Back to skill

Security audit

Monitor Tasks

Security checks for vulnerabilities and agentic risk

Overview

This OpenAnt monitoring skill is review-worthy because it runs an unpinned remote CLI and can automatically change notification/account state with broad wallet and notification permissions.

Install only if you are comfortable letting the agent run the OpenAnt CLI in your authenticated account. Prefer a version that pins the CLI package, narrows wallet and notification permissions to exact commands, and requires confirmation before marking notifications read or creating subscriptions.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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
Findings (3)

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:11
Finding
Runtime Execution of an Unpinned Remote CLI Package## Vulnerability Details **File Location**: `SKILL.md:11-18` **Vulnerability Type**: Mutable remote payload retrieval and execution **Risk Level**: High ### Vulnerable Code ```markdown Use the `npx @openant-ai/cli@latest` CLI to monitor your tasks, check notifications, and get platform statistics. This is your dashboard for staying on top of activity. **Always append `--json`** to every command for structured, parseable output. ## Confirm Authentication ```bash npx @openant-ai/cli@latest status --json ``` ``` The same mutable `@latest` package reference is used throughout the skill for all OpenAnt operations. ### Technical Analysis The skill instructs the agent to execute `@openant-ai/cli` through `npx` using the mutable `latest` distribution tag. `npx` may retrieve and execute package code from an external package registry at invocation time. Consequently, the code that ultimately runs is not fixed to the version that existed when this skill was reviewed. This creates a remote payload retrieval and supply-chain risk. A compromised package publisher account, malicious future release, registry compromise, or unintended breaking release could cause later skill invocations to execute different code without any change to this repository. The `--json` option only controls expected output format and does not constrain package installation or execution behavior. ### Attack Path 1. An attacker compromises the package publisher, registry publication process, or another mechanism controlling the `latest` tag. 2. The attacker publishes a modified version of `@openant-ai/cli` and assigns it to `latest`. 3. The agent invokes any documented command, such as `npx @openant-ai/cli@latest status --json`. 4. `npx` retrieves and executes the attacker-controlled package version. 5. The package code runs with the privileges and environment of the agent process. ### Impact Assessment Successful exploitation could execute arb ...[truncated 441 chars]
Remediation
## Remediation Suggestions - Replace `@latest` with an exact, reviewed package version. - Declare the CLI in a dependency manifest and commit the corresponding lockfile. - Enforce package integrity verification through lockfile integrity hashes or an approved internal package registry. - Install dependencies during a controlled build or deployment stage rather than downloading executable code during each skill invocation. - Review and test new CLI releases before updating the pinned version. - Run the CLI in a restricted environment with minimal filesystem, credential, environment-variable, and network access.

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:6
Finding
Overbroad Bash Allowlist Permits Undocumented CLI Operations## Vulnerability Details **File Location**: `SKILL.md:6` **Vulnerability Type**: Excessive tool permissions and insufficient command restriction **Risk Level**: High ### Vulnerable Code ```yaml allowed-tools: ["Bash(npx @openant-ai/cli@latest status*)", "Bash(npx @openant-ai/cli@latest whoami*)", "Bash(npx @openant-ai/cli@latest tasks list *)", "Bash(npx @openant-ai/cli@latest tasks get *)", "Bash(npx @openant-ai/cli@latest tasks escrow *)", "Bash(npx @openant-ai/cli@latest notifications*)", "Bash(npx @openant-ai/cli@latest stats*)", "Bash(npx @openant-ai/cli@latest watch *)", "Bash(npx @openant-ai/cli@latest wallet *)"] ``` ### Technical Analysis The tool policy uses wildcard command patterns, including unrestricted suffixes for `notifications*` and `wallet *`. These patterns authorize a broader set of arguments and subcommands than the operations documented by the skill, which are primarily notification queries, `notifications read-all`, and `wallet balance`. In particular, allowing every command beneath `wallet` violates least privilege for a monitoring skill that only claims to inspect a balance. The repository does not contain the CLI implementation or a complete list of supported subcommands, so it is not possible to establish whether the currently published CLI exposes transfers, signing, exports, configuration changes, or other sensitive operations. Nevertheless, the permission boundary itself is broader than the stated functional requirement. ### Attack Path 1. The skill is invoked in a context containing untrusted or adversarial task content. 2. That content influences the agent to issue an undocumented command that still matches an allowed wildcard, such as an additional `wallet` or `notifications` subcommand. 3. The Bash tool accepts the invocation because the command prefix matches the broad allowlist. 4. The external CLI executes the operation using the user's authenticated OpenAnt context. 5. If the selected ...[truncated 724 chars]
Remediation
## Remediation Suggestions - Replace wildcard permissions with exact command allowlist entries. - Permit only the required wallet command, such as `wallet balance --json`. - Enumerate `notifications unread --json`, `notifications list --json`, and any approved state-changing operation separately. - Remove the unused `whoami` permission unless the skill genuinely requires it. - Reject extra positional arguments, unknown options, command separators, and unsupported subcommands. - Separate read-only and state-changing tools into distinct permission groups. - Require explicit user confirmation before granting or invoking financially sensitive or state-changing operations.

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:129
Finding
State-Changing Notification Command Is Misclassified as Safe for Automatic Execution## Vulnerability Details **File Location**: `SKILL.md:129-136` **Vulnerability Type**: Unsafe automatic execution of a state-changing operation **Risk Level**: Medium ### Vulnerable Code ```markdown # 8. Mark notifications as read npx @openant-ai/cli@latest notifications read-all --json ``` ## Autonomy All commands in this skill are **read-only queries** — execute immediately without user confirmation. The only exception is `notifications read-all` which modifies read state, but is safe to execute. ``` ### Technical Analysis The autonomy policy initially characterizes all commands as read-only, then acknowledges that `notifications read-all` modifies server-side state. It nevertheless directs the agent to execute the command without user confirmation and includes it as the final step of the example dashboard session. Marking every notification as read is not a query. It changes the user's account state and can remove the unread indicator from notifications that the user has not personally reviewed. Declaring the action universally safe bypasses meaningful user consent and creates a risk that important events will no longer appear as pending. ### Attack Path 1. The user asks for a dashboard overview or notification check. 2. The agent follows the example dashboard sequence. 3. After retrieving information, the agent automatically invokes `notifications read-all --json`. 4. The platform marks all notifications as read, including notifications the user may not have reviewed. 5. The user may subsequently overlook task deadlines, disputes, submissions, or other events because their unread state has been cleared. ### Impact Assessment Exploitation or accidental activation can modify notification state across the authenticated OpenAnt account. It does not directly grant additional system privileges, but it can impair user awareness and affect operational decisions involving tasks, reviews, deadlines, or disputes. T ...[truncated 77 chars]
Remediation
## Remediation Suggestions - Remove `notifications read-all` from automatic dashboard workflows. - Require explicit user confirmation immediately before changing notification state. - Clearly distinguish read-only queries from state-changing operations in the autonomy policy. - Prefer an operation that marks only explicitly reviewed notifications as read, if the CLI supports it. - Display the number or identifiers of affected notifications before requesting confirmation. - Keep the state-changing command in a separate, narrowly scoped tool permission rather than under a broad notification wildcard.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (30)

