Documentation

GitHub PR Simulation Reports

The Cloud World Model GitHub App automatically runs infrastructure simulations when a pull request changes supported infrastructure files — giving your team modeled cost, performance and resilience estimates before the change merges.

Need help getting connected?

Connect GitHub repository

Source files are read for modeling; the App posts PR comments and checks. Cloud World Model does not request cloud credentials or access cloud environments, Terraform state, or provider APIs.

Get your first report

  1. Get Started and sign in with GitHub or email.
  2. Choose Connect GitHub repository and follow the guided GitHub authorization and installation flow.
  3. Review the repository access requested and explicitly confirm use of your CWM account credits. Linking your account does not prove that a repository exists.
  4. Open or update a pull request that changes supported infrastructure as code (IaC).
  5. Review the Before / After / Impact report in the pull request comment and informational GitHub Check, including its stated limitations.

Connecting is free. Each PR comparison uses 10 CWM credits. No API key is needed to connect.

Before connecting a private repository, review GitHub permissions and report sharing. Report links are unlisted, but anyone with a link can view the modeled report.

A real report

See an example report in a GitHub pull request.

Troubleshoot setup

  • No repositories listed: Create a repository on GitHub or choose an existing one, then grant the Cloud World Model GitHub App access to it. Linking a GitHub account alone does not prove a repository exists.
  • Organization approval is pending: The installation is not connected or eligible for reports until an organization owner approves access and setup verification and confirmation are complete.
  • You cancelled GitHub authorization: Start again from Get Started and choose Connect GitHub repository.
  • Verification expired or failed: Start a fresh guided connection from Get Started. CWM must verify your GitHub access before you review and confirm the connection. Expired verification cannot be extended or reused.

Rerunning a report

Start a fresh run on the pull request's current head in any of three ways:

  • Post a new PR comment containing only /cwm simulate. You need write access to the repository (write, maintain, or admin); the App reacts to acknowledge the command.
  • Click Re-run on the current head's Cloud World Model Check, or choose Re-run all checks.
  • Push a new commit to the PR branch.

A run already in progress won't be duplicated. Comments from bots are ignored.

PR reports have unlisted links you can share with your team. Anyone with a link can view the modeled report, including people without access to the GitHub repository. If you connect a private repository, share report links only with people authorized to see its infrastructure details.

Links do not currently expire, and uninstalling the App does not remove existing reports. CWM report retention is independent of GitHub Check retention: GitHub may remove a Check without removing its hosted CWM report or its separate PR comment. Read our Privacy Policy for more on data handling.

GitHub App permissions

Repository permissionAccessWhy
ContentsReadRead selected infrastructure source and support files for the PR comparison.
Pull requestsRead and writeRead PR changes and support posting the PR report.
IssuesRead and writePost and update PR conversation comments and acknowledge authorized /cwm simulate commands with a reaction.
ChecksRead and writeCreate and update the simulation Check and handle rerun requests.
MetadataReadGitHub's mandatory baseline permission; verify that command authors have repository write access.

The App requests no Actions, organization, account, or enterprise permissions.

The optional Helm GitHub Actions runner is disabled. Do not install the CWM Helm replica workflow or add Actions permissions for PR reports. A previously added .cwm/helm-replica-check.yml does not enable it; you may remove that opt-in file and any copied workflow. Existing GitHub Actions runs already queued by older versions may finish in your repository, but CWM ignores their results. Remove or disable a copied workflow in your repository to prevent manual runs.

Technical reference

How it works

When you connect a GitHub App installation to your CWM account and grant it access to a repository, the app listens for pull request events. This account-linked installation is the normal setup; an API key is not required. Each time a PR is opened or updated, the app:

  1. Scans the changed files for Terraform/OpenTofu-compatible configuration and other infrastructure definitions (see supported formats below).
  2. Resolves the immutable base and head commit SHAs and fetches the touched IaC scope, including required support files, at each commit.
  3. Translates each ref's detected resource configuration into a canonical CWM simulation input.
  4. Runs both snapshots through the same seeded 30-step workload for one flat 10-credit charge.
  5. Posts a PR comment and informational GitHub Check with the Before / After / Impact table and links to the read-only snapshots.

