Built for Agents

# Health check — no auth required
curl https://cloudworldmodel.ai/api/health
# → { "status": "ok", "version": "1.0.0", "uptime": 42.3 }

# Full OpenAPI spec as JSON
curl https://cloudworldmodel.ai/api-docs/openapi.json

# Interactive Swagger UI
open https://cloudworldmodel.ai/api-docs

npm install -g "github:canvascloudai/cwm-mcp"

{
  "mcpServers": {
    "cloud-world-model": {
      "command": "npx",
      "args": ["cwm-mcp"],
      "env": {
        "CWM_API_KEY": "your_api_key_here",
        "CWM_BASE_URL": "https://cloudworldmodel.ai"
      }
    }
  }
}

pip install "git+https://github.com/canvascloudai/cwm-sdk.git"

from cwm import CloudWorldModel

client = CloudWorldModel(
    base_url="https://cloudworldmodel.ai",
    api_key="your_api_key_here",
)

# 1. Create a simulation
sim = client.create_simulation({
    "name": "prod-replica",
    "resources": [
        {
            "id": "web",
            "type": "compute",
            "name": "Web Server",
            "provider": "aws",
            "characteristics": {"size": "t3.medium"},
        }
    ],
})

# 2. Run a simulation step
result = client.simulate_step(sim["id"], traffic=1500)
m = result["metrics"]
print(m["cpuUsage"])      # e.g. 0.72
print(m["latencyP95"])    # e.g. 143.2
print(m["costPerHour"])   # e.g. 0.0464

from cwm import CloudWorldModel

client = CloudWorldModel(
    base_url="https://www.cloudworldmodel.ai/api",
    api_key="your_api_key_here",
)

# 1. Create an RL environment linked to a simulation that already contains
#    at least one AWS database resource (the engine clones it for the episode).
env_result = client.create_rl_environment(
    simulation_id="<sim-id>",
    episode_config={"maxSteps": 40},
)
env_id = env_result["environment"]["id"]

# 2. add_resource action — adds an Aurora Serverless v2 database to the sim.
#    The engine models a 2-4 step ACU scale-out delay for aurora-serverless targets.
step1 = client.rl_step(env_id, action={
    "type": "add_resource",
    "parameters": {"resourceType": "database", "provider": "aws"},
})
# Response keys: observation, reward {total, components, metrics}, done, info
obs    = step1["observation"]   # {cpu_util, rps, instances, traffic, currentTime}
reward = step1["reward"]        # {total, components: {performance, cost, stability, sla}, metrics}

# 3. Ramp window (steps 1-4): ACU warming up — cpu_util == 0, cost at minCapacity floor.
#    Only count cost + stability reward components to avoid false latency penalties.
result = step1
for _ in range(4):
    result = client.rl_step(env_id, action={
        "type": "adjust_threshold",
        "parameters": {"cpuThreshold": 70},
    })
    obs        = result["observation"]
    rc         = result["reward"]["components"]
    adj_reward = rc["cost"] + rc["stability"]
    print(f"Ramp  cpu_util={obs['cpu_util']:.3f}  adj_reward={adj_reward:.3f}")

# 4. Steady-state training loop — all four reward components now meaningful.
done = result["done"]
while not done:
    result = client.rl_step(env_id, action={
        "type": "adjust_threshold",
        "parameters": {"cpuThreshold": 70},
    })
    done = result["done"]
    obs  = result["observation"]
    rw   = result["reward"]
    print(f"Train cpu_util={obs['cpu_util']:.3f}  "
          f"cost_usd_hr={rw['metrics']['costPerHour']:.4f}  "
          f"reward={rw['total']:.3f}")

# 5. Reset for the next episode.
client.rl_reset(env_id)

npm install "github:canvascloudai/cwm-ts-sdk"

import { CwmClient } from "@cwm/sdk";

const client = new CwmClient({
  baseUrl: "https://cloudworldmodel.ai",
  apiKey: "your_api_key_here",
});

// 1. Create a simulation
const sim = await client.createSimulation({
  name: "prod-replica",
  resources: [
    {
      id: "web",
      type: "compute",
      name: "Web Server",
      provider: "aws",
      characteristics: { size: "t3.medium" },
    },
  ],
});

// 2. Run a simulation step and read metrics
const result = await client.simulateStep(sim.id, { traffic: 1500 });
console.log(result.metrics.cpuUsage);    // e.g. 0.72
console.log(result.metrics.latencyP95); // e.g. 143.2
console.log(result.metrics.costPerHour); // e.g. 0.0464

import { CwmClient } from "@cwm/sdk";

const client = new CwmClient({
  baseUrl: "https://www.cloudworldmodel.ai/api",
  apiKey: "your_api_key_here",
});

// 1. Create an RL environment linked to a simulation that already contains
//    at least one AWS database resource (the engine clones it for the episode).
const { environment } = await client.createRlEnvironment("<sim-id>", {
  episodeConfig: { maxSteps: 40 },
});
const envId = environment.id;