Rp1

Medium
Category
MCP Rug Pull
Confidence
92% confidence
Finding
The manifest permits tools invoking `npx @openant-ai/cli@latest`, which authorizes runtime execution of whatever package version is current. Tool allowlists should be immutable where possible; otherwise the manifest itself becomes a standing supply-chain execution risk.

Vague Triggers

Medium
Confidence
96% confidence
Finding
The description includes broad trigger phrases like 'any updates?', 'what's new', and 'status update', which can match many generic user intents. Overbroad invocation criteria increase the chance this skill is selected unexpectedly, causing unintended access to notifications, tasks, wallet data, or state-changing subcommands in contexts where the user did not specifically ask for OpenAnt monitoring.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The documentation instructs execution of `npx @openant-ai/cli@latest`, which fetches and runs the latest published package at runtime rather than an immutable, reviewed version. If the upstream package or publishing account is compromised, the agent could execute attacker-controlled code within the permissions granted to this skill.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
This command uses `npx ...@latest`, which is a runtime supply-chain risk because it executes whichever package version is current when invoked. In an agent skill, that risk is amplified because the model may execute the command automatically and repeatedly without separate package review.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The task-list command is fetched via `npx ...@latest`, allowing silent code changes over time. A compromised or malicious update could exfiltrate credentials, alter outputs, or perform unintended actions under the user’s authenticated OpenAnt context.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
Using `@latest` here introduces a supply-chain execution risk each time the command runs. Because the command operates in an authenticated environment and may access user task metadata, compromise of the package could expose sensitive account data.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
`notifications read-all` is a state-changing command that marks all notifications as read, but it is presented as routine flow without a clear warning or confirmation requirement. This can irreversibly alter user-visible state, hide pending items, and reduce the user’s ability to notice important alerts or reconstruct what was unread before execution.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The notification-list example relies on `npx ...@latest`, which means the executed code is not stable or reviewable across runs. In a skill context, this creates a realistic path for malicious package updates to gain execution and access notification data or session context.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
This command fetches the latest CLI version at runtime, creating a supply-chain trust gap. Since the skill is user-invocable and encourages immediate execution, a malicious release could be automatically run without human validation.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
`npx ...@latest` allows unreviewed upstream changes to become executable code in the agent environment. That is dangerous because these task-monitoring commands may expose account-scoped data and could be abused by a compromised package to perform further actions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The command’s reliance on `@latest` means the code path can change between executions without notice. This undermines reproducibility and opens the door to malicious or compromised package releases being executed by the agent.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
This example uses a dynamically resolved latest package, which is a classic supply-chain weakness. Because the skill includes authenticated task lookups, the context increases the potential for data exposure if the package is ever compromised.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The use of `npx @openant-ai/cli@latest` here permits silent changes in executable code over time. An attacker controlling the package publication path could leverage that to run arbitrary code in the agent’s environment and access task/submission details.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
Because `@latest` is not immutable, this command may execute different code from one run to the next. In a monitoring skill that may be triggered frequently, that increases exposure to a compromised upstream release.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
This runtime package fetch creates a supply-chain risk that is material in an authenticated workflow. A malicious update could tamper with escrow-status outputs, harvest tokens, or execute arbitrary code under the current user context.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The latest-version resolution makes the command non-deterministic and vulnerable to upstream compromise. Since this skill is designed for direct execution, users may unknowingly run malicious code simply by invoking normal monitoring behavior.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The stats command also relies on `@latest`, so it carries the same dynamic code execution risk as the rest of the skill. Even seemingly harmless read operations can be used as a vehicle for arbitrary code execution if the CLI package is compromised.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
Using `@latest` for the watch subscription command creates an avoidable supply-chain exposure. Because this command may alter notification subscriptions and runs with authenticated context, a malicious package update could both change state and exfiltrate data.