If neither commit contains supported IaC in the touched scope, the app posts a brief note explaining that no simulation was run. If only one side contains supported IaC, the app still reports the addition or removal using the empty-side rules below.

What the report includes

New completed comparisons include the same Merge review summary in the PR comment, informational GitHub Check, and read-only workspace. It summarizes existing modeled operational changes separately from cost trade-offs: a higher cost alone is not an operational regression and may buy capacity or performance. Missing or incomparable metrics, partial coverage, and diagnostic or unvalidated evidence remain visible alongside the conclusion; incomplete evidence is never a pass. “No unfavorable changes detected in the modeled metrics” applies only to the recorded comparison with its stated limitations. This is not a risk score, merge recommendation, merge-safety guarantee, or rollback prediction; no rollback simulation is performed. Older reports without a recorded summary show it as unavailable rather than reconstructing evidence using the current model.

Each PR comment and GitHub Check contains the same four-row comparison table. The Impact value is always After minus Before and is marked as favourable, unfavourable, or unchanged for operational metrics; cost is a separate trade-off:

MetricValue usedImpact unit
Modeled total cost per hourFinal hourly run rate at the end of the shared 30-step window.Signed $/hr
p99 latencyHighest p99 request latency observed across the shared window.Signed milliseconds
Peak CPUHighest CPU utilisation observed across the shared window.Signed percentage points
ResilienceThe existing composite 0–100 resilience score for the snapshot.Signed score points

Base vs. head comparison

When a PR changes infrastructure, the report compares two snapshots side by side: the base (the target branch as it stands today) and the head (the branch with your PR applied). The read-only workspace linked from the PR comment shows a Before / After / Impact table plus commit links and a base/head snapshot toggle so you can inspect either configuration on the canvas without editing anything.

Deterministic by construction

Both sides run the same fixed 30-step simulation with the same seed. Because the only variable is the infrastructure defined in the diff, every delta shown in the Impact column is attributable to your change — not to run-to-run randomness. Results may change between runs as the engine and pricing catalog are updated.

How to read the Impact column

The Impact column shows head − base, expressed in each metric's own unit — for example +$0.42/hr for cost, −35 ms for latency, or +8 pts for the resilience score. Deltas are coloured by whether the change is an improvement for that metric (lower latency and CPU are better; higher resilience is better). Cost deltas are neutral trade-offs, not operational regressions. A delta is only shown when both sides have a value.

Scope of the comparison

The comparison covers only what CWM can model deterministically from the diff. Anything outside that scope — unmodeled resource types, request-based (per-invocation) pricing, or structural limitations of the detected configuration — is listed under an “Outside the comparison's scope” warning so reviewers do not over-trust the numbers. Treat those items as unmeasured, not as “no change”.

Simulation basis and provenance

Completed comparison reports include a compact Simulation basis that shows the before/after modeled resource counts, the fixed synthetic request rate, and the 30-step budget. The same compact basis appears in the GitHub Check so reviewers can see the context without opening the full PR comment.

The expandable “Simulation inputs, mappings and assumptions” details group the run information into Observed; peer mapping outcomes of Exact, Inferred, and Unsupported; then Assumed and Not evaluated. “Observed” refers to source files actually fetched for the comparison: selected IaC files at the immutable base and head commits and, for supported module chains, child-module source at the selected commits or pinned public refs. Resource-shape mappings, inferred connections, image-based Compose classification, and extractor defaults are identified separately rather than described as observed inputs.

These mapping labels describe two separate provenance dimensions. Exact means the source construct identity — its provider and CWM resource type — was preserved. Inferred means CWM added assumptions for modeled behavior, sizing, defaults, or topology. One source construct can therefore be Exact at the identity level while still having separate inferred modeling characteristics; this does not change its classification, simulation results, telemetry outcomes, or pricing behavior.

