Back to skill

Security audit

Intelligent Delegation

Security checks for vulnerabilities and agentic risk

Overview

The skill is mostly a disclosed delegation framework, but it asks agents to create persistent scheduled checks and its scoring tool can understate irreversible-task risk.

Review before installing. This skill does not show exfiltration or destructive code, but only use it if you are comfortable with agents modifying delegation procedures, keeping task/performance logs, and creating scheduled follow-up jobs. Do not let its scoring output automatically authorize irreversible, external, financial, deletion, or sensitive-data actions without separate human approval.

Vulnerability Patterns
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (1)

T09 · Insecure Skill Coding Practices

Error
Location
tools/score_task.py:36
Finding
Irreversible Tasks Are Assigned an Incorrectly Low Risk Score<![CDATA[ ## Vulnerability Details **File Location**: `tools/score_task.py:36-42`, `tools/score_task.py:54-61`, and `tools/score_task.py:86-109` **Vulnerability Type**: Incorrect security-sensitive risk calculation and approval-policy enforcement **Risk Level**: High ### Vulnerable Code ```python def score_to_autonomy(scores): risk = (scores["criticality"] + (6 - scores["reversibility"]) + scores["subjectivity"]) / 3 if risk >= 4: return "atomic" elif risk >= 2.5: return "bounded" return "open-ended" ``` ```python def needs_human_approval(scores): if scores["reversibility"] >= 4 and scores["criticality"] >= 3: return True, "Irreversible action with significant consequences" if scores["contextuality"] >= 4: return True, "Involves sensitive/private data" if scores["criticality"] >= 5: return True, "Critical task — failure would be severe" return False, None ``` ```python def calculate_recommendation(scores, description=""): tier, reason = select_agent_tier(scores, description) autonomy = score_to_autonomy(scores) monitoring = score_to_monitoring(scores) human_req, human_reason = needs_human_approval(scores) risk = ( scores["criticality"] * 0.3 + (6 - scores["reversibility"]) * 0.25 + scores["complexity"] * 0.2 + scores["contextuality"] * 0.15 + scores["subjectivity"] * 0.1 ) return { "agent_tier": tier, "agent_examples": AGENT_TIERS[tier]["examples"], "agent_reason": reason, "autonomy": autonomy, "monitoring": monitoring, "human_approval_required": human_req, "human_approval_reason": human_reason, "risk_level": "HIGH" if risk >= 4 else "MEDIUM" if risk >= 2.5 else "LOW", "risk_score": round(risk, 2), "scores": scores, } ``` ### Technical Analysis The documented scale defines `reversibility` as follows: - `1`: fully reversible - `5`: ...[truncated 3014 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Use the documented irreversibility score directly in all risk calculations: ```python def score_to_autonomy(scores): risk = ( scores["criticality"] + scores["reversibility"] + scores["subjectivity"] ) / 3 if risk >= 4: return "atomic" if risk >= 2.5: return "bounded" return "open-ended" ``` ```python risk = ( scores["criticality"] * 0.3 + scores["reversibility"] * 0.25 + scores["complexity"] * 0.2 + scores["contextuality"] * 0.15 + scores["subjectivity"] * 0.1 ) ``` 2. Align human-approval enforcement with the documented policy: ```python def needs_human_approval(scores): if scores["reversibility"] >= 4: return True, "Action is difficult or impossible to reverse" if scores["criticality"] >= 4: return True, "High-criticality task" if scores["contextuality"] >= 4: return True, "Involves sensitive/private data" return False, None ``` 3. Treat approval checks as independent hard safety gates rather than relying only on a weighted aggregate score. 4. Add parameterized tests proving monotonic behavior: - Increasing irreversibility must never reduce risk. - Scores of `4` or `5` for irreversibility must require approval. - Irreversible tasks must not receive `open-ended` autonomy. - Fully reversible tasks must not receive a larger reversibility-risk contribution than irreversible tasks. 5. Add regression tests comparing the implementation against the policy in `SKILL.md`. 6. Consider renaming the field from `reversibility` to `irreversibility` so that higher values and higher risk have the same semantic direction. ]]>
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (5)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The code only covers the task scoring component of the declared framework. It does perform multi-axis task scoring consistent with the description, but there is no implementation of task tracking, logging of sub-agent performance, automated verification, fallback-chain orchestration, or any broader multi-phase delegation workflow. Therefore the description materially overstates the implemented functionality and the primary behavior is narrower than claimed.

Lp3

Medium
Category
MCP Least Privilege
Confidence
70% confidence
Finding
Without declared permissions the skill's intent is opaque and cannot be validated.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
When AI agents delegate tasks to sub-agents, common failure modes include:
- **Lost tasks** — background work completes silently, no follow-up
- **Blind trust** — passing through sub-agent output without verification
- **No learning** — repeating the same delegation mistakes
- **Brittle failure** — one error kills the whole workflow
- **Gut-feel routing** — no systematic way to choose which agent handles what
Confidence
75% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The skill instructs users to create one-shot cron jobs for follow-up checks but provides no safety guidance on cron persistence, command validation, duplicate scheduling, privilege boundaries, or cleanup. In agent environments, automated scheduling can create unintended recurring execution, orphaned jobs, or execution of unsafe commands, which increases operational and security risk.

Internal Network Request

Medium
Category
Server-Side Request Forgery
Content
def check_port_alive(port=0, **_):
    try:
        req = urllib.request.Request(f"http://127.0.0.1:{int(port)}/", method="HEAD")
        with urllib.request.urlopen(req, timeout=3) as resp:
            return True, f"✅ Port {port} responding (status {resp.status})"
    except urllib.error.HTTPError as e:
Confidence
70% confidence
Finding
Code issues a request to a loopback, link-local, or private-range host. This can reach internal services not meant to be exposed and is a common SSRF pivot.

Static analysis

No suspicious patterns detected.