// 2. add_resource action — adds an Aurora Serverless v2 database to the sim.
//    The engine models a 2-4 step ACU scale-out delay for aurora-serverless targets.
let step1 = await client.rlStep(envId, {
  action: { type: "add_resource", parameters: { resourceType: "database", provider: "aws" } },
  tick_seconds: 60,
});
// Response keys: t, obs, metrics, reward, reward_components, done
let { t, obs, metrics } = step1;  // t=1 after first action
// obs: {cpu_util, rps, instances, traffic, currentTime}
// metrics: {cost_usd_hr, latency_p95, error_rate, uptime, sla_violations}

// 3. Ramp window (t = 1-4): obs.cpu_util === 0, metrics.cost_usd_hr at minCapacity floor (~$0.06/hr).
//    Only count cost + stability reward components — skip performance and sla during ACU ramp-up.
const RAMP_STEPS = 4;
let result = step1;
for (let i = 0; i < RAMP_STEPS; i++) {
  result = await client.rlStep(envId, {
    action: { type: "adjust_threshold", parameters: { cpuThreshold: 70 } },
    tick_seconds: 60,
  });
  ({ t, obs, metrics } = result);
  const rc = result.reward_components;
  const adjustedReward = rc.cost + rc.stability;
  console.log(`Ramp  t=${String(t).padStart(2)}  cpu_util=${obs.cpu_util.toFixed(3)}  ` +
              `cost_usd_hr=${metrics.cost_usd_hr.toFixed(4)}  adj_reward=${adjustedReward.toFixed(3)}`);
}

// 4. Steady-state training loop — all four reward components are now meaningful.
//    metrics.cost_usd_hr climbs over 3-6 steps toward the ACU-proportional steady-state rate.
let done = result.done;
while (!done) {
  result = await client.rlStep(envId, {
    action: { type: "adjust_threshold", parameters: { cpuThreshold: 70 } },
    tick_seconds: 60,
  });
  ({ t, obs, metrics } = result);
  const reward = result.reward;
  done = result.done;
  console.log(`Train t=${String(t).padStart(2)}  cpu_util=${obs.cpu_util.toFixed(3)}  ` +
              `latency_p95=${metrics.latency_p95.toFixed(0)}ms  ` +
              `cost_usd_hr=${metrics.cost_usd_hr.toFixed(4)}  reward=${reward.toFixed(3)}`);
}

// 5. Reset for the next episode.
await client.rlReset(envId);

# Install globally from GitHub
npm install -g "github:canvascloudai/cwm-cli"

# Verify
cwm --help

Usage: cwm <command> [options]

Commands:
  config      Manage CLI configuration (set, show)
  simulate    Simulation management (create, get, list, step)
  rl          RL environment interactions (create, step, reset)
  chaos       Chaos engineering (scenarios, run, status, results)
  multicloud  Strategy exploration (explore, status, results)
  keys        API key management (create, list, revoke)

Options:
  --base-url <url>   CWM server URL (overrides config)
  --api-key <key>    API key (overrides config)
  --output <format>  Output format: text | json
  -h, --help         Display help for a command

# 0. Save your key once; the CLI reads it automatically from ~/.cwm/config.json.
cwm config set --api-key your_api_key_here

# 1. Create an RL environment linked to a simulation that already contains
#    at least one AWS database resource (the engine clones it for the episode).
ENV_ID=$(cwm rl create <sim-id> --max-steps 40 --output json | jq -r '.environment.id')

# 2. add_resource action — adds an Aurora Serverless v2 database to the sim.
#    cwm rl step passes no action parameters, so use curl for this parameterized step.
#    The engine models a 2-4 step ACU scale-out delay for aurora-serverless targets.
curl -s -X POST https://www.cloudworldmodel.ai/api/rl/environments/$ENV_ID/step \
  -H "Authorization: Bearer your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{"action":{"type":"add_resource","parameters":{"resourceType":"database","provider":"aws"}}}' \
  | jq '{obs: .obs, reward: .reward, done: .done}'
# Response keys: obs {cpu_util, rps, instances, traffic, currentTime},
#                reward (total scalar), reward_components {performance,cost,stability,sla},
#                metrics {cost_usd_hr, latency_p95, error_rate}, done

# 3. Ramp window (steps 1-4): ACU warming up — obs.cpu_util == 0, cost at minCapacity floor.
#    Only cost + stability reward components are meaningful during ACU ramp-up.
for i in 1 2 3 4; do
  cwm rl step $ENV_ID adjust_threshold --output json \
    | jq '{cpu_util: .obs.cpu_util, adj_reward: (.reward_components.cost + .reward_components.stability)}'
done

# 4. Steady-state training loop — all four reward components are now meaningful.
#    Loop until the episode is done (done == true in the JSON response).
while true; do
  RESULT=$(cwm rl step $ENV_ID adjust_threshold --output json)
  echo "$RESULT" | jq '{cpu_util: .obs.cpu_util, cost_usd_hr: .metrics.cost_usd_hr, reward: .reward}'
  DONE=$(echo "$RESULT" | jq -r '.done')
  [ "$DONE" = "true" ] && break
done

# 5. Reset for the next episode.
cwm rl reset $ENV_ID