Back to skill

Security audit

Multi-Agent Coordinator

Security checks for vulnerabilities and agentic risk

Overview

This skill is a powerful multi-agent coordinator that is not clearly malicious, but it needs review because worker sessions can make broad changes and persist task data without strong permission boundaries.

Review this skill before installing in any sensitive workspace. Use it only in a sandbox or repository where spawned workers may safely read and edit files, avoid putting secrets in tasks, inspect generated prompts before running sessions_spawn, and delete .openclaw/scratchpad when the run is finished if it may contain private data.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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 (2)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/worker.py:32
Finding

Workers Have Unrestricted Filesystem and Shell Access Without Enforced Role-Based Permissions

Content
View full analysis
str: """Read a file""" self.tool_uses += 1 try: file_path = Path(path) if not file_path.exists(): return f"Error: File not found: {path}" content = file_path.read_text(encoding="utf-8") lines = content.split("\n") if len(lines) > limit: content = "\n".join(lines[:limit]) + f"\n... ({len(lines) - limit} more lines)" self.results.append({"tool": "read", "path": path, "status": "success"}) return content except Exception as e: return f"Error reading {path}: {e}" ``` ```python def write(self, path: str, content: str) -> str: """Write a file""" self.tool_uses += 1 try: file_path = Path(path) file_path.parent.mkdir(parents=True, exist_ok=True) file_path.write_text(content, encoding="utf-8") self.results.append({"tool": "write", "path": path, "status": "success"}) return f"Written: {path}" except Exception as e: return f"Error writing {path}: {e}" ``` ```python def edit(self, path: str, old: str, new: str) -> str: """Edit a file (find and replace)""" self.tool_uses += 1 try: file_path = Path(path) if not file_path.exists(): return f"Error: File not found: ...[truncated 4078 chars]
Remediation
View remediation

T01 · Skill Instruction Hijacking

