Simulate cloud infrastructure and estimate cost before deploying or changing infrastructure.
Maintain this server? Claim it
Call this server's tools from your browser. Nothing to install.
Optional. Cloud World Model API key; unlocks all 63 authenticated tools. 9 keyless demo tools work without it.
Requests go through mcptry because browsers can't call most MCP servers directly. Header values are sent to the server for that request only and are never stored or logged.
Tool list from our last check. Connect live to refresh it.
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. For SQS Queue Backlog Saturation, the optional 5,000 RPS event burst is inactive by default and starts at step 6 after the five-step creation warm-up when enabled. simulation.create accepts scenarioOverrides.sqsQueueBacklogSaturation.includeEventBurst and an optional absolute eventBurstStartStep (integer 6–100000); omit the step to retain default step 6, and choose it before simulation.step finalizes replay identity. AWS Multi-Region Failover exposes characteristics.route53Failover: 10 simulated seconds per step, 10-second probes, three failures/recoveries and 60-second DNS TTL. West fails at evaluation currentTime 5 after creation warm-up through 59, returns at 60. Load reaches 2600 RPS at step 40 and holds. simulation.create accepts scenarioOverrides.awsMultiRegionFailover.includeRecoveryRamp (default true when supplied; absent override leaves recovery inactive), recoveryRampStartStep (absolute integer 40–100000, default 60), and dnsTtlSeconds (positive, at most 86400), selected before simulation.step. The likely next tool is simulation.create.
Scenario identifier returned by scenario.list
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. For SQS Queue Backlog Saturation, the optional 5,000 RPS event burst is inactive by default and starts at step 6 after the five-step creation warm-up when enabled. simulation.create accepts scenarioOverrides.sqsQueueBacklogSaturation.includeEventBurst and an optional absolute eventBurstStartStep (integer 6–100000); omit the step to retain default step 6, and choose it before simulation.step finalizes replay identity. AWS Multi-Region Failover exposes characteristics.route53Failover: 10 simulated seconds per step, 10-second probes, three failures/recoveries and 60-second DNS TTL. West fails at evaluation currentTime 5 after creation warm-up through 59, returns at 60. Load reaches 2600 RPS at step 40 and holds. simulation.create accepts scenarioOverrides.awsMultiRegionFailover.includeRecoveryRamp (default true when supplied; absent override leaves recovery inactive), recoveryRampStartStep (absolute integer 40–100000, default 60), and dnsTtlSeconds (positive, at most 86400), selected before simulation.step. The likely next tool is simulation.create.
| Argument | Type | Description |
|---|---|---|
| scenarioId* | string | Scenario identifier returned by scenario.list |
{
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"scenarioId"
],
"properties": {
"scenarioId": {
"type": "string",
"minLength": 1,
"description": "Scenario identifier returned by scenario.list"
}
},
"additionalProperties": false
}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.
| Argument | Type | Description |
|---|---|---|
| category | string | Only scenarios in this category, such as scaling, failure, reliability, networking, or cost |
| provider | string | Only scenarios that include resources from this cloud provider |
| difficulty | string | Only scenarios at this difficulty level |
{
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"properties": {
"category": {
"type": "string",
"minLength": 1,
"description": "Only scenarios in this category, such as scaling, failure, reliability, networking, or cost"
},
"provider": {
"enum": [
"aws",
"gcp",
"azure",
"oci",
"digitalocean"
],
"type": "string",
"description": "Only scenarios that include resources from this cloud provider"
},
"difficulty": {
"enum": [
"beginner",
"intermediate",
"advanced"
],
"type": "string",
"description": "Only scenarios at this difficulty level"
}
},
"additionalProperties": false
}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`. When copying a scenario graph that returns `autoscalingConfig`, pass that config to `simulation.create` too so its thresholds and cooldown are preserved. For AWS Multi-Region Failover, scenarioOverrides.awsMultiRegionFailover accepts includeRecoveryRamp (defaults true when the override is supplied), recoveryRampStartStep (absolute integer 40–100000, default 60), and dnsTtlSeconds (positive, at most 86400, default 60). Without an override the recovery ramp is inactive. Select overrides before the first simulation.step. scenario.get exposes characteristics.route53Failover: west fails at evaluation currentTime 5 after creation warm-up through 59, returns at 60; 10 simulated seconds per step, 10-second probes and three consecutive failures/recoveries. The ramp reaches 2600 RPS at step 40 and holds until recovery. For SQS Queue Backlog Saturation, set `scenarioOverrides: { sqsQueueBacklogSaturation: { includeEventBurst: true, eventBurstStartStep: 10 } }` to enable the optional 5,000 RPS burst and choose its absolute start step (integer 6–100000, after the five-step creation warm-up). Within this override, includeEventBurst defaults to true, so eventBurstStartStep alone enables the burst; without the override the burst stays inactive. Omit eventBurstStartStep to use catalog default step 6; select this scenario-only override before the first simulation.step so replay identity is unchanged. 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. For the Web App Autoscaling scenario, create with `scenarioId: "web-autoscaling"` and `scenarioOverrides: { webAutoscaling: { includeTrafficRecovery: true } }` to activate the optional Traffic Recovery ramp and observe scale-in. `includeTrafficRecovery` is optional and defaults to false, leaving the phase inactive. Opt in before the first simulation.step because replay identity is finalized when stepping starts. This override also requires scenarioId and is mutually exclusive with resources and connections. For Database Failover, create with `scenarioId: "db-failover"` and `scenarioOverrides: { dbFailover: { includeTrafficRecovery: true } }` to activate its optional Traffic Recovery ramp; it defaults to false. The scheduled primary-overload phase and ramp are shifted by the five-step creation warm-up. Select the override before the first simulation.step because replay identity is finalized when stepping starts. This override requires scenarioId and is mutually exclusive with resources and connections. For the Redis Cache Crash & Recovery scenario, create with `scenarioId: "redis-cache-crash-recovery"` and `scenarioOverrides: { redisCacheCrashRecovery: { cacheableRequestShare: 0.8, cacheHitRate: 0.8 } }` to set the request share sent to Redis and the configured hit rate among those requests (both fractions from 0 to 1; defaults are 0.8). The selected values are per-simulation and appear in normalizedConfig and per-step requestFlow metrics; they do not change the catalog scenario. Redis Cache Crash & Recovery starts at 5,000 RPS by default; an explicit simulation.create traffic value becomes the starting load, and the scenario has no active traffic pattern. Use simulation.inject_traffic to change load after stepping; this remains valid after replay identity finalizes. `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. Custom cache path: use a resource with type 'cache', characteristics.serviceFamily 'elasticache', cacheHitRate as a fraction (0.8, not 80) and optional cacheableRequestShare; connect the load balancer to each app server, each app server to the cache and to the database, and the cache to the database; use responseMode 'full' to see metrics.requestFlow. Use resilienceConfig.externalMetrics for deterministic sampled recommendations: no_ready_endpoints is successful zero only when its trigger sets noReadyEndpointsAsZero:true; discovery_error and fetch_error always remain errors. This is not a KEDA/provider actuator and does not change resource counts. 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→each app→DB connections, minInstances=maxInstances=2, autoscaling:false, traffic 20–300 RPS. Only typical-fit-20, typical-fit-100 and typical-fit-200 tuned the typical-v1-20260927c/6aa574d7ff9d3080b88b221bcd59f7d218ae37f0 fit; 300 is an independent holdout and 500 is diagnostic only. Other typical workloads are modeled, not owned. P99 has distinct per-percentile provenance: latencyP99Basis identifies the owned in-VPC internal-ALB fit, a scaled-from-fit estimate (not directly measured), or an uncalibrated generic model. On the exact healthy lean owned graph at 10–1,000 offered target RPS, P99=max(final P95, 7.021919127633514 + 0.00027013891327780484*T) ms; only 10/100/500 RPS were fit, 1,000 RPS was held out. Lean M5 scaling is not a new measurement; typical/heavy and active failures retain uncalibrated P99. predictionEvidence.latencyP99 has measured 0.65–1.35×, scaled 0.50–1.50× (beyond 1,000: 0.25–2×), or uncalibrated 0.50–2× (beyond: 0.25–3×) assumption bounds centered on final P99. These are not confidence intervals or provider measurements. Historical evidence may omit P99. latencyBasis describes the general modeled latency path; use latencyP99Basis specifically for P99. P99 is diagnostic, not scored. For compute, set characteristics.capacityRps for an explicit per-node RPS ceiling at which CPU reaches ~95%; do not use maxThroughput for that compute contract. Kubernetes rejects capacityRps: set maxThroughput for the total cluster RPS ceiling, or nodePools[].maxThroughput for per-node pool capacity. Omitted compute capacityRps uses the selected catalog tier and can intentionally produce a stressed baseline (for example, the AWS m5.large catalog denominator is 2,000 RPS); for a healthy, capacity-bounded compute experiment, declare an explicit per-node capacity such as 500 RPS. That value is an experiment control, not a universal hardware fact. For OCI flexible compute shapes, pass the documented positive integer characteristics.ocpus explicitly; VM.Standard.E4.Flex accepts 1–64 OCPUs and each OCPU maps to 2 vCPUs. OCPU count establishes capacity dimensions only, not provider-specific performance, throughput, or price. An uncounted flexible shape remains an unverified generic estimate. Check GET /api/prediction/generic-shapes for the catalog-derived generic fallback inventory. New prediction-only GCP standard capacity entries include e2-standard-2/4/8/16/32, n1-standard-1/2/4/8/16/32/64/96, and n2-standard-16/32/48/64/80/96/128; provider specifications establish vCPU/memory dimensions, not CWM performance or pricing. Version 1 predictionEvidence explicitly reports legacyGeneric at the top level and on every appCpuByResource item; its note identifies each generic resource's shape and fallback reason. For generic fixed compute, characteristics.instanceCount accepts integer 1–100 represented VMs; capacity aggregates and CPU is per VM. Do not combine it with autoscaling:true, minInstances, or maxInstances. Aurora Serverless v2 remains limited to 1 with multiAz:false or 2 with multiAz:true. For Aurora Serverless ACU limits, use characteristics.config.minCapacity/maxCapacity or flat characteristics.minCapacity/maxCapacity. The exact AWS database shape with serviceFamily: 'aurora-serverless' and size: 'db.serverless' also accepts flat characteristics.minAcu/maxAcu; those aliases are rejected elsewhere, including at the resource root or inside config. For that shape, multiAz:true with instanceCount:2 creates a separately billable reader (<writer-id>-reader) in another AZ. Inspect returned resources and metrics before using simulation.step to observe modeled failover; no AWS timing guarantee is implied. For database connection budgets, set characteristics.connectionDemand on a database: {mode:'declared',declaredConnections:240} uses that plan-time demand without RPS; {mode:'max',declaredConnections:240,idlePoolFloor:200} takes the maximum of load-derived demand and the declared/floor values; omitted configuration preserves load-derived behavior. declaredConnections and idlePoolFloor are ASSUMPTIONS / plan-time budgets (for example, replicas × per-pod pool size), not observed live DB connections. Set maxConnections to the usable limit you intend to test. Per-database metrics report connectionDemandMode, loadDerivedConnections, declaredConnections/idlePoolFloor, and modeledConnections; cost and DB CPU/latency remain based on existing load-driven behavior. Demand above the usable limit adds a bounded, rule-based pool-saturation error signal; it is not a provider-calibrated rate. Capacity, node-bound, SKU, and autoscaling values supplied through this MCP tool are recorded as agent-supplied in the immutable normalizationReceipt; request responseMode: 'full' to inspect it. Generic GKE telemetry and recovery apply only to worker nodes; the control-plane management fee is cost-only, with no modeled control-plane CPU, API throttling, or cooldown. To bound the autoscaled fleet size, set the top-level maxInstances / minInstances parameters. If you do not set maxInstances, the engine uses the provider default — AWS 50, GCP 15, Azure/OCI/DigitalOcean 10 — which may be much larger than your intended fleet size. The response includes effectiveMaxInstances / effectiveMinInstances so you can confirm the bounds that will be enforced. For a targeted CPU HPA scale-out threshold, send the canonical autoscalingTargetCpu field in this create call (for example, autoscalingTargetCpu: 70 for GKE). The compatible aliases scaleOutCpuThreshold, scaleOutCpuPercent, and autoscaleTargetCpuPercent are also accepted; if more than one is sent, their values must agree. Every create response includes hpaAudit with the supplied field, persisted thresholds, and any provider default. For ECS Fargate CPU-only target tracking, set ecsCpuTargetTracking: true, autoscalingTargetCpu, minInstances/maxInstances, and optional scaleOutCooldownSeconds/scaleInCooldownSeconds with simulationSecondsPerStep (default 1). Inspect autoscalingConfig in the compact response or applicationAutoscalingPolicy in the full response. Latency and throughput do not trigger ECS scaling in this mode. These four TOP-LEVEL fields are simulation-wide — the engine applies one CPU threshold identically to every resource's scale decision by default. To make ONE resource scale at a different CPU target than the rest of the simulation (e.g. a GKE cluster scaling out at 60% while an EC2 fleet in the same simulation scales out at 80%), set characteristics.scaleOutCpuThreshold and/or characteristics.scaleInCpuThreshold on that specific resource instead — the per-resource value wins over the simulation-wide default for that resource only. A misnamed near-miss field nested under characteristics (e.g. targetCPUUtilizationPercentage) is rejected with a 400 explaining the correct field name — it is never silently dropped and defaulted. Responses are compact by default: id, name, status, traffic, and a per-resource summary (id, name, status, cpuPercent, routedRps, availabilityState, isRoutable, and recoveryBlockedReason when provided). Pass responseMode: 'full' to get the complete simulation object instead. During a failure workflow, lower traffic to serviceable levels before calling simulation.recover_resource, then use simulation.step until the recovered resource is healthy. Recovery progress is included when applicable: recoveryProgress.state is parked, cooling_down, or healthy, and its parkWindow/cooldown objects report totalSteps, completedSteps, remainingSteps, target, and requiredSteps. Poll simulation.step until state is healthy, then use simulation.metrics to inspect the resulting state and metrics. No prerequisites. Returns the created simulation's id, which every other simulation.* tool consumes; the new simulation also becomes this session's current simulation, so subsequent per-simulation tools may omit simulationId. The likely next tool is simulation.step to advance time. Do not call api.spec to learn the simulation workflow — the tool descriptions in this session contain everything needed. Authenticate with an API key for unlimited persistent simulations.
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 64 tools and persistent simulation management.
| Argument | Type | Description |
|---|---|---|
| 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 example Grok Bot or Cursor), pass this explicit ID after every fresh initialization. A fresh session has no current-simulation pointer and returns NO_ACTIVE_SIMULATION when the ID is omitted. Anonymous capabilities are short-lived (30 minutes by default), unguessable, and revoked when the demo expires or is deleted; proxy IP changes do not invalidate them. Do not treat the ID as a durable share link. |
{
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"properties": {
"simulationId": {
"type": "string",
"description": "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 example Grok Bot or Cursor), pass this explicit ID after every fresh initialization. A fresh session has no current-simulation pointer and returns NO_ACTIVE_SIMULATION when the ID is omitted. Anonymous capabilities are short-lived (30 minutes by default), unguessable, and revoked when the demo expires or is deleted; proxy IP changes do not invalidate them. Do not treat the ID as a durable share link."
}
},
"additionalProperties": false
}Fail one compute/Kubernetes node, database, or cache 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 a database or cache 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 or cache must be healthy; an already failed database or cache 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 replay; always target by name/id when reproducing a precise fault sequence. The response always echoes the applied outcome via resolvedResourceId, resolvedResourceName, and previousHealth (populated from the selected resource on the random path too). Network, storage, queue, and security resource types are not supported by quick injection. Cache failures are supported and recoverable with simulation.recover_resource. For typed database_overload use authenticated failure.create (unavailable anonymously); instance_kill PERMANENTLY removes the instance — failure.delete does not restore it; use instance_down instead for a reversible single-node outage. Returns the updated resource list and the failure event that was logged. The likely next tool is simulation.step to observe how the architecture degrades under failure, then simulation.metrics to review the health impact. Do not use it to advance simulation time — that is simulation.step. Pass simulationId from simulation.create when this call is made from a fresh MCP session; otherwise you may omit it to target the current simulation in the preserved MCP session. Authenticate with an API key to unlock all 64 tools including typed durational failures and chaos engineering.
Change traffic on a demo simulation using targetRps, deltaPercent, or explicit random: true. targetRps takes precedence over deltaPercent; random cannot be combined with either. Missing or unknown selectors are rejected, and no random spike is selected implicitly. Absolute targets are capped at 10000 RPS in demo mode. The change affects metrics after the next simulation.step. For Redis Cache Crash & Recovery, the default 5,000 RPS load has no active pattern, so this controlled traffic update also works after replay identity finalizes. 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.
| Argument | Type | Description |
|---|---|---|
| random | boolean | Explicitly select a random stress spike; never selected implicitly. |
| targetRps | integer | Absolute traffic level in RPS to set. Server-capped at 10000 RPS in demo mode. |
| deltaPercent | number | Relative traffic change; must be greater than -100. |
| 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 example Grok Bot or Cursor), pass this explicit ID after every fresh initialization. A fresh session has no current-simulation pointer and returns NO_ACTIVE_SIMULATION when the ID is omitted. Anonymous capabilities are short-lived (30 minutes by default), unguessable, and revoked when the demo expires or is deleted; proxy IP changes do not invalidate them. Do not treat the ID as a durable share link. |
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-only; repeated calls may be subject to demo usage limits. The likely next tool is simulation.step or simulation.inject_traffic.
| Argument | Type | Description |
|---|---|---|
| responseMode |
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 64 tools and unlimited simulations.
| Argument | Type | Description |
|---|---|---|
| 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 example Grok Bot or Cursor), pass this explicit ID after every fresh initialization. A fresh session has no current-simulation pointer and returns NO_ACTIVE_SIMULATION when the ID is omitted. Anonymous capabilities are short-lived (30 minutes by default), unguessable, and revoked when the demo expires or is deleted; proxy IP changes do not invalidate them. Do not treat the ID as a durable share link. |
{
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"properties": {
"resourceId": {
"type": "string",
"description": "ID of the failed resource to recover"
},
"resourceName": {
"type": "string",
"description": "Exact case-insensitive name of the failed resource to recover"
},
"simulationId": {
"type": "string",
"description": "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 example Grok Bot or Cursor), pass this explicit ID after every fresh initialization. A fresh session has no current-simulation pointer and returns NO_ACTIVE_SIMULATION when the ID is omitted. Anonymous capabilities are short-lived (30 minutes by default), unguessable, and revoked when the demo expires or is deleted; proxy IP changes do not invalidate them. Do not treat the ID as a durable share link."
}
},
"additionalProperties": false
}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. An optional traffic override is applied when no traffic pattern is active; with an active pattern it is rejected with STEP_TRAFFIC_PATTERN_ACTIVE. Use simulation.inject_traffic to change load; it deactivates patterns before replay finalization and uses a runtime-only override for finalized SQS backlog runs, or omit traffic to follow the schedule. 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; unavailable identifies a failed or parked node, while scaled_to_zero and cold_start identify Fargate no-task states. Pass responseMode: 'full' to get the complete simulation state instead. During recovery, each resource may include recoveryProgress with state parked, cooling_down, or healthy, plus parkWindow and cooldown counters. Poll simulation.step until the targeted resource's recoveryProgress.state is 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, each step response also includes gpuUtilization (%), tokensPerSecond, costPerMillionTokens (USD/M tokens), idleGpuCostPerHour (USD/hr of standby GPU spend), and idleGpuFraction (0-1 idle HA overhead share) so you can track inference economics step by step. Authenticate with an API key for unlimited steps and GPU right-sizing hints.
| Argument | Type | Description |
|---|---|---|
| name* | string | Human-readable name for the simulation |
| seed | integer | Deterministic RNG seed for reproducible replays |
| traffic | number | Initial traffic in requests per second (RPS) |
| 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 reports per-quantity provenance and assumption ranges, not confidence intervals. |
| 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 with scenarioId) |
| scenarioId | string | Live scenario identifier from scenario.list; mutually exclusive with resources and connections |
| 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 between resources; omit when using scenarioId. |
| description | string | Optional description of the simulation's purpose |
| 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 larger than your intended fleet size. |
| minInstances | integer | Floor on the autoscaled compute fleet size, stored as autoscalingConfig.minInstances. |
| 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 complete simulation object including all resource characteristics and connections. |
| resilienceConfig | object | Optional retry/cascade resilience model returned by scenario.get. externalMetrics accepts deterministic sampled triggers; no_ready_endpoints is successful zero only when noReadyEndpointsAsZero:true, while discovery_error and fetch_error remain errors. This recommendation model does not actuate KEDA, providers, or simulated resource counts. |
| autoscalingConfig | object | Simulation autoscaling thresholds and cooldown. Pass the value from scenario.get when creating from a copied scenario graph. |
| scenarioOverrides | any | Scenario-only customization; requires scenarioId and exactly one supported override. SQS event-burst start is an absolute post-warm-up step and must be selected before the first simulation.step. Redis cache assumptions affect only this simulation. |
| scaleOutCpuPercent | 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. |
| ecsCpuTargetTracking | boolean | Opt into CPU-only ECS Fargate target tracking. |
| scaleOutCpuThreshold | number | Equivalent alias for autoscalingTargetCpu; if both are sent they must match. |
| scaleInCooldownSeconds | integer | ECS CPU target-tracking scale-in cooldown in simulated seconds. |
| scaleOutCooldownSeconds | integer | ECS CPU target-tracking scale-out cooldown in simulated seconds. |
| simulationSecondsPerStep | number | Simulated seconds per step for ECS cooldowns (default 1). |
| autoscaleTargetCpuPercent | number | Grok-compatible alias for the CPU HPA scale-out target; if multiple target names are sent they must match. |
{
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"name"
],
"properties": {
"name": {
"type": "string",
"maxLength": 120,
"description": "Human-readable name for the simulation"
},
"seed": {
"type": "integer",
"minimum": 0,
"description": "Deterministic RNG seed for reproducible replays"
},
"traffic": {
"type": "number",
"default": 0,
"description": "Initial traffic in requests per second (RPS)"
},
"appWeight": {
"enum": [
"lean",
"typical",
"heavy"
],
"type": "string",
"description": "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 reports per-quantity provenance and assumption ranges, not confidence intervals."
},
"resources": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"type",
"name"
],
"properties": {
"id": {
"type": "string",
"description": "Unique identifier for this resource within the simulation"
},
"name": {
"type": "string",
"description": "Display name for the resource"
},
"type": {
"enum": [
"compute",
"database",
"storage",
"network",
"cache",
"queue",
"kubernetes"
],
"type": "string",
"description": "Resource category"
},
"maxAcu": {
"description": "Not accepted at resource level; use characteristics.maxAcu for the exact AWS Aurora Serverless v2 db.serverless shape."
},
"minAcu": {
"description": "Not accepted at resource level; use characteristics.minAcu for the exact AWS Aurora Serverless v2 db.serverless shape."
},
"location": {
"type": "object",
"required": [
"regionKey"
],
"properties": {
"zoneKey": {
"type": "string"
},
"regionKey": {
"type": "string"
},
"localityType": {
"enum": [
"az",
"zone",
"availability_domain",
"fault_domain"
],
"type": "string"
},
"providerLabel": {
"type": "string"
},
"faultDomainKey": {
"type": "string"
}
},
"description": "Resource region; set location.regionKey:'us-east-2' on each owned typical node (normalized to use2).",
"additionalProperties": false
},
"provider": {
"enum": [
"aws",
"gcp",
"azure",
"oci",
"digitalocean"
],
"type": "string",
"default": "aws",
"description": "Cloud provider hosting this resource"
},
"recoveryPolicy": {
"type": "object",
"properties": {
"warningSteps": {
"type": "integer",
"minimum": 1
},
"criticalSteps": {
"type": "integer",
"minimum": 1
},
"failureParkSteps": {
"type": "integer",
"minimum": 1
},
"warningCpuThreshold": {
"type": "number",
"maximum": 100,
"minimum": 0
},
"criticalCpuThreshold": {
"type": "number",
"maximum": 100,
"minimum": 0
}
},
"description": "Optional recovery thresholds and cooldown lengths for this resource",
"additionalProperties": false
},
"characteristics": {
"type": "object",
"properties": {
"size": {
"type": "string",
"description": "Instance or SKU size (e.g. 't3.medium', 'db.r5.large')"
},
"ocpus": {
"type": "integer",
"maximum": 126,
"description": "OCI flexible compute shape capacity. Family-specific limits are validated against the provider shape; VM.Standard.E4.Flex accepts 1–64 OCPUs and 1 OCPU = 2 vCPUs. Not a performance or price claim.",
"exclusiveMinimum": 0
},
"config": {
"type": "object",
"properties": {
"maxCapacity": {
"type": "number",
"exclusiveMinimum": 0
},
"minCapacity": {
"type": "number",
"exclusiveMinimum": 0
}
},
"description": "Aurora Serverless ACU bounds. Nested config uses minCapacity/maxCapacity; flat characteristics.minAcu/maxAcu aliases are accepted only on the exact AWS Aurora Serverless v2 db.serverless shape.",
"additionalProperties": true
},
"maxAcu": {
"type": "number",
"description": "Flat maximum ACU alias only for AWS Aurora Serverless v2 size db.serverless; conflicts with maxCapacity are rejected.",
"exclusiveMinimum": 0
},
"minAcu": {
"type": "number",
"description": "Flat minimum ACU alias only for AWS Aurora Serverless v2 size db.serverless; conflicts with minCapacity are rejected.",
"exclusiveMinimum": 0
},
"multiAz": {
"type": "boolean",
"description": "AWS Aurora Serverless v2: true with instanceCount:2 creates a billable reader in a second AZ."
},
"workload": {
"enum": [
"crud",
"crud-typical"
],
"type": "string",
"description": "Explicit 'crud-typical' on each owned typical app; 'crud' selects lean identity on the exact lean graph."
},
"appRuntime": {
"type": "string",
"description": "Owned typical app runtime: node."
},
"capacityGB": {
"type": "number",
"description": "Storage capacity in GB — drives per-GB snapshot/backup idle cost and stopped-instance storage cost"
},
"cdnTraffic": {
"type": "object",
"required": [
"cacheableFraction",
"cacheableMissDatabaseFraction",
"dynamicDatabaseFraction"
],
"properties": {
"cacheableFraction": {
"type": "number",
"maximum": 1,
"minimum": 0
},
"dynamicDatabaseFraction": {
"type": "number",
"maximum": 1,
"minimum": 0
},
"cacheableMissDatabaseFraction": {
"type": "number",
"maximum": 1,
"minimum": 0
}
},
"description": "Assumed CDN cacheable/dynamic request mix and DB-query fractions. cacheHitRate applies only to the cacheable share. Read simulation.step metrics.cdnFlow for the modeled edge, origin and database flow.",
"additionalProperties": false
},
"autoscaling": {
"type": "boolean",
"description": "Mark this compute resource as the autoscaling primary target"
},
"capacityRps": {
"type": "number",
"description": "Compute only: literal per-node RPS ceiling at which CPU reaches ~95%. Kubernetes rejects capacityRps; use maxThroughput for its total cluster ceiling.",
"exclusiveMinimum": 0
},
"maxCapacity": {
"type": "number",
"description": "Aurora Serverless maximum ACU (flat form; nested config wins).",
"exclusiveMinimum": 0
},
"minCapacity": {
"type": "number",
"description": "Aurora Serverless minimum ACU (flat form; nested config wins).",
"exclusiveMinimum": 0
},
"billingState": {
"enum": [
"active",
"idle",
"stopped",
"detached",
"deleted"
],
"type": "string",
"description": "Billing state: 'stopped' bills storage only, 'idle'/'detached' bill flat idle rates, 'deleted' bills nothing. Default 'active'."
},
"cacheHitRate": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "Cache only: fraction (0–1) of requests routed through this cache that are served from cache; 0.8 means an 80% hit rate."
},
"appDbPoolSize": {
"type": "integer",
"description": "Owned typical: pool size 250 on each app.",
"exclusiveMinimum": 0
},
"instanceCount": {
"type": "integer",
"maximum": 100,
"minimum": 1,
"description": "Generic fixed compute: represented VM count (integer 1–100); capacity aggregates and CPU is per VM. Cannot combine with autoscaling:true, minInstances, or maxInstances. AWS Aurora Serverless v2 remains 1 with multiAz:false or 2 with multiAz:true."
},
"maxThroughput": {
"type": "number",
"description": "Kubernetes: total cluster RPS ceiling; compute: legacy internal throughput scaling parameter (prefer capacityRps for compute)."
},
"serviceFamily": {
"type": "string",
"description": "Idle-billed service family (e.g. 'nat-gateway', 'vpc-endpoint', 'eip-detached', 'ebs-snapshot') — determines the flat idle rate"
},
"appWorkerCount": {
"type": "integer",
"description": "Owned typical: 2 workers on each app.",
"exclusiveMinimum": 0
},
"maxConnections": {
"type": "integer",
"maximum": 1000000,
"description": "Fixed concurrent DB connection budget; Aurora Serverless defaults from maximum configured ACU.",
"exclusiveMinimum": 0
},
"route53Failover": {
"type": "object",
"required": [
"primaryRegion",
"secondaryRegion"
],
"properties": {
"dnsTtlSeconds": {
"type": "number",
"default": 60,
"maximum": 86400,
"exclusiveMinimum": 0
},
"primaryRegion": {
"type": "string",
"minLength": 1
},
"secondaryRegion": {
"type": "string",
"minLength": 1
},
"failureThreshold": {
"type": "integer",
"default": 3,
"exclusiveMinimum": 0
},
"recoveryThreshold": {
"type": "integer",
"default": 3,
"exclusiveMinimum": 0
},
"primaryTrafficShare": {
"type": "number",
"default": 0.5,
"maximum": 1,
"minimum": 0
},
"simulationSecondsPerStep": {
"type": "number",
"default": 10,
"exclusiveMinimum": 0
},
"healthCheckIntervalSeconds": {
"type": "number",
"default": 10,
"exclusiveMinimum": 0
}
},
"additionalProperties": false
},
"sessionAffinity": {
"type": "object",
"required": [
"mode",
"fleetId"
],
"properties": {
"mode": {
"type": "string",
"const": "sticky"
},
"fleetId": {
"type": "string",
"maxLength": 128,
"minLength": 1
},
"workload": {
"type": "object",
"required": [
"replicas",
"minReplicas",
"maxReplicas",
"capacityRpsPerReplica"
],
"properties": {
"replicas": {
"type": "integer",
"maximum": 10000,
"minimum": 1
},
"autoscaling": {
"type": "boolean",
"default": true
},
"maxReplicas": {
"type": "integer",
"maximum": 10000,
"minimum": 1
},
"minReplicas": {
"type": "integer",
"maximum": 10000,
"minimum": 1
},
"targetCpuPercent": {
"type": "number",
"default": 70,
"maximum": 100,
"minimum": 1
},
"capacityRpsPerReplica": {
"type": "number",
"exclusiveMinimum": 0
}
},
"additionalProperties": false
},
"reconnect": {
"enum": [
"none",
"next-step"
],
"type": "string",
"default": "none"
},
"arrivalsPerStep": {
"type": "number",
"default": 0,
"minimum": 0
},
"initialSessions": {
"type": "number",
"default": 100,
"minimum": 0
},
"meanLifetimeSteps": {
"type": "number",
"default": 300,
"minimum": 1
},
"maxSessionsPerOwner": {
"type": "number",
"default": 1000,
"exclusiveMinimum": 0
},
"requestsPerSessionPerSecond": {
"type": "number",
"default": 1,
"exclusiveMinimum": 0
}
},
"description": "Opt-in modeled sticky owners for generic compute; Kubernetes requires explicit workload replicas independent of nodes. Use identical fleetId/config on compute peers. Existing sessions do not migrate on scale-out; owner loss disconnects them. reconnect:'next-step' explicitly enables rebinding; default none. Session arrivals/lifetime are assumptions, not measured OpenShell data. Read full step metrics.sessionAffinity for per-owner load, rejects and disconnects.",
"additionalProperties": false
},
"connectionDemand": {
"type": "object",
"required": [
"mode"
],
"properties": {
"mode": {
"enum": [
"load-derived",
"declared",
"max"
],
"type": "string",
"description": "load-derived keeps the legacy traffic estimate; declared uses only the plan-time declaredConnections/idlePoolFloor; max uses the greatest of load-derived and declared/floor demand."
},
"idlePoolFloor": {
"type": "integer",
"maximum": 1000000,
"minimum": 0,
"description": "ASSUMPTION / plan-time minimum idle pool footprint, not an observed live connection count."
},
"declaredConnections": {
"type": "integer",
"maximum": 1000000,
"minimum": 0,
"description": "ASSUMPTION / plan-time peak pool budget (for example, replicas × per-pod pool size), not an observed live connection count."
}
},
"description": "Database only. Omit to preserve legacy load-derived connection use. `declared` and `max` require declaredConnections and/or idlePoolFloor. Demand above usable maxConnections adds a bounded rule-based pool-saturation error signal, not a provider-calibrated rate.",
"additionalProperties": false
},
"kubernetesCpuHpa": {
"type": "object",
"required": [
"cpuDemandMilliCoresPerRps",
"targets",
"replicas",
"minReplicas",
"maxReplicas"
],
"properties": {
"targets": {
"type": "array",
"items": {
"anyOf": [
{
"type": "object",
"required": [
"type",
"targetPercent"
],
"properties": {
"type": {
"type": "string",
"const": "Utilization"
},
"targetPercent": {
"type": "number",
"maximum": 1000,
"exclusiveMinimum": 0
}
},
"additionalProperties": false
},
{
"type": "object",
"required": [
"type",
"targetMilliCores"
],
"properties": {
"type": {
"type": "string",
"const": "AverageValue"
},
"targetMilliCores": {
"type": "number",
"maximum": 100000,
"exclusiveMinimum": 0
}
},
"additionalProperties": false
}
]
},
"maxItems": 2,
"minItems": 1
},
"replicas": {
"type": "integer",
"maximum": 10000,
"minimum": 1
},
"maxReplicas": {
"type": "integer",
"maximum": 10000,
"minimum": 1
},
"minReplicas": {
"type": "integer",
"maximum": 10000,
"minimum": 1
},
"cpuDemandEvidence": {
"$ref": "#/properties/resources/items/properties/characteristics/properties/kubernetesCpuHpa/properties/cpuRequestEvidence"
},
"cpuRequestEvidence": {
"type": "object",
"required": [
"source",
"reference"
],
"properties": {
"source": {
"enum": [
"calibrated",
"external"
],
"type": "string"
},
"reference": {
"type": "string",
"maxLength": 512,
"minLength": 1
}
},
"additionalProperties": false
},
"cpuDemandCalibration": {
"type": "object",
"required": [
"method",
"reviewed",
"measurements"
],
"properties": {
"method": {
"type": "string",
"const": "least-squares-through-origin"
},
"reviewed": {
"type": "boolean",
"const": true
},
"measurements": {
"type": "array",
"items": {
"type": "object",
"required": [
"rps",
"cpuMilliCores"
],
"properties": {
"rps": {
"type": "number",
"maximum": 1000000,
"exclusiveMinimum": 0
},
"cpuMilliCores": {
"type": "number",
"maximum": 1000000000,
"minimum": 0
}
},
"additionalProperties": false
},
"maxItems": 100,
"minItems": 2
}
},
"additionalProperties": false
},
"cpuRequestMilliCores": {
"type": "number",
"maximum": 100000,
"exclusiveMinimum": 0
},
"cpuDemandMilliCoresPerRps": {
"type": "number",
"maximum": 1000000,
"exclusiveMinimum": 0
},
"scaleDownStabilizationSteps": {
"type": "integer",
"maximum": 10000,
"minimum": 1
}
},
"description": "Opt-in bounded workload-pod replica model, separate from node-pool scaling. Declare CPU demand in millicores/RPS and targets (Utilization requires an explicit CPU request). A reviewed cpuDemandCalibration may include 2–100 offered-RPS/aggregate-mCPU points and must match the explicit demand value; cite its source and reference in cpuDemandEvidence. Unannotated request/demand inputs are ASSUMED; no HPA controller parity is claimed.",
"additionalProperties": false
},
"loadBalancerScheme": {
"enum": [
"internal",
"internet-facing"
],
"type": "string",
"description": "Owned typical ALB scheme: internal."
},
"scaleInCpuThreshold": {
"type": "number",
"maximum": 100,
"minimum": 0,
"description": "Compute or Kubernetes only — overrides the simulation-wide CPU HPA scale-in target for THIS resource's scale decisions only; every other resource keeps the simulation-wide default."
},
"scaleOutCpuThreshold": {
"type": "number",
"maximum": 100,
"minimum": 0,
"description": "Compute or Kubernetes only — overrides the simulation-wide CPU HPA scale-out target (see the top-level autoscalingTargetCpu) for THIS resource's scale decisions only; every other resource keeps the simulation-wide default."
},
"cacheableRequestShare": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "Cache only: fraction (0–1) of offered requests routed through this cache; when omitted on a connected cache path, all synchronous non-queued traffic is assumed cacheable."
},
"workloadDatabaseEngine": {
"enum": [
"mysql"
],
"type": "string",
"description": "MySQL workload identity on the db.r5.large database."
},
"workloadDatabaseVersion": {
"type": "string",
"description": "Owned typical MySQL workload version: 8.0."
}
},
"description": "Capacity and sizing characteristics for the resource (extra keys such as costMultiplier pass through unchanged)",
"additionalProperties": true
}
},
"additionalProperties": false
},
"description": "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 with scenarioId)"
},
"scenarioId": {
"type": "string",
"minLength": 1,
"description": "Live scenario identifier from scenario.list; mutually exclusive with resources and connections"
},
"connections": {
"type": "array",
"items": {
"type": "object",
"required": [
"sourceId",
"targetId"
],
"properties": {
"label": {
"type": "string",
"description": "Optional label describing the connection type"
},
"sourceId": {
"type": "string",
"description": "ID of the source (upstream) resource"
},
"targetId": {
"type": "string",
"description": "ID of the target (downstream) resource"
}
},
"additionalProperties": false
},
"description": "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 between resources; omit when using scenarioId."
},
"description": {
"type": "string",
"maxLength": 500,
"description": "Optional description of the simulation's purpose"
},
"maxInstances": {
"type": "integer",
"minimum": 1,
"description": "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 larger than your intended fleet size."
},
"minInstances": {
"type": "integer",
"minimum": 1,
"description": "Floor on the autoscaled compute fleet size, stored as autoscalingConfig.minInstances."
},
"responseMode": {
"enum": [
"compact",
"full"
],
"type": "string",
"default": "compact",
"description": "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 complete simulation object including all resource characteristics and connections."
},
"resilienceConfig": {
"type": "object",
"properties": {
"enabled": {
"type": "boolean",
"description": "Master switch for retry/cascade modeling"
},
"version": {
"type": "number",
"const": 1,
"description": "Resilience model version"
},
"maxStepWork": {
"type": "integer",
"maximum": 2048,
"minimum": 1
},
"podServices": {
"type": "array",
"items": {
"type": "object",
"required": [
"resourceId",
"replicas",
"perPodCapacityRps"
],
"properties": {
"replicas": {
"type": "integer",
"maximum": 1000,
"minimum": 0
},
"readiness": {
"type": "object",
"default": {},
"properties": {
"failureThreshold": {
"type": "integer",
"default": 1,
"maximum": 20,
"minimum": 1
},
"successThreshold": {
"type": "integer",
"default": 1,
"maximum": 20,
"minimum": 1
},
"startupDelaySeconds": {
"type": "number",
"default": 0,
"maximum": 3600,
"minimum": 0
},
"readinessProbePeriodSeconds": {
"type": "integer",
"default": 1,
"maximum": 300,
"minimum": 1
}
},
"additionalProperties": false
},
"resourceId": {
"type": "string",
"maxLength": 128,
"minLength": 1
},
"termination": {
"type": "object",
"default": {},
"properties": {
"preStopSeconds": {
"type": "number",
"default": 0,
"maximum": 3600,
"minimum": 0
},
"inflightDrainBehavior": {
"enum": [
"finish",
"drop-at-sigkill"
],
"type": "string",
"default": "finish"
},
"requestDurationSeconds": {
"type": "number",
"default": 0,
"maximum": 3600,
"minimum": 0
},
"terminationGracePeriodSeconds": {
"type": "number",
"default": 30,
"maximum": 3600,
"minimum": 0
}
},
"additionalProperties": false
},
"initialReady": {
"type": "boolean",
"default": true
},
"rollingUpdate": {
"type": "object",
"required": [
"startStep"
],
"properties": {
"maxSurge": {
"type": "integer",
"default": 1,
"maximum": 1000,
"minimum": 0
},
"startStep": {
"type": "integer",
"maximum": 100000,
"minimum": 0
},
"maxUnavailable": {
"type": "integer",
"default": 0,
"maximum": 1000,
"minimum": 0
}
},
"additionalProperties": false
},
"replicaChanges": {
"type": "array",
"items": {
"type": "object",
"required": [
"step",
"replicas"
],
"properties": {
"step": {
"type": "integer",
"maximum": 100000,
"minimum": 0
},
"replicas": {
"type": "integer",
"maximum": 1000,
"minimum": 0
}
},
"additionalProperties": false
},
"default": [],
"maxItems": 100
},
"readinessChanges": {
"type": "array",
"items": {
"type": "object",
"required": [
"step",
"passing"
],
"properties": {
"step": {
"type": "integer",
"maximum": 100000,
"minimum": 0
},
"passing": {
"type": "boolean"
}
},
"additionalProperties": false
},
"default": [],
"maxItems": 100
},
"perPodCapacityRps": {
"type": "number",
"maximum": 1000000,
"exclusiveMinimum": 0
},
"endpointPropagation": {
"type": "object",
"default": {},
"properties": {
"addDelaySeconds": {
"type": "number",
"default": 0,
"maximum": 3600,
"minimum": 0
},
"removeDelaySeconds": {
"type": "number",
"default": 0,
"maximum": 3600,
"minimum": 0
}
},
"additionalProperties": false
},
"hpaUnreadyPodPolicy": {
"enum": [
"excluded",
"zero",
"target"
],
"type": "string",
"default": "excluded"
}
},
"additionalProperties": false
},
"maxItems": 32,
"minItems": 1,
"description": "Opt-in generic pod lifecycle by resourceId: explicit replicas/perPodCapacityRps, readiness/probe thresholds, endpoint add/remove delays, termination preStop/grace/inflight drain, HPA unready policy, replicaChanges/readinessChanges and rollingUpdate startStep/maxSurge/maxUnavailable. Times are simulated seconds (one ordinary step); full metrics expose resilience.podServices, compact exposes resilienceDiagnostics.podServices. No controller/proxy parity."
},
"dependencies": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"sourceId",
"targetId"
],
"properties": {
"id": {
"type": "string",
"maxLength": 128,
"minLength": 1,
"description": "Unique dependency edge ID"
},
"capacity": {
"type": "object",
"properties": {
"maxRps": {
"type": "number",
"maximum": 500000,
"exclusiveMinimum": 0
},
"maxConcurrent": {
"type": "integer",
"maximum": 1000000,
"exclusiveMinimum": 0
},
"meanServiceTimeMs": {
"type": "number",
"maximum": 120000,
"exclusiveMinimum": 0
}
},
"additionalProperties": false
},
"sourceId": {
"type": "string",
"minLength": 1,
"description": "Upstream resource ID"
},
"targetId": {
"type": "string",
"minLength": 1,
"description": "Downstream resource ID"
},
"protection": {
"type": "object",
"properties": {
"loadShedding": {
"type": "boolean"
},
"rateLimitRps": {
"type": "number",
"maximum": 500000,
"exclusiveMinimum": 0
},
"circuitBreaker": {
"type": "object",
"properties": {
"enabled": {
"type": "boolean"
},
"openSteps": {
"type": "integer",
"maximum": 120,
"minimum": 1
},
"minimumRequests": {
"type": "integer",
"maximum": 100000,
"minimum": 1
},
"halfOpenMaxRequests": {
"type": "integer",
"maximum": 10000,
"minimum": 1
},
"failureRateThreshold": {
"type": "number",
"maximum": 1,
"minimum": 0
}
},
"additionalProperties": false
}
},
"additionalProperties": false
},
"retryPolicy": {
"type": "object",
"properties": {
"backoffMs": {
"type": "integer",
"maximum": 60000,
"minimum": 0,
"description": "Initial retry backoff in milliseconds (default 100)."
},
"timeoutMs": {
"type": "integer",
"maximum": 120000,
"minimum": 1,
"description": "Per-attempt client deadline in milliseconds (default 2000); includes queue wait, service, and latency."
},
"maxRetries": {
"type": "integer",
"maximum": 8,
"minimum": 0,
"description": "Maximum retries for this dependency edge (0 disables retries; default 2)."
},
"jitterRatio": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "Fractional backoff jitter from 0 to 1 (default 0.1)."
},
"retryActorId": {
"type": "string",
"maxLength": 128,
"minLength": 1,
"description": "Actor producing retries, such as a gateway or client"
},
"retryBudgetRps": {
"type": "number",
"maximum": 500000,
"minimum": 0,
"description": "Optional absolute retry RPS cap, also bounded by retryBudgetRatio."
},
"retryBudgetRatio": {
"type": "number",
"maximum": 10,
"minimum": 0,
"description": "Retry RPS budget as a multiple of original edge RPS (default 2)."
},
"backoffMultiplier": {
"type": "number",
"maximum": 10,
"minimum": 1,
"description": "Exponential backoff multiplier (default 2)."
}
},
"additionalProperties": false
},
"requestRatio": {
"type": "number",
"maximum": 20,
"minimum": 0,
"description": "Requests to target per original request"
},
"authDependencyId": {
"type": "string",
"maxLength": 128,
"minLength": 1,
"description": "Dependency receiving generated auth/token traffic"
},
"authRequestsPerAttempt": {
"type": "number",
"maximum": 10,
"minimum": 0,
"description": "Auth/token requests generated per dependency attempt"
}
},
"additionalProperties": false
},
"maxItems": 64,
"description": "Dependency edges with retry and protection policies"
},
"externalMetrics": {
"type": "object",
"required": [
"errorMode",
"initialCapacity",
"triggers"
],
"properties": {
"triggers": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"targetValue",
"samples"
],
"properties": {
"id": {
"type": "string",
"maxLength": 128,
"minLength": 1
},
"samples": {
"type": "array",
"items": {
"anyOf": [
{
"type": "object",
"required": [
"step",
"status",
"value"
],
"properties": {
"step": {
"type": "integer",
"maximum": 100000,
"minimum": 0
},
"value": {
"type": "number",
"maximum": 1000000000,
"minimum": 0
},
"status": {
"type": "string",
"const": "value"
}
},
"additionalProperties": false
},
{
"type": "object",
"required": [
"step",
"status"
],
"properties": {
"step": {
"type": "integer",
"maximum": 100000,
"minimum": 0
},
"status": {
"enum": [
"no_ready_endpoints",
"discovery_error",
"fetch_error"
],
"type": "string"
}
},
"additionalProperties": false
}
]
},
"maxItems": 120,
"minItems": 1
},
"targetValue": {
"type": "number",
"maximum": 1000000000,
"minimum": 0.000001,
"exclusiveMinimum": 0
},
"noReadyEndpointsAsZero": {
"type": "boolean",
"default": false
}
},
"additionalProperties": false
},
"maxItems": 16,
"minItems": 1
},
"errorMode": {
"enum": [
"drop_failed_trigger",
"freeze_combined_decision"
],
"type": "string"
},
"maxCapacity": {
"type": "integer",
"default": 100,
"maximum": 10000,
"minimum": 1
},
"minCapacity": {
"type": "integer",
"default": 0,
"maximum": 10000,
"minimum": 0
},
"initialCapacity": {
"type": "integer",
"maximum": 10000,
"minimum": 0
}
},
"description": "Deterministic per-trigger recommendation inputs. A no_ready_endpoints sample is a successful zero only when that trigger sets noReadyEndpointsAsZero:true; discovery_error and fetch_error always remain errors. This is not a KEDA/provider actuator and does not change resource counts.",
"additionalProperties": false
},
"maxCascadeDepth": {
"type": "integer",
"maximum": 8,
"minimum": 1
},
"maxGeneratedRps": {
"type": "number",
"maximum": 500000,
"exclusiveMinimum": 0
},
"scalingPolicies": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"dependencyId",
"constrainedMetric",
"observationMetric",
"scaleOutThresholdPercent"
],
"properties": {
"id": {
"type": "string",
"maxLength": 128,
"minLength": 1
},
"dependencyId": {
"type": "string",
"maxLength": 128,
"minLength": 1
},
"constrainedMetric": {
"enum": [
"rps",
"concurrency"
],
"type": "string"
},
"observationMetric": {
"enum": [
"source_cpu",
"capacity_utilization"
],
"type": "string"
},
"observedResourceId": {
"type": "string",
"minLength": 1
},
"scaleOutThresholdPercent": {
"type": "number",
"maximum": 100,
"minimum": 1
},
"scaleOutCapacityMultiplier": {
"type": "number",
"maximum": 20,
"minimum": 1
}
},
"additionalProperties": false
},
"maxItems": 32,
"description": "Capacity-observation policies, including intentional autoscaling blind spots"
},
"scheduledFaults": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"type",
"startStep"
],
"properties": {
"id": {
"type": "string",
"maxLength": 128,
"minLength": 1
},
"type": {
"enum": [
"capacity_limit",
"concurrency_limit",
"latency",
"error_rate",
"traffic_surge"
],
"type": "string",
"description": "Fault type; traffic_surge increases root client demand"
},
"endStep": {
"type": "integer",
"minimum": 1
},
"errorRate": {
"type": "number",
"maximum": 1,
"minimum": 0
},
"startStep": {
"type": "integer",
"minimum": 0
},
"dependencyId": {
"type": "string"
},
"maxConcurrent": {
"type": "integer",
"maximum": 1000000,
"exclusiveMinimum": 0
},
"addedLatencyMs": {
"type": "number",
"maximum": 120000,
"minimum": 0
},
"capacityPercent": {
"type": "number",
"maximum": 100,
"minimum": 0
},
"targetResourceId": {
"type": "string"
},
"trafficMultiplier": {
"type": "number",
"maximum": 20,
"description": "traffic_surge demand multiplier",
"exclusiveMinimum": 1
}
},
"additionalProperties": false
},
"maxItems": 32,
"description": "Scheduled capacity, error, latency, concurrency, or traffic-surge faults"
},
"retryGeneratedTrafficAffectsCost": {
"type": "boolean"
}
},
"description": "Optional retry/cascade resilience model returned by scenario.get. externalMetrics accepts deterministic sampled triggers; no_ready_endpoints is successful zero only when noReadyEndpointsAsZero:true, while discovery_error and fetch_error remain errors. This recommendation model does not actuate KEDA, providers, or simulated resource counts.",
"additionalProperties": false
},
"autoscalingConfig": {
"type": "object",
"required": [
"scaleOutCpuThreshold",
"scaleInCpuThreshold",
"scaleOutThroughputThreshold",
"scaleInThroughputThreshold",
"scaleOutLatencyThreshold",
"cooldownSeconds",
"minInstances",
"maxInstances"
],
"properties": {
"maxInstances": {
"type": "number"
},
"minInstances": {
"type": "number"
},
"cooldownSeconds": {
"type": "number"
},
"scaleInCpuThreshold": {
"type": "number"
},
"ecsCpuTargetTracking": {
"type": "boolean"
},
"scaleOutCpuThreshold": {
"type": "number"
},
"scaleInCooldownSeconds": {
"type": "integer",
"maximum": 86400,
"minimum": 0
},
"scaleOutCooldownSeconds": {
"type": "integer",
"maximum": 86400,
"minimum": 0
},
"scaleOutLatencyThreshold": {
"type": "number"
},
"simulationSecondsPerStep": {
"type": "number",
"maximum": 60,
"exclusiveMinimum": 0
},
"scaleInThroughputThreshold": {
"type": "number"
},
"scaleOutThroughputThreshold": {
"type": "number"
}
},
"description": "Simulation autoscaling thresholds and cooldown. Pass the value from scenario.get when creating from a copied scenario graph.",
"additionalProperties": false
},
"scenarioOverrides": {
"anyOf": [
{
"type": "object",
"required": [
"awsMultiRegionFailover"
],
"properties": {
"awsMultiRegionFailover": {
"type": "object",
"properties": {
"dnsTtlSeconds": {
"type": "number",
"maximum": 86400,
"exclusiveMinimum": 0
},
"includeRecoveryRamp": {
"type": "boolean",
"default": true
},
"recoveryRampStartStep": {
"type": "integer",
"maximum": 100000,
"minimum": 40
}
},
"additionalProperties": false
}
},
"additionalProperties": false
},
{
"type": "object",
"required": [
"sqsQueueBacklogSaturation"
],
"properties": {
"sqsQueueBacklogSaturation": {
"type": "object",
"properties": {
"includeEventBurst": {
"type": "boolean",
"default": true
},
"eventBurstStartStep": {
"type": "integer",
"maximum": 100000,
"minimum": 6
}
},
"additionalProperties": false
}
},
"additionalProperties": false
},
{
"type": "object",
"required": [
"eksSpotInterruption"
],
"properties": {
"eksSpotInterruption": {
"type": "object",
"required": [
"startupSeconds"
],
"properties": {
"startupSeconds": {
"type": "integer",
"maximum": 3600,
"minimum": 0
}
},
"additionalProperties": false
}
},
"additionalProperties": false
},
{
"type": "object",
"required": [
"webAutoscaling"
],
"properties": {
"webAutoscaling": {
"type": "object",
"properties": {
"includeTrafficRecovery": {
"type": "boolean",
"default": false
}
},
"additionalProperties": false
}
},
"additionalProperties": false
},
{
"type": "object",
"required": [
"redisCacheCrashRecovery"
],
"properties": {
"redisCacheCrashRecovery": {
"type": "object",
"required": [
"cacheableRequestShare",
"cacheHitRate"
],
"properties": {
"cacheHitRate": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "Configured hit rate among requests sent to Redis (0–1; the scenario default is 0.8)."
},
"cacheableRequestShare": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "Fraction of offered requests sent to Redis (0–1; the scenario default is 0.8)."
}
},
"additionalProperties": false
}
},
"additionalProperties": false
}
],
"description": "Scenario-only customization; requires scenarioId and exactly one supported override. SQS event-burst start is an absolute post-warm-up step and must be selected before the first simulation.step. Redis cache assumptions affect only this simulation."
},
"scaleOutCpuPercent": {
"type": "number",
"maximum": 100,
"minimum": 0,
"description": "Grok-compatible alias for the CPU HPA scale-out target; if multiple target names are sent they must match."
},
"autoscalingTargetCpu": {
"type": "number",
"maximum": 100,
"minimum": 0,
"description": "Canonical CPU HPA scale-out target percent. CWM synthesizes unrelated autoscaling defaults."
},
"ecsCpuTargetTracking": {
"type": "boolean",
"description": "Opt into CPU-only ECS Fargate target tracking."
},
"scaleOutCpuThreshold": {
"type": "number",
"maximum": 100,
"minimum": 0,
"description": "Equivalent alias for autoscalingTargetCpu; if both are sent they must match."
},
"scaleInCooldownSeconds": {
"type": "integer",
"maximum": 86400,
"minimum": 0,
"description": "ECS CPU target-tracking scale-in cooldown in simulated seconds."
},
"scaleOutCooldownSeconds": {
"type": "integer",
"maximum": 86400,
"minimum": 0,
"description": "ECS CPU target-tracking scale-out cooldown in simulated seconds."
},
"simulationSecondsPerStep": {
"type": "number",
"maximum": 60,
"description": "Simulated seconds per step for ECS cooldowns (default 1).",
"exclusiveMinimum": 0
},
"autoscaleTargetCpuPercent": {
"type": "number",
"maximum": 100,
"minimum": 0,
"description": "Grok-compatible alias for the CPU HPA scale-out target; if multiple target names are sent they must match."
}
},
"additionalProperties": false
}| Argument | Type | Description |
|---|---|---|
| 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 example Grok Bot or Cursor), pass this explicit ID after every fresh initialization. A fresh session has no current-simulation pointer and returns NO_ACTIVE_SIMULATION when the ID is omitted. Anonymous capabilities are short-lived (30 minutes by default), unguessable, and revoked when the demo expires or is deleted; proxy IP changes do not invalidate them. Do not treat the ID as a durable share link. |
{
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"properties": {
"resourceId": {
"type": "string",
"description": "Optional: ID of the resource to fail. Takes precedence over resourceName."
},
"resourceName": {
"type": "string",
"description": "Optional: name of the resource to fail (exact match preferred; unambiguous prefix accepted). Ambiguous names return a 400 with a candidate list."
},
"simulationId": {
"type": "string",
"description": "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 example Grok Bot or Cursor), pass this explicit ID after every fresh initialization. A fresh session has no current-simulation pointer and returns NO_ACTIVE_SIMULATION when the ID is omitted. Anonymous capabilities are short-lived (30 minutes by default), unguessable, and revoked when the demo expires or is deleted; proxy IP changes do not invalidate them. Do not treat the ID as a durable share link."
}
},
"additionalProperties": false
}{
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"properties": {
"random": {
"type": "boolean",
"const": true,
"description": "Explicitly select a random stress spike; never selected implicitly."
},
"targetRps": {
"type": "integer",
"minimum": 1,
"description": "Absolute traffic level in RPS to set. Server-capped at 10000 RPS in demo mode."
},
"deltaPercent": {
"type": "number",
"description": "Relative traffic change; must be greater than -100.",
"exclusiveMinimum": -100
},
"simulationId": {
"type": "string",
"description": "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 example Grok Bot or Cursor), pass this explicit ID after every fresh initialization. A fresh session has no current-simulation pointer and returns NO_ACTIVE_SIMULATION when the ID is omitted. Anonymous capabilities are short-lived (30 minutes by default), unguessable, and revoked when the demo expires or is deleted; proxy IP changes do not invalidate them. Do not treat the ID as a durable share link."
}
},
"additionalProperties": false
}| string |
| Response detail level. 'compact' (default) returns principal current metrics, errorBreakdown when available, per-resource status (id, name, status, cpuPercent, routedRps, availabilityState, isRoutable, recoveryBlockedReason, and failureLifecycle/routingState when provided), and only the last 10 metrics-history entries — keeps polling cheap for agent loops. 'full' returns the complete simulation object (all resource characteristics and connections) plus the entire metrics history. |
| 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 example Grok Bot or Cursor), pass this explicit ID after every fresh initialization. A fresh session has no current-simulation pointer and returns NO_ACTIVE_SIMULATION when the ID is omitted. Anonymous capabilities are short-lived (30 minutes by default), unguessable, and revoked when the demo expires or is deleted; proxy IP changes do not invalidate them. Do not treat the ID as a durable share link. |
{
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"properties": {
"responseMode": {
"enum": [
"compact",
"full"
],
"type": "string",
"default": "compact",
"description": "Response detail level. 'compact' (default) returns principal current metrics, errorBreakdown when available, per-resource status (id, name, status, cpuPercent, routedRps, availabilityState, isRoutable, recoveryBlockedReason, and failureLifecycle/routingState when provided), and only the last 10 metrics-history entries — keeps polling cheap for agent loops. 'full' returns the complete simulation object (all resource characteristics and connections) plus the entire metrics history."
},
"simulationId": {
"type": "string",
"description": "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 example Grok Bot or Cursor), pass this explicit ID after every fresh initialization. A fresh session has no current-simulation pointer and returns NO_ACTIVE_SIMULATION when the ID is omitted. Anonymous capabilities are short-lived (30 minutes by default), unguessable, and revoked when the demo expires or is deleted; proxy IP changes do not invalidate them. Do not treat the ID as a durable share link."
}
},
"additionalProperties": false
}| Argument | Type | Description |
|---|---|---|
| traffic | number | Optional RPS override for this step. Applied when no traffic pattern is active; otherwise rejected with STEP_TRAFFIC_PATTERN_ACTIVE. Use simulation.inject_traffic to change load; finalized SQS backlog runs keep the pattern snapshot and apply an explicit target at runtime. |
| responseMode | string | Response detail level. 'compact' (default) returns only principal metrics, errorBreakdown when available, per-resource status (id, name, status, cpuPercent, routedRps, availabilityState, isRoutable, recoveryBlockedReason, and failureLifecycle/routingState when provided), and this step's events — keeps observations small for agent loops. 'full' returns the complete backend step response including the entire simulation object with all resource characteristics and connections. |
| 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 example Grok Bot or Cursor), pass this explicit ID after every fresh initialization. A fresh session has no current-simulation pointer and returns NO_ACTIVE_SIMULATION when the ID is omitted. Anonymous capabilities are short-lived (30 minutes by default), unguessable, and revoked when the demo expires or is deleted; proxy IP changes do not invalidate them. Do not treat the ID as a durable share link. |
{
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"properties": {
"traffic": {
"type": "number",
"minimum": 0,
"description": "Optional RPS override for this step. Applied when no traffic pattern is active; otherwise rejected with STEP_TRAFFIC_PATTERN_ACTIVE. Use simulation.inject_traffic to change load; finalized SQS backlog runs keep the pattern snapshot and apply an explicit target at runtime."
},
"responseMode": {
"enum": [
"compact",
"full"
],
"type": "string",
"default": "compact",
"description": "Response detail level. 'compact' (default) returns only principal metrics, errorBreakdown when available, per-resource status (id, name, status, cpuPercent, routedRps, availabilityState, isRoutable, recoveryBlockedReason, and failureLifecycle/routingState when provided), and this step's events — keeps observations small for agent loops. 'full' returns the complete backend step response including the entire simulation object with all resource characteristics and connections."
},
"simulationId": {
"type": "string",
"description": "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 example Grok Bot or Cursor), pass this explicit ID after every fresh initialization. A fresh session has no current-simulation pointer and returns NO_ACTIVE_SIMULATION when the ID is omitted. Anonymous capabilities are short-lived (30 minutes by default), unguessable, and revoked when the demo expires or is deleted; proxy IP changes do not invalidate them. Do not treat the ID as a durable share link."
}
},
"additionalProperties": false
}