Repository scope is limited to the touched IaC files selected for each ref and the bounded support files needed for modeling or confirming formats such as Helm charts. Supported module-call chains may also fetch same-repo child modules at the selected commits or pinned public Registry/Git modules, as described below. CWM does not inspect live infrastructure, application code, production traffic, or provider APIs. The report is therefore a bounded model comparison, not a confidence score or a statement about the deployed environment.

Kubernetes workload capacity is inferred

Terraform infrastructure and Kubernetes workloads have deliberately different labels. For example, a Terraform aws_instance.cross_cloud change from t3.micro to t3.xlarge is shown as Exact — Terraform EC2: the source instance and its modeled SKU are both named. A Deployment that produces resources such as nymeria-aws and nymeria-aws-1 is shown as Inferred — Kubernetes workload capacity. Those names do not mean CWM discovered AWS instances, worker nodes, or pod placement in the repository.

For Kubernetes workload capacity, CWM uses AWS and us-east-1 as modeling defaults. A displayed t3.micro is a capacity-model shape, not an observed worker-node SKU. Replica count and CPU limits affect the capacity/performance model. CPU requests, memory, and ephemeral storage are explicitly disclosed when present, but are not evaluated as billable infrastructure.

Cost detail separates direct modeled resource charges from simulation-derived effects such as egress and data transfer. An egress delta emerges from the combined simulated topology and workload; it is non-additive and is never attributed to either a Terraform EC2 change or a Kubernetes manifest change alone.

PRs that add or remove infrastructure

When a PR adds new infrastructure there is no base configuration to compare against, so the base side is empty and its cost is shown as $0/hr. When a PR removes infrastructure the head side is empty and the table shows its cost as $0/hr. The cost impact remains a real signed After-minus-Before delta; p99 latency, Peak CPU, and Resilience are labelled N/A on the empty side instead of simulating a fallback server.

Credit usage

Connecting is free. Each PR comparison uses 10 CWM credits. CWM uses credits from the CWM account connected to the GitHub App installation. Billing belongs to that linked CWM account, not an API key. The cost is the same regardless of the number of resources in the diff — 30 steps are always run.

A base-vs-head comparison is billed as a single 10-credit charge, not two. The one charge covers simulating both the base and head snapshots and producing the Before / After / Impact report — so a PR that runs a full comparison costs exactly the same as one that only has a head snapshot.

If your account has fewer than 10 credits when a PR event arrives, the simulation is skipped before either snapshot runs. If a required comparison run fails after the charge is reserved, the reservation is refunded and no partial result is published. You can monitor your balance on the Billing page.

Linking your installation

Connect and confirm the installation through the guided flow at Get Started. Review repository access and explicitly confirm credit use for the connected CWM account.

Legacy compatibility

The optional key-based instructions at GitHub setup are retained for existing compatibility workflows. After installing the Cloud World Model GitHub App, the legacy setup page accepts existing cwm_live_ credentials; the installation ID may be pre-filled from the redirect URL.

Existing connections keep their owner and billing attribution; signing in does not transfer them to a different account. A key or installation ID alone does not prove GitHub access: verification and explicit credit-use confirmation still apply. The normal guided connection does not require an API key.

Supported IaC formats

The app detects infrastructure resources from the following file types in a PR diff:

FormatDetection signal
Terraform/OpenTofu-compatible configurationStandard Terraform and OpenTofu configuration files with .tf, .tfvars, .tf.json, or .tfvars.json extension. CWM statically extracts supported declarations; it does not run terraform or tofu.
CloudFormationYAML or JSON files containing AWSTemplateFormatVersion or AWS:: resource types in the diff patch.
Kubernetes manifestsYAML files with both apiVersion: and kind: fields in the diff patch. GitHub Actions workflow files are explicitly excluded.
Helm chartsChart.yaml, values files, and templates/ YAML within a Helm chart directory tree. CWM models supported values statically; it does not render templates or execute Helm. Unresolved helper, template, and routing relationships remain coverage limits rather than verified replica counts.
Docker ComposeFiles named docker-compose*.yml or compose*.yml.

