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.
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
- Get Started and sign in with GitHub or email.
- Choose Connect GitHub repository and follow the guided GitHub authorization and installation flow.
- Review the repository access requested and explicitly confirm use of your CWM account credits. Linking your account does not prove that a repository exists.
- Open or update a pull request that changes supported infrastructure as code (IaC).
- 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.
Report sharing
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 permission | Access | Why |
|---|---|---|
| Contents | Read | Read selected infrastructure source and support files for the PR comparison. |
| Pull requests | Read and write | Read PR changes and support posting the PR report. |
| Issues | Read and write | Post and update PR conversation comments and acknowledge authorized /cwm simulate commands with a reaction. |
| Checks | Read and write | Create and update the simulation Check and handle rerun requests. |
| Metadata | Read | GitHub'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:
- Scans the changed files for Terraform/OpenTofu-compatible configuration and other infrastructure definitions (see supported formats below).
- Resolves the immutable base and head commit SHAs and fetches the touched IaC scope, including required support files, at each commit.
- Translates each ref's detected resource configuration into a canonical CWM simulation input.
- Runs both snapshots through the same seeded 30-step workload for one flat 10-credit charge.
- 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:
| Metric | Value used | Impact unit |
|---|---|---|
| Modeled total cost per hour | Final hourly run rate at the end of the shared 30-step window. | Signed $/hr |
| p99 latency | Highest p99 request latency observed across the shared window. | Signed milliseconds |
| Peak CPU | Highest CPU utilisation observed across the shared window. | Signed percentage points |
| Resilience | The 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:
| Format | Detection signal |
|---|---|
| Terraform/OpenTofu-compatible configuration | Standard 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. |
| CloudFormation | YAML or JSON files containing AWSTemplateFormatVersion or AWS:: resource types in the diff patch. |
| Kubernetes manifests | YAML files with both apiVersion: and kind: fields in the diff patch. GitHub Actions workflow files are explicitly excluded. |
| Helm charts | Chart.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 Compose | Files 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 area | Public compatibility scope |
|---|---|
| Standard Terraform/OpenTofu-compatible resource blocks | Supported resource families are extracted using the same bounded Terraform contract and classified in the coverage table below. |
| OpenTofu state encryption | The 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 constructs | Remain 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.
| Format | Supported construct category | CWM model | Classification |
|---|---|---|---|
| Terraform/OpenTofu-compatible configuration | GKE worker node pools | Default 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 configuration | EKS GPU managed nodegroups | Literal 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 |
| CloudFormation | EKS GPU managed nodegroups | Literal 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 configuration | DigitalOcean literal resources | Verified 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 configuration | Azure Kubernetes (AKS) default node pool | Inferred 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 capacity | Inferred |
| Terraform/OpenTofu-compatible configuration | DigitalOcean Kubernetes (DOKS) node pools | DigitalOcean 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 configuration | DigitalOcean Kubernetes (DOKS) HA control plane | Direct 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 unchanged | Inferred |
| Terraform/OpenTofu-compatible configuration | AWS EC2 instances | AWS compute | Exact |
| Terraform/OpenTofu-compatible configuration | AWS RDS instances | AWS database from the canonical RDS tier catalog | Exact |
| Terraform/OpenTofu-compatible configuration | AWS Lambda functions | AWS request-serving compute | Exact |
| Terraform/OpenTofu-compatible configuration | AWS Lambda provisioned-concurrency aliases | AWS Lambda warm capacity from direct local function, version, and alias references | Inferred |
| Terraform/OpenTofu-compatible configuration | AWS Lambda standalone provisioned concurrency | AWS Lambda warm capacity from direct local function, version, or alias references | Inferred |
| Terraform/OpenTofu-compatible configuration | AWS Launch Template Auto Scaling Groups | AWS 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 default | Inferred |
| Terraform/OpenTofu-compatible configuration | AWS mixed-instance Launch Template Auto Scaling Groups | AWS compute fleet from a direct mixed_instances_policy template relationship with unique member types, source-proven launch-template revision selection, and bounded capacity | Inferred |
| Terraform/OpenTofu-compatible configuration | GCP Compute Engine instances | GCP compute | Exact |
| Terraform/OpenTofu-compatible configuration | GCP Cloud SQL primary instances and read replicas | Bounded 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 exclusions | Exact |
| Terraform/OpenTofu-compatible configuration | GCP Cloud Functions v2 | GCP request-serving compute | Exact |
| Terraform/OpenTofu-compatible configuration | GCP regional Managed Instance Group autoscalers | GCP 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 floor | Inferred |
| Terraform/OpenTofu-compatible configuration | GCP Cloud Run v2 services | GCP request-serving compute from literal container CPU/memory, concurrency, and scaling settings; expressions and regional topology remain explicitly incomplete | Inferred |
| Terraform/OpenTofu-compatible configuration | Azure virtual machines | Azure compute | Exact |
| Terraform/OpenTofu-compatible configuration | Azure function and container apps | Azure request-serving compute | Exact |
| Terraform/OpenTofu-compatible configuration | OCI compute instances | OCI compute | Exact |
| Terraform/OpenTofu-compatible configuration | OCI Functions | OCI request-serving compute | Exact |
| Terraform/OpenTofu-compatible configuration | OCI databases | OCI Autonomous Database and MySQL HeatWave | Inferred |
| Terraform/OpenTofu-compatible configuration | OCI storage | OCI Object, Block, and File Storage | Inferred |
| Terraform/OpenTofu-compatible configuration | OCI load balancing | OCI Load Balancer and Network Load Balancer | Inferred |
| Terraform/OpenTofu-compatible configuration | OCI cache and messaging | OCI Cache Redis, Streaming, and Queue | Inferred |
| Terraform/OpenTofu-compatible configuration | OCI Kubernetes | OCI 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 tiers | Inferred |
| CloudFormation | EC2 instances | AWS compute | Exact |
| CloudFormation | Lambda functions | AWS request-serving compute | Exact |
| CloudFormation / AWS SAM | Serverless functions | Inferred 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 unmodeled | Inferred |
| CloudFormation | Lambda provisioned-concurrency aliases | AWS Lambda warm capacity from direct local function, version, and alias references | Inferred |
| CloudFormation | RDS DB instances | AWS database | Exact |
| CloudFormation | AWS application and network load balancers | Bounded 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 model | Inferred |
| Terraform/OpenTofu-compatible configuration | AWS application, network, and gateway load balancers | Bounded 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 model | Inferred |
| Terraform/OpenTofu-compatible configuration | AWS NAT gateways | Bounded AWS NAT gateway network resource with fixed hourly and per-GB processing assumptions | Inferred |
| Terraform/OpenTofu-compatible configuration | AWS Classic Load Balancers | Distinct 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 configuration | AWS interface VPC endpoints | Bounded AWS interface endpoint network resource with fixed endpoint-hour and per-GB processing assumptions | Inferred |
| Terraform/OpenTofu-compatible configuration | AWS detached Elastic IPs | Bounded AWS detached Elastic IP residual network charge; associated addresses remain outside the separate-resource model | Inferred |
| Terraform/OpenTofu-compatible configuration | AWS ECS Fargate services | Bounded 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 incomplete | Inferred |
| CloudFormation | ECS Fargate services | Bounded 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 incomplete | Inferred |
| CloudFormation | ECS Application Auto Scaling | Source-observed MinCapacity and MaxCapacity plus directly related ECSServiceAverageCPUUtilization target tracking or alarm-linked ChangeInCapacity step scaling; scheduled and unsupported capacity behavior are not simulated | Inferred |
| Kubernetes manifests | Deployments, StatefulSets, and ReplicaSets | Inferred AWS workload capacity from replicas and CPU limits; AWS/us-east-1 and displayed shape are CWM defaults, not worker-node facts | Inferred |
| Kubernetes manifests | CPU HorizontalPodAutoscalers | Source-proven replica bounds and CPU scale-out threshold for one Deployment or StatefulSet | Inferred |
| Helm charts | Values workload capacity | Inferred Kubernetes workload pool from bounded replica and CPU values; AWS/us-east-1 and the displayed shape are CWM defaults, not worker-node facts | Inferred |
| Helm charts | Disabled workload exclusions | Literal enabled: false branches are excluded from modeled capacity | Inferred |
| Docker Compose | Services | AWS compute | Inferred |
| Docker Compose | Supported database-image services | Inferred AWS database | Inferred |
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.
