Back to skill

Security audit

Autonomy Ladder

Security checks for vulnerabilities and agentic risk

Overview

This skill openly provides an autonomy framework, but it asks agents to persist broad decision rules and act without prior approval on production, financial, credential, infrastructure, repository, and customer-facing actions.

Review this carefully before installing. It is not evidence of malware, but it should only be used after narrowing the tiers to your own environment, keeping credential, production, financial, repository-write, infrastructure, and external-message actions approval-gated, and avoiding persistent MEMORY/SOUL/HEARTBEAT changes unless you explicitly approve the exact text and have a rollback path.

Vulnerability Patterns
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
Findings (2)

T02 · Agent Memory Poisoning

Error
Location
SKILL.md:14
Finding
Persistent Poisoning of Agent Memory and Decision Policy<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 14-16; related instructions at lines 59-68 and 109-114 **Vulnerability Type**: Persistent insertion of attacker-controlled behavioral rules into agent memory **Risk Level**: High ### Vulnerable Code ```markdown Add this to your `MEMORY.md` and reference it from `SOUL.md`: ```markdown ## Autonomy Ladder ``` The persistence mechanism is reinforced later in the file: ```markdown ### In SOUL.md Reference the ladder in your agent's decision-making section: ```markdown ## Decision-Making - Consult the Autonomy Ladder in MEMORY.md before acting - When an action doesn't clearly fit a tier, default to the more cautious tier - When in doubt between Tier 2 and Tier 3, ask — the cost of asking is low - Fix first, report after applies ONLY to Tier 1 actions ``` ``` The quick-start instructions explicitly direct the user or agent to perform the persistent modification: ```markdown 1. Copy the framework above into your `MEMORY.md` 2. Customize the bullet points for your specific business 3. Add a reference to it in your `SOUL.md` decision-making section 4. Start with a conservative distribution (more items in Tier 3) 5. Review and promote items monthly based on track record ``` ### Technical Analysis The skill does not keep its autonomy guidance scoped to the current invocation. It explicitly directs that the supplied rules be copied into `MEMORY.md` and referenced from `SOUL.md`, which are presented as persistent agent memory and decision-policy files. Once installed, the injected rules can influence unrelated future sessions without requiring the skill to be loaded again. The instruction to consult the ladder before acting makes the injected content part of the agent's general decision process. This is consistent with memory poisoning because attacker-supplied behavioral policy is written into durable state and used to govern later actions. The monthly promotion mechanism can further expand t ...[truncated 1407 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove all instructions that copy skill-controlled policy into `MEMORY.md`, `SOUL.md`, or other persistent agent-state files. 2. Keep the autonomy framework scoped to the current invocation by default. 3. Require explicit, informed human approval before modifying persistent memory or core decision policies. 4. Display an exact diff of every proposed persistent change before writing it. 5. Record the source, timestamp, authorizing user, and expiration date for approved policy entries. 6. Apply integrity controls so untrusted skills cannot directly modify agent identity, memory, or safety-policy files. 7. Provide a one-step rollback procedure that restores the prior policy. 8. Require renewed approval before promoting any action to a less restrictive autonomy tier. 9. Treat modifications to the autonomy ladder itself as protected administrative operations that cannot be authorized by the ladder. ]]>

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:19
Finding
Blanket Preauthorization of Consequential Agent Operations<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 19-42; enforcement guidance at lines 59-77 **Vulnerability Type**: Instruction hijacking that weakens per-action authorization requirements **Risk Level**: High ### Vulnerable Code ```markdown ### Tier 1 — Act immediately, report after Speed matters more than my input. Downside of acting wrong is low. Do it, then tell me what happened. - Fix monitoring alerts and restart crashed services - Answer routine customer questions (order status, password resets, FAQs) - Update internal documentation and daily notes - Rotate expired credentials and API keys - Run scheduled reports and health checks - Archive processed emails - Kill and restart stalled background processes ### Tier 2 — Act immediately, report with detail Higher stakes, but within your competence. I want enough detail to audit the decision after the fact. - Process refunds under $50 - Deploy bug fixes to production (must verify fix works) - Send follow-up emails to leads or existing customers - Triage and respond to support tickets - Make minor content or copy updates - Merge PRs that pass CI with no conflicts - Scale infrastructure up/down within budget guardrails ``` The skill also instructs heartbeat processing to execute these actions immediately: ```markdown ## Incident Response (every heartbeat) 1. Check for alerts or failures 2. Classify by autonomy tier 3. Tier 1: fix immediately, log to daily notes 4. Tier 2: fix immediately, send detailed report 5. Tier 3: draft recommendation, flag for review ``` ### Technical Analysis The skill substitutes a broad, skill-defined autonomy policy for contemporaneous authorization. It explicitly requires immediate execution for Tier 1 and Tier 2 operations, with notification occurring only after the operation. Several listed actions are consequential and may be difficult to reverse safely: - Rotating credentials or API keys can invalidate dependent services and lock out users. - Res ...[truncated 2356 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Change all financial, credential, production, external-communication, repository-write, process-control, and infrastructure operations to proposal-only behavior. 2. Require explicit, action-specific approval immediately before executing each consequential operation. 3. Present the exact target, parameters, expected effects, rollback plan, estimated cost, and affected systems in the approval request. 4. Enforce tool-level authorization rather than relying only on natural-language instructions. 5. Use least-privilege credentials and separate read-only inspection tools from write-capable execution tools. 6. Apply strict allowlists for services, repositories, communication recipients, deployment environments, and infrastructure resources. 7. Require dry runs and validated rollback plans for production or infrastructure changes. 8. Add independent validation for credential rotation, including dependency discovery and staged rollover. 9. Require human review for refunds and outbound messages, regardless of monetary value or recipient category. 10. Prevent untrusted alerts, emails, tickets, or repository content from determining autonomy classification without validation. 11. Disable recurring heartbeat execution of consequential actions; heartbeat checks should detect and propose remediation rather than execute it. 12. Preserve tamper-evident audit logs, but do not treat post-action reporting as a substitute for authorization. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (2)

Missing User Warnings

Medium
Confidence
92% confidence
Finding
This guidance explicitly authorizes autonomous actions such as restarting services, rotating credentials/API keys, and killing processes under Tier 1 with only after-the-fact reporting. Those are sensitive operational actions that can cause outages, break integrations, revoke legitimate access, or destroy forensic context if performed incorrectly, and the skill does not require safeguards like scope limits, verification steps, rollback procedures, or human review.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
Tier 2 permits autonomous production deployments, refunds, support responses, PR merges, and infrastructure scaling before human approval, which can directly affect customers, finances, and system integrity. Although it asks for detailed reporting afterward, post hoc auditability does not prevent harmful actions, and the skill lacks guardrails around data sensitivity, change windows, approval thresholds, testing rigor, or rollback authority.

Static analysis

No suspicious patterns detected.