Terraform/OpenTofu compatibility boundary

CWM supports Terraform/OpenTofu-compatible configuration, not Terraform or OpenTofu execution. The GitHub App uses the existing bounded static extractor to inspect source text at immutable commits. It never runs terraform plan, terraform apply, tofu plan, or tofu apply; it does not initialize provider plugins or read Terraform/OpenTofu state.

Configuration areaPublic compatibility scope
Standard Terraform/OpenTofu-compatible resource blocksSupported resource families are extracted using the same bounded Terraform contract and classified in the coverage table below.
OpenTofu state encryptionThe terraform.encryption block is ignored as non-resource metadata and marked not evaluated; key providers, encryption methods, state, and passphrases are not interpreted.
Dynamic values, provider/state evaluation, and unsupported constructsRemain unsupported or not evaluated. CWM does not invent resources, resolve arbitrary runtime expressions, query providers, read state, or turn an unsupported construct into an AWS fallback.

Supported IaC coverage

Detecting an IaC file does not mean every resource in that file is faithfully modeled. Each recognized construct is classified in the report’s mapping audit as Exact, Inferred, or Unsupported. Exact preserves the source construct’s provider and CWM resource type identity. Inferred describes assumptions added for modeled behavior, sizing, defaults, or topology — for example, translating a Kubernetes CPU limit into a modeled shape. Unsupported is reported as unmodeled and is never treated as an AWS reference server. An exact Terraform compute mapping may still have inferred CWM sizing, provider, region, or topology characteristics; those are separate dimensions, not a correction to the exact identity mapping.

Terraform/OpenTofu-compatible module calls are a bounded coverage boundary. CWM can follow supported same-repo and pinned public module-call chains as described below, but it does not run terraform or tofu or evaluate arbitrary modules. Unresolved calls remain Unsupported; a neutral no-simulation result makes no claim about infrastructure inside them. Directly modeled Terraform resources in the same root module are still compared normally.

OCI Terraform support is explicitly limited to the catalog-backed families listed in the table: compute and Functions, Autonomous Database/MySQL HeatWave, Object/Block/File Storage, Load Balancing, Redis cache, Streaming/Queue, and a single directly related OKE node pool. VCN, subnet, IAM, attachment, listener, and mount-target resources provide relationship evidence only; unsupported OCI services, dynamic or computed values, unbounded collections, and ambiguous relationships remain Unsupportedand never become an AWS fallback or an invented OCI tier.