Error
Location
`. 3. Place arbitrary instruction text in `<result>` and use any task ID because no equality check is enforced. 4. Mark the worker completed and include it in specification generation. 5. Pass the generated specification to a privileged implementation worker. ### Impact Assessment The direct impact is corruption of workflow state and implementation specifications. When the poisoned specification reaches a privileged implementer, the practical impact expands to the permissions available to that worker, pot ...[truncated 784 chars]:399
Finding

Untrusted Worker Results Are Reused as Executable Instructions in Privileged Implementation Prompts

Content
View full analysis
bool: """Check if worker has completed and extract result""" if not worker.session_key: return False # Get session history history = self.openclaw.get_session_history(worker.session_key, limit=20) # Look for task-notification in the history for msg in history: content = msg.get('content', '') if isinstance(msg, dict) else str(msg) if '' in content: notification = self.protocol.parse_notification(content) if notification: worker.status = notification.get('status', 'completed') worker.result = notification.get('result', '') worker.completed_at = datetime.now() # Save notification self.scratchpad.write( f"notification-{worker.id}.xml", content ) print(f"[Coordinator] ✓ Worker {worker.id} completed: {notification.get('summary', '')}") return True ``` Worker-controlled results are copied verbatim into the synthesized specification: ```python findings = [] for worker in workers: if worker.result: findings.append(f"[{worker.role} - {worker.id}]\n{worker.result}") print(f"Synthesizing findings from {len(findings)} workers...") # Create implementation spec spec_lines = [ "# Implementation Specification", "", f"Generated at: {datetime.now().isofor ...[truncated 5319 chars]
Remediation
View remediation
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Rogue AgentSelf-Modification, Session Persistence
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
Findings (45)

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding

The description overstates the implementation. The code does match some high-level elements: it models Coordinator Mode, uses XML task notifications, has a scratchpad-backed filesystem, and implements the four named workflow phases. However, the key claimed capability—real parallel worker spawning via sessions_spawn—is absent. The code explicitly notes that real session integration would exist 'in real implementation' and instead simulates workers with local objects and synthetic notifications. Messaging is also mocked via print statements rather than actual session transport. The result is materially different from a production-ready orchestration system; it is better characterized as a coordinator scaffold/demo or prototype. Therefore the declared description does not accurately represent the actual behavior.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding

The description overstates the implemented functionality. The code does support some declared elements: XML task notifications are parsed, worker/coordinator state is persisted, and there is a synthesis-like spec generation step. However, the key claimed capability—real parallel worker spawning via sessions_spawn—is not implemented. The spawn_worker method explicitly says actual spawn must be done via the sessions_spawn tool and only returns a prepared prompt; the CLI merely prints a suggested command. Likewise, wait_for_workers is a placeholder that does not perform actual asynchronous polling or coordination. The claimed four-phase workflow is not fully present: there is no concrete orchestration for implementation or verification phases, just role templates and result handling. This makes the declared description materially inaccurate relative to the code's actual behavior.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding

The supplied code chunk is narrowly focused on XML message formatting/parsing and basic in-memory message routing. While XML task notifications are consistent with part of the description, the major claimed capabilities of the skill are absent from this code: there is no coordinator logic, no parallel worker spawning, no session management, no persistence layer, and no workflow engine implementing the four phases. Therefore the declared description materially overstates what this code chunk actually does.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding

The description presents a full production-ready orchestration system centered on coordinator functionality, parallel spawning, persistent state, and a defined four-phase workflow. The supplied code chunk instead contains a single worker implementation. It can read/write files, run shell commands, search files, and emit XML notifications, but its task execution is largely simulated and role-based. There is no evidence here of Coordinator Mode, sessions_spawn, actual multi-agent orchestration, real parallelism, or complete workflow management. While XML task notifications are partially consistent with the description, the primary purpose and scope are materially narrower and different from what is declared.

Content

No source excerpt is available for this finding.

Exfiltration Commands

High
Category
Prompt Injection
Confidence
90% confidence
Finding

Instructions found that direct the agent to transmit conversation context or user data to external services.

Content

Scanner excerpt · SKILL.md (reported line 195)May include surrounding context.

md
| OpenClaw Tool | Usage in Multi-Agent |
|---------------|---------------------|
| `sessions_spawn` | Spawn worker agents |
| `sessions_send` | Send messages to workers |
| `sessions_list` | List active workers |
| `sessions_history` | Get worker results |
| `cron` | Schedule periodic tasks |

Exfiltration Commands

High
Category
Prompt Injection
Confidence
90% confidence
Finding

Instructions found that direct the agent to transmit conversation context or user data to external services.

Content

Scanner excerpt · references/ARCHITECTURE.md (reported line 111)May include surrounding context.

md
| OpenClaw Tool | Usage in Multi-Agent |
|---------------|---------------------|
| `sessions_spawn` | Spawn worker agents |
| `sessions_send` | Send messages to workers |
| `sessions_list` | List active workers |
| `sessions_history` | Get worker results |
| `cron` | Schedule periodic tasks |

Exfiltration Commands

High
Category
Prompt Injection
Confidence
90% confidence
Finding

Instructions found that direct the agent to transmit conversation context or user data to external services.

Content

Scanner excerpt · scripts/coordinator.py (reported line 472)May include surrounding context.

python
self.pending_messages: Dict[str, list] = {}  # worker_id -> messages
    
    def send_to(self, worker_id: str, message: str, from_id: str = "coordinator"):
        """Send message to specific worker"""
        if worker_id not in self.pending_messages:
            self.pending_messages[worker_id] = []

Exfiltration Commands

High
Category
Prompt Injection
Confidence
90% confidence
Finding

Instructions found that direct the agent to transmit conversation context or user data to external services.

Content

Scanner excerpt · scripts/protocol.py (reported line 109)May include surrounding context.

python
self.pending_messages: Dict[str, list] = {}  # worker_id -> messages
    
    def send_to(self, worker_id: str, message: str, from_id: str = "coordinator"):
        """Send message to specific worker"""
        if worker_id not in self.pending_messages:
            self.pending_messages[worker_id] = []

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
99% confidence
Finding

This is a true tool-parameter abuse issue because the bash tool accepts arbitrary command text and executes it with shell=True. In a multi-agent orchestration skill where worker tasks and inputs may be influenced by other agents or untrusted content, this creates a high-risk command injection and arbitrary code execution capability that can modify files, exfiltrate data, or run destructive system commands.

Content

Scanner excerpt · scripts/worker.py (reported line 120)May include surrounding context.

python
self.tool_uses += 1
        import subprocess
        try:
            result = subprocess.run(
                command,
                shell=True,
                capture_output=True,

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

The document explicitly promotes persistent storage of worker prompts, states, and results under predictable on-disk paths, but does not warn that these files may contain sensitive task content, code, or derived secrets. In a multi-agent orchestration skill, this increases the chance of unintended retention, later disclosure, or reuse of sensitive data by other tools, users, or sessions.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The quick-start instructions tell users to spawn real worker sessions and pass task content via files and shell interpolation, but provide no warning that task data will be written to disk and executed through external session tooling. In this skill context, that omission is more dangerous because the whole feature is production-oriented multi-agent execution, so users are encouraged to operationalize it on real tasks where sensitive content may be exposed or retained.

Content

No source excerpt is available for this finding.

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
86% confidence
Finding

The skill advertises and documents shell execution, file writes, persistent state, and session-oriented orchestration, but it does not declare any explicit tool scope such as permissions or allowed-tools. That creates a trust and review gap: operators cannot easily tell what capabilities the skill expects, and an agent may invoke broader tools than users anticipated.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

Large portions of the skill instructions are written in Chinese, including operational steps and behavior descriptions, while the document does not offer the user an opt-in language selection or explain that the skill is intended only for a Chinese-language audience. Under SQP-3, forcing a specific language or locale without user choice is a policy violation.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The skill explicitly instructs creation of persistent files under .openclaw/scratchpad and ongoing state storage, but it does not warn users that running it will modify the workspace and leave artifacts behind. In an agent setting, silent file creation and persistent state can surprise users, overwrite expected state, leak project information into shared scratch directories, or interfere with later runs.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
90% confidence
Finding

The document explicitly states workers have full file, shell, and web access while also describing shared scratchpad writes, but it does not pair that with a strong warning about the operational risk. In a multi-agent orchestration skill, this is dangerous because users may enable or deploy it without understanding that spawned workers can perform broad system actions and persist shared state, increasing the blast radius of prompt injection or task misuse.

Content

No source excerpt is available for this finding.

Session Persistence

Medium
Category
Rogue Agent
Confidence
80% 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.

Content

Scanner excerpt · references/ARCHITECTURE.md (reported line 114)May include surrounding context.

md
| `sessions_send` | Send messages to workers |
| `sessions_list` | List active workers |
| `sessions_history` | Get worker results |
| `cron` | Schedule periodic tasks |
| `message` | Notify user of completion |

### Future: Agent Teams

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

The manifest description says the skill already 'implements Coordinator Mode with real parallel worker spawning via sessions_spawn'. However, this document's current-state section says Phase 1 is the current implementation and includes 'Simulated worker execution', while 'Real Worker Spawning' is deferred to Phase 2. That is an active contradiction between documentation and the stated implemented capability.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

Medium
Category
Not specified by scanner
Confidence
90% confidence
Finding

The description advertises state persistence, but the coordinator's authoritative workflow state is stored only in process memory in self.workers and self.phase. While some specs and notifications are written to the scratchpad, there is no corresponding load/recovery path to persist and restore coordinator state across executions.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

Medium
Category
Not specified by scanner
Confidence
98% confidence
Finding

The manifest describes a production-ready orchestration system with real parallel worker spawning via sessions_spawn, but spawn_worker only creates local Worker objects and send_to_worker explicitly notes that a real implementation would use sessions_send. This means the implemented behavior is a simulation of orchestration rather than the claimed real session-based multi-agent execution.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
90% confidence
Finding

The coordinator writes worker task specifications, context, and later notifications/results to a predictable local scratchpad directory without any consent flow, retention policy, or sensitivity filtering. In an agent system, tasks and results may contain secrets, proprietary code details, or user data, so silent persistence increases the risk of local information disclosure to other users, processes, backups, or logs.

Content

No source excerpt is available for this finding.

File System Enumeration

Medium
Category
Data Exfiltration
Confidence
80% confidence
Finding

Code scans file system directories looking for sensitive files. This could be reconnaissance for credential theft.

Content

Scanner excerpt · scripts/coordinator.py (reported line 274)May include surrounding context.

python
if not research_prompts:
            # Default research angles
            research_prompts = [
                f"Explore codebase structure related to: {task}. Find key files and their relationships.",
                f"Analyze current implementation for: {task}. Identify patterns and potential issues.",
                f"Research dependencies and requirements for: {task}. What needs to change?"
            ]

File System Enumeration

Medium
Category
Data Exfiltration
Confidence
80% confidence
Finding

Code scans file system directories looking for sensitive files. This could be reconnaissance for credential theft.

Content

Scanner excerpt · scripts/coordinator_phase2.py (reported line 487)May include surrounding context.

python
if not research_prompts:
            # Default research angles
            research_prompts = [
                f"Explore codebase structure related to: {task}. Find key files and their relationships.",
                f"Analyze current implementation for: {task}. Identify patterns and potential issues.",
                f"Research dependencies and requirements for: {task}. What needs to change?"
            ]

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The coordinator writes worker task specifications, session metadata, and later results/notifications to local files under .openclaw, but provides no disclosure, consent prompt, retention control, or redaction. If tasks or results contain sensitive source code, secrets, or user data, this creates a quiet persistence channel and expands exposure beyond runtime memory.

Content

No source excerpt is available for this finding.

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
88% confidence
Finding

This subprocess invocation launches the external openclaw sessions spawn command using task content derived from higher-level input, which can create autonomous worker sessions that perform broad tool-assisted actions. Although subprocess.run is used with an argument list rather than a shell string, the real risk is delegated execution: untrusted task content is handed to another agent/process with no policy validation, approval gate, or scope restriction.

Content

Scanner excerpt · scripts/coordinator_phase2.py (reported line 113)May include surrounding context.

python
]
        
        try:
            result = subprocess.run(
                cmd,
                capture_output=True,
                text=True,

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
90% confidence
Finding

The script can launch external openclaw worker sessions that may use powerful tools such as bash, edit, and web access, yet it does so without an explicit user-facing warning or approval checkpoint. In a multi-agent orchestration skill, this materially increases risk because a single request can fan out into multiple autonomous actions across the environment.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.