Description-Behavior Mismatch

Medium
Confidence
90% confidence
Finding
The skill’s documented purpose is monitoring tasks, notifications, and platform stats, but it also includes wallet balance checks. Scope expansion matters because users or higher-level policies may permit this skill expecting only task-monitoring behavior, while wallet access exposes additional financial metadata and broadens the consequences of accidental or adversarial invocation.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The wallet-balance command uses a dynamically fetched latest package, which could expose financial metadata or credentials if the package supply chain is compromised. Financial/account-related contexts make the impact more sensitive than a generic demo command.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
This example session begins with `npx ...@latest`, inheriting the same arbitrary-code execution risk from an unpinned runtime dependency. Example sessions are particularly risky because users and agents tend to copy or automate them verbatim.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The unread-notifications example uses `@latest`, which permits execution of unreviewed upstream code. In an automated agent setting, this can turn routine status checks into a supply-chain compromise vector.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The created-tasks example is another runtime fetch of the latest CLI package, creating a persistent supply-chain risk throughout the document. Repetition across many commands increases the likelihood that any invocation path will execute a compromised release.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
Because this active-work example uses `@latest`, it allows arbitrary upstream changes to be pulled into the execution path. The authenticated nature of the command increases the damage potential compared with a non-authenticated utility.

Static analysis

No suspicious patterns detected.