For supported chains, when every module call in a changed file has a source CWM can resolve — a same-repo relative path (./ or ../), a pinned public Terraform Registry address (<namespace>/<name>/<provider> with an exact version, no range operator), or a pinned GitHub-hosted Git address (git::https://github.com/<owner>/<repo>?ref=<tag-or-sha> or the github.com/... shorthand, with a full commit SHA or semantic-version tag) — CWM follows the module-call graph, as many hops as it actually contains up to a small bounded depth, fetching each hop’s directory and propagating each hop’s literal and var.<name> call arguments into the next hop’s variable scope using Terraform’s own name-matching rule. A same-repo hop fetches at the PR’s exact base and head commits; a registry or Git hop fetches the published module’s source at its pinned version/ref over the public internet (unauthenticated, public repositories only), and any further same-repo-relative calls inside that external module resolve against it, not the PR’s own repository. If the chain terminates in an already-covered resource, CWM simulates it and the report’s mapping detail names the resolved chain (the module labels/paths walked from the changed call to the modeled resource) and the specific propagated input(s) responsible — a chain that crossed into an external module is labeled distinctly (“registry/Git-resolved”) and names the exact published module fetched, so it is never confused with an ordinary same-module default or a purely same-repo chain. An unpinned version/ref, an HTTP or otherwise unrecognized source, a private or unreachable module, an ambiguous or cyclic call graph, a hop that cannot be fetched, or a chain that exceeds the bounded depth all fall back unchanged to the neutral module-boundary result above — CWM never simulates a partial or guessed chain, and sibling module calls not on the resolved path are never fetched.

Top-level Terraform/OpenTofu-compatible locals declarations are also an explicit Unsupported coverage boundary when no directly mapped resource is in the analyzed scope. CWM does not resolve local values into resources outside that scope, so the neutral result does not identify, infer, or simulate an unobserved resource. Directly modeled resources remain eligible for their normal comparison.

FormatSupported construct categoryCWM modelClassification
Terraform/OpenTofu-compatible configurationGKE worker node poolsDefault and directly associated standalone GKE pools with N1 standard 1/2/4 or supported E2 standard machine types and bounded declared node counts. Worker cost uses us-central1 on-demand reference prices times declared count; cluster fee is separate. Throughput is modeled, not measured. Unknown types, ambiguous relationships, GPU and autoscaling are unsupported; zone replication, disks, networking and discounts are excluded.Inferred
Terraform/OpenTofu-compatible configurationEKS GPU managed nodegroupsLiteral catalog GPU instance type and desired/minimum/maximum node counts. Readiness and serving capacity require explicit modeled assumptions; expressions and mixed instance types remain unsupported.Exact
CloudFormationEKS GPU managed nodegroupsLiteral catalog GPU instance type and desired/minimum/maximum node counts. Readiness and serving capacity require explicit modeled assumptions; unresolved references and mixed instance types remain unsupported.Exact
Terraform/OpenTofu-compatible configurationDigitalOcean literal resourcesVerified regular Droplet SKUs; Basic single-primary PostgreSQL/MySQL databases; regional HTTP load balancers ($12/month per node), regional network load balancers ($15/month per node), and Global load balancers ($15/month with 25 million requests, 5 domains, and 1 TB transfer included); standalone DOKS pools with direct cluster references and unique names. Native .tofu and .tofu.json use bounded HCL/JSON parsing at immutable revisions. Monthly list prices ÷ 730 are normalized equivalents, not short-lived hourly bills. Performance, latency and failures remain estimates; the network-LB 50 Mbps/node ingress fact is not converted to an RPS limit. Unknown SKUs, paid Droplet add-ons, custom database storage, standbys, other engines, internal load balancers, dynamic/computed Global domains, and unresolved relationships are unsupported.Exact
Terraform/OpenTofu-compatible configurationAzure Kubernetes (AKS) default node poolInferred Azure/AKS aggregate from one direct default_node_pool; source location, raw vm_size, and worker-count facts are preserved while CWM uses the existing Azure/AKS worker baseline for approximate cost and capacityInferred
Terraform/OpenTofu-compatible configurationDigitalOcean Kubernetes (DOKS) node poolsDigitalOcean Kubernetes from exact catalog-backed inline and directly associated standalone pools. Unique same-scope scalar literal defaults, literal locals and direct aliases may resolve pool inputs; no expression evaluation. Explicit autoscaling with omitted node_count starts at min_nodes as a labeled CWM assumption, never max_nodes. A present unresolved count stays unsupported; fixed fleets stay fixed and may omit bounds. Configured min–max worker cost ranges are separate from bounded-run counts and running cost. Literal ha retains the separate fee and 99.95% HA SLA; unsupported siblings remain out of scope, not whole-stack savings.Exact
Terraform/OpenTofu-compatible configurationDigitalOcean Kubernetes (DOKS) HA control planeDirect literal DOKS ha selects the official standard free or HA $40/month prorated control-plane charge and reports the 99.95% monthly control-plane uptime SLA; worker-pool economics are unchangedInferred
Terraform/OpenTofu-compatible configurationAWS EC2 instancesAWS computeExact
Terraform/OpenTofu-compatible configurationAWS RDS instancesAWS database from the canonical RDS tier catalogExact
Terraform/OpenTofu-compatible configurationAWS Lambda functionsAWS request-serving computeExact
Terraform/OpenTofu-compatible configurationAWS Lambda provisioned-concurrency aliasesAWS Lambda warm capacity from direct local function, version, and alias referencesInferred
Terraform/OpenTofu-compatible configurationAWS Lambda standalone provisioned concurrencyAWS Lambda warm capacity from direct local function, version, or alias referencesInferred
Terraform/OpenTofu-compatible configurationAWS Launch Template Auto Scaling GroupsAWS compute fleet from a direct template relationship and statically resolvable capacity; desired capacity and bounds may use one same-module literal variable default, including a retained zero floor; instance type may use the same bounded defaultInferred
Terraform/OpenTofu-compatible configurationAWS mixed-instance Launch Template Auto Scaling GroupsAWS compute fleet from a direct mixed_instances_policy template relationship with unique member types, source-proven launch-template revision selection, and bounded capacityInferred
Terraform/OpenTofu-compatible configurationGCP Compute Engine instancesGCP computeExact
Terraform/OpenTofu-compatible configurationGCP Cloud SQL primary instances and read replicasBounded literal MySQL/PostgreSQL native tier, engine/version, region, edition, HA, SSD/HDD allocation and direct local primary links; configuration-specific catalog prices and explicit component exclusionsExact
Terraform/OpenTofu-compatible configurationGCP Cloud Functions v2GCP request-serving computeExact
Terraform/OpenTofu-compatible configurationGCP regional Managed Instance Group autoscalersGCP compute fleet from direct local autoscaler, regional MIG, and single-version instance-template links; literal min/max replicas bound CWM autoscaling and min_replicas supplies the initial floorInferred
Terraform/OpenTofu-compatible configurationGCP Cloud Run v2 servicesGCP request-serving compute from literal container CPU/memory, concurrency, and scaling settings; expressions and regional topology remain explicitly incompleteInferred
Terraform/OpenTofu-compatible configurationAzure virtual machinesAzure computeExact
Terraform/OpenTofu-compatible configurationAzure function and container appsAzure request-serving computeExact
Terraform/OpenTofu-compatible configurationOCI compute instancesOCI computeExact
Terraform/OpenTofu-compatible configurationOCI FunctionsOCI request-serving computeExact
Terraform/OpenTofu-compatible configurationOCI databasesOCI Autonomous Database and MySQL HeatWaveInferred
Terraform/OpenTofu-compatible configurationOCI storageOCI Object, Block, and File StorageInferred
Terraform/OpenTofu-compatible configurationOCI load balancingOCI Load Balancer and Network Load BalancerInferred
Terraform/OpenTofu-compatible configurationOCI cache and messagingOCI Cache Redis, Streaming, and QueueInferred
Terraform/OpenTofu-compatible configurationOCI KubernetesOCI OKE cluster with bounded node-pool relationships, source-proven direct or same-directory module-input regions, top-level/nested Flex shape layouts, and OCPU-qualified catalog tiersInferred
CloudFormationEC2 instancesAWS computeExact
CloudFormationLambda functionsAWS request-serving computeExact
CloudFormation / AWS SAMServerless functionsInferred AWS Lambda request-based compute; function-local MemorySize, then Globals.Function.MemorySize, maps proportionally to bounded capacity (1 GB = 3,000 RPS) and request/GB-second cost at a fixed 100 ms duration. An omitted effective value defaults to 128 MB; dynamic or invalid values remain explicitly unmodeledInferred
CloudFormationLambda provisioned-concurrency aliasesAWS Lambda warm capacity from direct local function, version, and alias referencesInferred
CloudFormationRDS DB instancesAWS databaseExact
CloudFormationAWS application and network load balancersBounded AWS ALB or NLB network resource from literal CloudFormation product configuration; ALB/NLB pricing, forwarding capacity, and latency assumptions are distinct, while gateway, listener, target, health, WAF, LCU, and computed relationship details remain outside the modelInferred
Terraform/OpenTofu-compatible configurationAWS application, network, and gateway load balancersBounded AWS ALB, NLB, or GWLB network resource from literal product configuration, with direct local listener → target-group → instance relationships when the chain is complete and bounded; GWLB uses the $0.0125/hour fixed charge from the AWS Elastic Load Balancing pricing page (US East, retrieved 2026-08-30), a 50,000 RPS bounded forwarding ceiling, and 2 ms base latency, while endpoint, GLCU, target health, WAF, LCU, and computed relationship details remain outside the modelInferred
Terraform/OpenTofu-compatible configurationAWS NAT gatewaysBounded AWS NAT gateway network resource with fixed hourly and per-GB processing assumptionsInferred
Terraform/OpenTofu-compatible configurationAWS Classic Load BalancersDistinct bounded Classic ELB network resource with an approximate fixed hourly charge; ASG load_balancers and ELB instances create serving edges only through direct local references. PR IaC has no observed per-ELB processed bytes, so processed-GB billing is excluded; data transfer is estimated separately. Unresolved registrations remain outside the model.Inferred
Terraform/OpenTofu-compatible configurationAWS interface VPC endpointsBounded AWS interface endpoint network resource with fixed endpoint-hour and per-GB processing assumptionsInferred
Terraform/OpenTofu-compatible configurationAWS detached Elastic IPsBounded AWS detached Elastic IP residual network charge; associated addresses remain outside the separate-resource modelInferred
Terraform/OpenTofu-compatible configurationAWS ECS Fargate servicesBounded Linux on-demand ECS/Fargate task fleet from literal or same-module-resolved task CPU/memory, FARGATE placement, awsvpc service networking, counts, and directly related literal ECS CPU auto-scaling policies; unsupported policy expressions remain explicitly incompleteInferred
CloudFormationECS Fargate servicesBounded Linux on-demand ECS/Fargate task fleet from literal task CPU/memory, FARGATE placement, awsvpc service networking, desired count, directly provable Application Auto Scaling bounds, and supported ECS CPU policy behavior in CloudFormation YAML or JSON; unresolved references and unsupported policy expressions remain explicitly incompleteInferred
CloudFormationECS Application Auto ScalingSource-observed MinCapacity and MaxCapacity plus directly related ECSServiceAverageCPUUtilization target tracking or alarm-linked ChangeInCapacity step scaling; scheduled and unsupported capacity behavior are not simulatedInferred
Kubernetes manifestsDeployments, StatefulSets, and ReplicaSetsInferred AWS workload capacity from replicas and CPU limits; AWS/us-east-1 and displayed shape are CWM defaults, not worker-node factsInferred
Kubernetes manifestsCPU HorizontalPodAutoscalersSource-proven replica bounds and CPU scale-out threshold for one Deployment or StatefulSetInferred
Helm chartsValues workload capacityInferred Kubernetes workload pool from bounded replica and CPU values; AWS/us-east-1 and the displayed shape are CWM defaults, not worker-node factsInferred
Helm chartsDisabled workload exclusionsLiteral enabled: false branches are excluded from modeled capacityInferred
Docker ComposeServicesAWS computeInferred
Docker ComposeSupported database-image servicesInferred AWS databaseInferred

The audit resolves only the bounded Terraform/OpenTofu-compatible module chains and literal or directly propagated variable inputs described above. It does not evaluate arbitrary module expressions, remote state, Helm template rendering, provider lookups, live infrastructure, or application traffic. An unsupported construct is a limitation to investigate, not evidence that it has no cost or operational impact. This reference lists supported construct categories only; it never includes repository content, filenames, or configuration values from pull requests.

If your IaC format is not listed above, the PR comment will note that no infrastructure was detected rather than producing a misleading report.

Need help?

Use the guided connection to connect a repository; an API key is not a prerequisite. Visit the full API reference for the underlying simulation endpoints the app uses.

Contact support

For help with the Cloud World Model GitHub App, email api@cloudworldmodel.ai.

Include the repository or pull request (PR) link and a brief description of the issue. Do not send API keys, credentials, or sensitive repository content.