Back to skill

Security audit

vmware-aiops

Security checks for vulnerabilities and agentic risk

Overview

The skill is transparent about VMware administration, but it exposes destructive MCP operations and guest command execution that can run immediately with configured infrastructure credentials.

Install only with a dedicated least-privilege VMware account, preferably read-only unless you truly need writes. Treat MCP mode as capable of immediate infrastructure changes, keep guest credentials separate and minimal, avoid root guest accounts, and pin/verify the vmware-aiops package before production use.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (2)

T09 · Insecure Skill Coding Practices

Error
Location
references/capabilities.md:30
Finding
Destructive MCP Operations Execute Without Enforced Approval<![CDATA[ ## Vulnerability Details **File Location**: `references/capabilities.md:30-45` **Supporting Locations**: `SKILL.md:207-211`; `references/agent-guardrails.md:96-106` **Vulnerability Type**: Missing authorization and approval enforcement for high-impact operations **Risk Level**: High ### Vulnerable Code Snippet ```markdown | **MCP** | **None, by design.** A write tool acts on the first call. There is no `confirmed=` handshake, no approval tier, and no read-only switch — the switch existed in v1.8.0–1.8.6 and was removed in v1.8.7 (decision **D-2** of the family security HLD, 2026-07-21) because it was enforced on the MCP path only and any agent with a shell stepped around it. A two-step handshake was considered in the same review and cut: it is neither authorization nor accountability, only a speed-bump that a model intending to act steps over by passing `confirmed=True`. | 7 of the 43 write tools default to a no-write preview (below) | **What actually protects the estate over MCP is the vCenter/ESXi service account.** Writes the account may not perform are refused by vCenter itself, whatever the agent intends, on every surface, with no way around it from inside the skill. To run an agent read-only, give it a read-only vCenter role and point the skill's `.env` at that account — one decision, enforced where it is made. What happened is then recoverable from `~/.vmware/audit.db`, which every write goes through before the caller sees a result. Nothing in this skill will stop `vm_delete` deleting a VM the account is allowed to delete. - **Write tools: 43** — every tool whose description starts `[WRITE]` and whose `readOnlyHint` is `false`. - **Confirm-gated: 7** — `add_host_vmk`, `create_drs_rule`, `create_dvs_portgroup`, `delete_drs_rule`, `remove_host_vmk`, `set_drs_rule_enabled`, `set_vmk_service` <br>These host-networking and DRS authoring tools take a `confirm` argument that defaults to false, in which case they validate everything they can and ...[truncated 3148 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Make the MCP server read-only by default and require an explicit administrative configuration to expose write tools. 2. Implement server-enforced two-phase authorization for destructive and guest-writing operations: - First call validates the request and returns an immutable operation digest. - A separately authenticated approval service issues a short-lived approval token bound to the digest, target, requester, and expiration. - The execution call must present that token and must reject changed parameters. 3. Require external human approval for VM deletion, cluster deletion, snapshot reversion or deletion, forced shutdown, network removal, alarm reset, TTL deletion, guest execution, and guest file upload. 4. Enforce deny-by-default policy rules for production targets rather than relying on operators to create optional deny rules. 5. Separate guest operations into an independently enabled component with distinct credentials and policy controls. 6. Prohibit root or administrator guest credentials by default. Use dedicated guest accounts restricted to the commands, paths, and VMs required for the task. 7. Add command allowlists, argument validation, destination-path restrictions, and execution timeouts for guest operations. 8. Ensure approval and authorization checks occur inside the server and cannot be bypassed through the shell or an alternative client. 9. Retain audit logging, but treat it as a detective control rather than a substitute for preventive authorization. ]]>

T08 · Insecure Dependencies

Warning
Location
references/setup-guide.md:7
Finding
Unpinned External Package Installation Creates a Supply-Chain Execution Risk<![CDATA[ ## Vulnerability Details **File Location**: `references/setup-guide.md:7-15` **Supporting Locations**: `SKILL.md:9-12,51-71,291-294`; `references/setup-guide.md:37-45,69-75,160-164` **Vulnerability Type**: Mutable and unverifiable third-party dependency installation **Risk Level**: Medium ### Vulnerable Code Snippet ```bash # Via PyPI (recommended for version pinning) uv tool install vmware-aiops==1.2.3 # Via Skills.sh (fetches from GitHub) npx skills add vmware-skills/VMware-AIops # Via ClawHub (fetches from ClawHub registry snapshot of GitHub) clawhub install @zw008/vmware-aiops ``` The primary setup instructions also use an unpinned package: ```bash # 1. Install from PyPI (source: github.com/vmware-skills/VMware-AIops) uv tool install vmware-aiops # 2. Verify installation source vmware-aiops --version # confirms installed version ``` ### Technical Analysis The audited artifact contains documentation but does not include the implementation source, a complete dependency lockfile, artifact hashes, or signed provenance for the executable `vmware-aiops` package. Several recommended installation paths resolve mutable external packages from PyPI, GitHub-oriented tooling, or a registry. Although one example pins `vmware-aiops` to version `1.2.3`, the primary installation commands are unpinned. A version pin alone also does not authenticate package contents without an expected cryptographic digest or verified signature. Running `vmware-aiops --version` confirms only what the installed binary reports; it does not prove that the artifact came from the expected source repository or that it was not modified. The installed program is expected to access `~/.vmware-aiops/.env`, connect to vCenter or ESXi, and perform high-impact infrastructure operations. Consequently, a compromised package release, registry account, transitive dependency, or mutable installer path would execute in a highly sensitive context. No malicious dependency was identified in ...[truncated 1775 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the main package and every transitive dependency to reviewed versions. 2. Publish and require SHA-256 hashes for all downloaded wheels, archives, registry snapshots, and installer artifacts. 3. Use signed releases and verify signatures or Sigstore attestations before installation. 4. Publish reproducible-build instructions and provenance that binds each package artifact to a specific source commit. 5. Include a complete lockfile in the audited project and install using locked dependencies with hash verification. 6. Avoid installation commands that re-resolve current packages on every launch, including legacy `uvx` workflows. 7. Do not treat `--version` output as source verification. Verify package metadata, cryptographic digest, signature, and source commit independently. 8. Mirror approved packages into a controlled internal registry for production deployments. 9. Run the package under a dedicated operating-system account with access only to required configuration files. 10. Use narrowly scoped vCenter and guest credentials so compromise of the local package does not grant estate-wide administrative access. 11. Add automated dependency scanning, release-signature verification, and registry ownership monitoring to the publication pipeline. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Rogue AgentSelf-Modification, Session Persistence
Findings (49)

Credential Access

High
Category
Privilege Escalation
Content
argument-hint: "[vm-name or describe your task]"
allowed-tools:
  - Bash
metadata: {"openclaw":{"requires":{"env":["VMWARE_AIOPS_CONFIG"],"bins":["vmware-aiops"],"config":["~/.vmware-aiops/config.yaml","~/.vmware-aiops/.env"]},"optional":{"env":["VMWARE_TARGET_PASSWORD","VMWARE_<TARGET>_USERNAME","SLACK_WEBHOOK_URL","DISCORD_WEBHOOK_URL","VMWARE_AUDIT_APPROVED_BY"],"bins":["vmware-policy"]},"primaryEnv":"VMWARE_AIOPS_CONFIG","homepage":"https://github.com/vmware-skills/VMware-AIops","emoji":"🖥️","os":["macos","linux"]}}
compatibility: >
  vmware-policy auto-installed as Python dependency (provides @vmware_tool decorator and audit logging). All write operations audited to ~/.vmware/audit.db.
  Credentials: Each vCenter/ESXi target requires a per-target password env var in ~/.vmware-aiops/.env following the pattern VMWARE_<TARGET_NAME_UPPER>_PASSWORD. Passwords are never logged or echoed.
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
metadata: {"openclaw":{"requires":{"env":["VMWARE_AIOPS_CONFIG"],"bins":["vmware-aiops"],"config":["~/.vmware-aiops/config.yaml","~/.vmware-aiops/.env"]},"optional":{"env":["VMWARE_TARGET_PASSWORD","VMWARE_<TARGET>_USERNAME","SLACK_WEBHOOK_URL","DISCORD_WEBHOOK_URL","VMWARE_AUDIT_APPROVED_BY"],"bins":["vmware-policy"]},"primaryEnv":"VMWARE_AIOPS_CONFIG","homepage":"https://github.com/vmware-skills/VMware-AIops","emoji":"🖥️","os":["macos","linux"]}}
compatibility: >
  vmware-policy auto-installed as Python dependency (provides @vmware_tool decorator and audit logging). All write operations audited to ~/.vmware/audit.db.
  Credentials: Each vCenter/ESXi target requires a per-target password env var in ~/.vmware-aiops/.env following the pattern VMWARE_<TARGET_NAME_UPPER>_PASSWORD. Passwords are never logged or echoed.
  Destructive operations: All write tools require explicit parameters and pass through the @vmware_tool decorator (pre-check + audit + sanitize). CLI destructive commands additionally require double confirmation and support --dry-run; the MCP tools have neither — a write acts on the first call, and read/write authorization is delegated to the vCenter service account (give an agent a read-only vCenter role to run it read-only).
  Guest operations: Require explicit vm_name, command (full path), arguments, username parameters — no implicit or background execution. The command is unbounded and runs with the guest credentials supplied, so the guest account is a second authorization boundary independent of the vCenter one; omit guest credentials if guest ops are not needed.
  Webhooks: Disabled by default. When enabled, send only aggregated alert metadata (alarm counts, event types) to user-configured URLs. No credentials, IPs, or PII in payloads.
Confidence
84% confidence
Finding
The skill relies on plaintext per-target passwords in `~/.vmware-aiops/.env` and also exposes Bash as an allowed tool. In an adversarial-agent context, any skill that both depends on accessible local secret files and can invoke shell commands increases the chance of credential disclosure through accidental reads, prompt injection, or misuse of companion tooling.

Ae1

High
Category
analysis-evasion
Content
re list (complete by construction). Rationale, `total` semantics, error shape: `references/capabilities.md`.
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
re list (complete by construction). Rationale, `total` semantics, error shape: `references/capabilities.md`.
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Credential Access

High
Category
Privilege Escalation
Content
```bash
uv tool install vmware-aiops
mkdir -p ~/.vmware-aiops
vmware-aiops init  # generates config.yaml and .env templates
chmod 600 ~/.vmware-aiops/.env
```
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
```bash
uv tool install vmware-aiops
mkdir -p ~/.vmware-aiops
vmware-aiops init  # generates config.yaml and .env templates
chmod 600 ~/.vmware-aiops/.env
```
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
`vm_guest_exec` runs a caller-supplied command inside the guest OS through
VMware Tools, with the credentials passed to it — which its own documented
example makes `root`. Nothing in this skill bounds what the command may be:
`rm -rf /` is a well-formed argument, and the same is true of
`vm_guest_exec_output` and of the `exec` steps inside `vm_guest_provision`.
It is the widest blast radius in the skill and it is ungated over MCP.
Confidence
100% confidence
Finding
This duplicate finding points to the same issue: unbounded command execution inside a VM through `vm_guest_exec`, `vm_guest_exec_output`, and `vm_guest_provision` exec steps. Since the skill manages production VMware environments, arbitrary in-guest command execution is especially dangerous because it bypasses many vCenter-side read-only assumptions and depends on guest credentials, creating a second powerful execution path.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
`vm_guest_exec` runs a caller-supplied command inside the guest OS through
VMware Tools, with the credentials passed to it — which its own documented
example makes `root`. Nothing in this skill bounds what the command may be:
`rm -rf /` is a well-formed argument, and the same is true of
`vm_guest_exec_output` and of the `exec` steps inside `vm_guest_provision`.
It is the widest blast radius in the skill and it is ungated over MCP.
Confidence
100% confidence
Finding
This duplicate finding points to the same issue: unbounded command execution inside a VM through `vm_guest_exec`, `vm_guest_exec_output`, and `vm_guest_provision` exec steps. Since the skill manages production VMware environments, arbitrary in-guest command execution is especially dangerous because it bypasses many vCenter-side read-only assumptions and depends on guest credentials, creating a second powerful execution path.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
```bash
# Diagnostics
vmware-aiops doctor [--skip-auth]

# MCP Config Generator
vmware-aiops mcp-config generate --agent <goose|cursor|claude-code|continue|vscode-copilot|localcowork|mcp-agent>
Confidence
87% confidence
Finding
Documenting a --skip-auth option suggests an authentication bypass mode, which can be abused if available outside tightly controlled diagnostics scenarios. Even if intended for troubleshooting, exposing this in general reference material normalizes use of unauthenticated operation and can lead to misuse or implementation shortcuts around security checks.

Credential Access

High
Category
Privilege Escalation
Content
# 3. Configure
mkdir -p ~/.vmware-aiops
vmware-aiops init  # generates config.yaml and .env templates
chmod 600 ~/.vmware-aiops/.env
# Edit ~/.vmware-aiops/config.yaml and .env with your target details
```
Confidence
87% confidence
Finding
The setup guide instructs users to store VMware target credentials in a local `.env` file, which creates a concentrated secrets store on disk for infrastructure-administration accounts. Even with restrictive permissions and base64 obfuscation, compromise of the user account, backups, shell history, endpoint malware, or accidental inclusion in tooling can expose credentials with direct impact on vCenter/ESXi operations.

Credential Access

High
Category
Privilege Escalation
Content
# 3. Configure
mkdir -p ~/.vmware-aiops
vmware-aiops init  # generates config.yaml and .env templates
chmod 600 ~/.vmware-aiops/.env
# Edit ~/.vmware-aiops/config.yaml and .env with your target details
```
Confidence
87% confidence
Finding
The generated `.env` template combined with explicit post-install handling encourages keeping operational secrets in a predictable local file path. In the context of a VM-management tool capable of state-changing actions, theft of those secrets could enable shutdowns, cloning, snapshot abuse, or broader infrastructure compromise.

Credential Access

High
Category
Privilege Escalation
Content
mkdir -p ~/.vmware-aiops
vmware-aiops init  # generates config.yaml and .env templates
chmod 600 ~/.vmware-aiops/.env
# Edit ~/.vmware-aiops/config.yaml and .env with your target details
```

### Declare `environment:` on each target
Confidence
85% confidence
Finding
Telling users to edit `.env` with target details reinforces manual secret handling in plaintext-adjacent local files. Because this skill manages virtualization infrastructure, exposed credentials have elevated blast radius compared with ordinary app credentials.

Agent Config Directory Access

High
Category
Agent Snooping
Content
## MCP Mode (Optional)

For Claude Code / Cursor users who prefer structured tool calls, add to `~/.claude/settings.json`:

```json
{
Confidence
90% confidence
Finding
Skill reads from agent configuration directories (.claude/, .codex/, .gemini/). These directories may contain API keys, personal settings, and other credentials that the skill has no legitimate need to access.

Description-Behavior Mismatch

Medium
Confidence
88% confidence
Finding
The manifest frames this skill as the entry point for VM operations and explicitly says not to use it for NSX networking, storage/iSCSI/vSAN, or Kubernetes lifecycle. However, the documented capabilities include creating dvSwitch portgroups, adding/removing host VMkernel interfaces, setting VMkernel services, and creating/deleting clusters and adding/removing hosts, which materially extend beyond VM lifecycle management and overlap adjacent infrastructure domains.

Session Persistence

Medium
Category
Rogue Agent
Content
- Bash
metadata: {"openclaw":{"requires":{"env":["VMWARE_AIOPS_CONFIG"],"bins":["vmware-aiops"],"config":["~/.vmware-aiops/config.yaml","~/.vmware-aiops/.env"]},"optional":{"env":["VMWARE_TARGET_PASSWORD","VMWARE_<TARGET>_USERNAME","SLACK_WEBHOOK_URL","DISCORD_WEBHOOK_URL","VMWARE_AUDIT_APPROVED_BY"],"bins":["vmware-policy"]},"primaryEnv":"VMWARE_AIOPS_CONFIG","homepage":"https://github.com/vmware-skills/VMware-AIops","emoji":"🖥️","os":["macos","linux"]}}
compatibility: >
  vmware-policy auto-installed as Python dependency (provides @vmware_tool decorator and audit logging). All write operations audited to ~/.vmware/audit.db.
  Credentials: Each vCenter/ESXi target requires a per-target password env var in ~/.vmware-aiops/.env following the pattern VMWARE_<TARGET_NAME_UPPER>_PASSWORD. Passwords are never logged or echoed.
  Destructive operations: All write tools require explicit parameters and pass through the @vmware_tool decorator (pre-check + audit + sanitize). CLI destructive commands additionally require double confirmation and support --dry-run; the MCP tools have neither — a write acts on the first call, and read/write authorization is delegated to the vCenter service account (give an agent a read-only vCenter role to run it read-only).
  Guest operations: Require explicit vm_name, command (full path), arguments, username parameters — no implicit or background execution. The command is unbounded and runs with the guest credentials supplied, so the guest account is a second authorization boundary independent of the vCenter one; omit guest credentials if guest ops are not needed.
Confidence
90% confidence
Finding
The skill persists sensitive operational history in `~/.vmware/audit.db` and stores long-lived credentials in `~/.vmware-aiops/.env`. Even if passwords are not logged, persistent local artifacts can reveal infrastructure names, targets, user actions, and approval metadata that may aid lateral movement or post-compromise reconnaissance on the agent host.

Session Persistence

Medium
Category
Rogue Agent
Content
| Cluster Triage (1) | `cluster_health_summary` (delegates to vmware-monitor) | Read |
| Object Investigation (4) | `vm_investigation_bundle`, `host_investigation_bundle`, `datastore_investigation_bundle`, `cross_vcenter_attention` (all delegate to vmware-monitor) | Read |

**List envelope**: the read list tools — `browse_datastore`, `list_vcenter_alarms`, `vm_list_plans`, `vm_list_snapshots`, `vm_list_ttl` — return `{items, returned, limit, total, truncated, hint}` rather than a bare array. Read the rows from `items` and check `truncated` before concluding a listing is complete; empty `items` with `truncated: false` means checked-and-none, not a failure. The write `batch_*` tools keep their bare list (complete by construction). Rationale, `total` semantics, error shape: `references/capabilities.md`.

**Read/write split**: 17 tools are read-only (per `[READ]` docstring marker), 43 modify state. All write tools require explicit parameters and are audit-logged. Destructive operations (`vm_delete`, `vm_revert_snapshot`, `vm_delete_snapshot`, `vm_set_ttl` (schedules an unattended auto-delete), force power-off, cluster delete/remove-host, alarm reset, guest exec/upload, `remove_host_vmk`, `delete_drs_rule`) require double confirmation at the CLI layer and support `--dry-run`.
Confidence
60% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
**Read/write split**: 17 tools are read-only (per `[READ]` docstring marker), 43 modify state. All write tools require explicit parameters and are audit-logged. Destructive operations (`vm_delete`, `vm_revert_snapshot`, `vm_delete_snapshot`, `vm_set_ttl` (schedules an unattended auto-delete), force power-off, cluster delete/remove-host, alarm reset, guest exec/upload, `remove_host_vmk`, `delete_drs_rule`) require double confirmation at the CLI layer and support `--dry-run`.

**The MCP tools have no confirmation step and no dry-run** — a write acts on the first call, by design (HLD D-2). What decides whether it lands is the vCenter account's privilege; what records it is `~/.vmware/audit.db`. To run an agent read-only, give it a read-only vCenter role. `vm_guest_exec` is the widest blast radius here: an unbounded command run inside the guest with the credentials passed in (`root` in the documented example), ungated. The guest account is a second authorization boundary — a read-only vCenter role does not constrain it. Inventory: `references/capabilities.md`.

**Network write gating**: `create_dvs_portgroup`, `add_host_vmk`, and `set_vmk_service` are preview/confirm-gated — `confirm=False` (default) returns the exact spec that would be applied without writing. `remove_host_vmk` is **fail-closed**: it refuses when the vmk is selected for a host service (management/vMotion/vSAN), lives on a non-default netstack (NSX TEPs, dedicated vMotion stacks), carries a default gateway route, or when any of that cannot be verified — pass `force_unprotected=True` to override the non-absolute protections. The host's only management-enabled vmk is never removable (no override). `set_vmk_service` is **fail-closed** too: it refuses both directions when the host's service map is unreadable, and refuses (no override) to untag `management` from the host's only management-enabled vmk — the call rides the interface it would untag.
Confidence
99% confidence
Finding
The skill explicitly states that MCP write tools execute immediately with no confirmation step or dry-run, including destructive VM, cluster, alarm, network, and guest-exec operations. In an agent setting, this creates a real autonomous-action hazard: a prompt mistake, prompt injection, or model misinterpretation can trigger irreversible infrastructure changes on first call.

Session Persistence

Medium
Category
Rogue Agent
Content
vmware-aiops cluster info <name>
vmware-aiops cluster drs-rules <name>                                     # list DRS rules
vmware-aiops cluster drs-rule-set <name> --rule <r> --enable|--disable [--dry-run]
vmware-aiops cluster drs-rule-create <name> --rule <r> --type antiAffinity --vm <vm1> --vm <vm2> [--disabled] [--dry-run]
vmware-aiops cluster drs-rule-delete <name> --rule <r> [--dry-run]        # VM-VM only; double confirm

# Datastore
Confidence
60% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Session Persistence

Medium
Category
Rogue Agent
Content
|---|---|
| "Use explicit limits for queries that may return large amounts of data" | **The list envelope.** `browse_datastore`, `list_vcenter_alarms`, `vm_list_plans`, `vm_list_snapshots` and `vm_list_ttl` return `{items, returned, limit, total, truncated, hint}`, so the model reads truncation instead of guessing at it. |
| "If a listing came back empty, say so rather than claiming the call failed" | Same envelope. Empty `items` with `truncated: false` means checked-and-none — a stated result, not a silence the model has to interpret. |
| "Log every state change you make" | **The `@vmware_tool` decorator.** Every write is recorded to `~/.vmware/audit.db` before the model sees the result, and policy rules are evaluated ahead of execution. Neither depends on the model cooperating. |
| "Block state-changing writes against a production target" | **Policy.** An opt-in environment-scoped `deny` rule in `~/.vmware/rules.yaml` matches a target's `environment:` label and refuses matching writes before execution. |

---
Confidence
60% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
- L1/L2 tools are read-only and safe for agents to call unprompted.
- **The levels describe risk, not enforcement.** Nothing in this skill stops an agent calling an L3 or L4 tool over MCP. What decides whether the write lands is the vCenter account — see [What gates a write](#what-gates-a-write).
- **List envelope**: the read list tools (`browse_datastore`, `list_vcenter_alarms`, `vm_list_plans`, `vm_list_snapshots`, `vm_list_ttl`) return `{items, returned, limit, total, truncated, hint}` instead of a bare array, so an agent can tell a complete answer from a first page rather than inferring it (issue #31). All five enumerate their collection in full before any limit is applied, so `total` is always the real count; only `list_vcenter_alarms` takes a `limit` and can therefore report `truncated: true`. The write `batch_*` tools deliberately keep a bare list — each row is a per-item result of work already done, complete by construction. Errors from these read tools are `{error, hint}` (a dict, not a one-element list).
- L3+ tools always pass through the `@vmware_tool` decorator: connection check → policy check (opt-in `deny` rules only; nothing is denied by default) → audit log. There is no confirmation step in that chain.
- Multi-party approval, where it is genuinely required, is [vmware-pilot](https://github.com/vmware-skills/VMware-Pilot)'s job — it has the state machine and a real human approval step. See it also for cross-skill L4 orchestration and the Dispatcher/Subagent pattern.

## What gates a write
Confidence
98% confidence
Finding
The documentation explicitly states that L3/L4 write tools can be invoked over MCP without any confirmation or enforced approval, and that policy checks deny nothing by default. In a skill whose purpose is VM lifecycle and infrastructure management, this enables an autonomous agent to power off, delete, migrate, or otherwise modify production resources on a single call if the bound service account permits it.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
| Surface | Confirmation | Preview |
|---|---|---|
| **CLI** | Two interactive `typer.confirm` prompts before every irreversible or guest-writing command. The set is derived from the MCP `destructiveHint` annotations, so a new such command fails the test suite until it has them, and a declined prompt is audited as `rejected`. *Honest limitation:* an agent with a shell satisfies both prompts by piping `yes` into the command. This defends the mistyped command, not a determined caller. | `--dry-run` on every write command |
| **MCP** | **None, by design.** A write tool acts on the first call. There is no `confirmed=` handshake, no approval tier, and no read-only switch — the switch existed in v1.8.0–1.8.6 and was removed in v1.8.7 (decision **D-2** of the family security HLD, 2026-07-21) because it was enforced on the MCP path only and any agent with a shell stepped around it. A two-step handshake was considered in the same review and cut: it is neither authorization nor accountability, only a speed-bump that a model intending to act steps over by passing `confirmed=True`. | 7 of the 43 write tools default to a no-write preview (below) |

**What actually protects the estate over MCP is the vCenter/ESXi service account.**
Writes the account may not perform are refused by vCenter itself, whatever the
Confidence
99% confidence
Finding
The file says 'MCP: None, by design' for confirmation and approval, meaning write actions execute immediately on first invocation. Relying solely on external vCenter permissions is insufficient as an application-layer safety control, because any over-privileged account or mis-scoped agent can immediately perform destructive infrastructure changes through this skill.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
| Feature | Details |
|---------|---------|
| Plan → Confirm → Execute → Log | CLI workflow: show current state, confirm changes, execute, audit log |
| Double Confirmation (**CLI only**) | CLI destructive commands (power-off, delete, reconfigure, snapshot-revert/delete, clean-slate, guest-exec, guest-upload, cluster delete/remove-host, alarm clear) require 2 sequential prompts and take no bypass flag. **The MCP tools have no confirmation step at all** — see [What gates a write](#what-gates-a-write) |
| Rejection Logging | Declined CLI confirmations are recorded in the audit trail for security review |
| Audit Trail | All operations logged to `~/.vmware/audit.db` (SQLite WAL, via vmware-policy) with before/after state |
| Input Validation | VM name length/format, CPU (1-128), memory (128-1048576 MB), disk (1-65536 GB) validated before execution |
Confidence
97% confidence
Finding
The 'Safety Features' section confirms that double confirmation exists only for CLI usage and that MCP tools have no confirmation step at all. Because this skill is designed for agent use, the absence of an MCP-side guard materially increases the chance of unintended or unauthorized writes to VMs, clusters, and alarms.

Unsafe Defaults

Medium
Category
Tool Misuse
Content
```bash
# Diagnostics
vmware-aiops doctor [--skip-auth]

# MCP Config Generator
vmware-aiops mcp-config generate --agent <goose|cursor|claude-code|continue|vscode-copilot|localcowork|mcp-agent>
Confidence
82% confidence
Finding
An authentication-skipping flag represents an unsafe operational pathway and may encourage workflows that rely on weakened security assumptions. In a VM management skill with high-privilege actions, any ambiguity around auth enforcement materially increases the risk of unauthorized diagnostics or misuse.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
This reference exposes destructive VM operations such as power-off, delete, snapshot revert, and migration without clear warnings about service interruption, irreversibility, or prerequisites. In an agent context, lack of safety guidance increases the risk of an operator or model invoking high-impact actions without adequate confirmation or change controls.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The manifest describes this skill as the entry point for VM operations such as power, clone, snapshot, migrate, deploy, guest command execution, batch operations, cluster management, alarm acknowledgment, and triage/investigation. This reference expands the skill’s advertised behavior to additional areas not declared there, including direct VM create/delete/reconfigure, guest file transfer, datastore operations, background daemon management, and MCP configuration generation, creating a description-behavior mismatch at the documented interface level.

Static analysis

No suspicious patterns detected.