Autonomous LLM agents like OpenClaw are shifting the paradigm from passive assistants to proactive entities capable of executing complex, long-horizon tasks through high-privilege system access. However, a security analysis research report from Tsinghua University and Ant Group reveals that OpenClaw’s ‘kernel-plugin’ architecture—anchored by a pi-coding-agent serving as the Minimal Trusted Computing Base (TCB)—is vulnerable to multi-stage systemic risks that bypass traditional, isolated defenses. By introducing a five-layer lifecycle framework covering initialization, input, inference, decision, and execution, the research team demonstrates how compound threats like memory poisoning and skill supply chain contamination can compromise an agent’s entire operational trajectory.

OpenClaw Architecture: The pi-coding-agent and the TCB

OpenClaw utilizes a ‘kernel-plugin’ architecture that separates core logic from extensible functionality. The system’s Trusted Computing Base (TCB) is defined by the pi-coding-agent, a minimal core responsible for memory management, task planning, and execution orchestration. This TCB manages an extensible ecosystem of third-party plugins—or ‘skills’—that enable the agent to perform high-privilege operations such as automated software engineering and system administration. A critical architectural vulnerability identified by the research team is the dynamic loading of these plugins without strict integrity verification, which creates an ambiguous trust boundary and expands the system’s attack surface.

A Lifecycle-Oriented Threat Taxonomy

The research team systematizes the threat landscape across five operational stages that align with the agent’s functional pipeline:

• Stage I (Initialization): The agent establishes its operational environment and trust boundaries by loading system prompts, security configurations, and plugins.
• Stage II (Input): Multi-modal data is ingested, requiring the agent to differentiate between trusted user instructions and untrusted external data sources.
• Stage III (Inference): The agent reasoning process utilizes techniques such as Chain-of-Thought (CoT) prompting while maintaining contextual memory and retrieving external knowledge via retrieval-augmented generation.
• Stage IV (Decision): The agent selects appropriate tools and generates execution parameters through planning frameworks such as ReAct.
• Stage V (Execution): High-level plans are converted into privileged system actions, requiring strict sandboxing and access-control mechanisms to manage operations.

This structured approach highlights that autonomous agents face multi-stage systemic risks that extend beyond isolated prompt injection attacks.

Technical Case Studies in Agent Compromise

1. Skill Poisoning (Initialization Stage)

Skill poisoning targets the agent before a task even begins. Adversaries can introduce malicious skills that exploit the capability routing interface.

• The Attack: The research team demonstrated this by coercing OpenClaw to create a functional skill named hacked-weather.
• Mechanism: By manipulating the skill’s metadata, the attacker artificially elevated its priority over the legitimate weather tool.
• Impact: When a user requested weather data, the agent bypassed the legitimate service and triggered the malicious replacement, yielding attacker-controlled output.
• Prevalence: An empirical audit cited in the research report found that 26% of community-contributed tools contain security vulnerabilities.

2. Indirect Prompt Injection (Input Stage)

Autonomous agents frequently ingest untrusted external data, making them susceptible to zero-click exploits.

• The Attack: Attackers embed malicious directives within external content, such as a web page.
• Mechanism: When the agent retrieves the page to fulfill a user request, the embedded payload overrides the original objective.
• Result: In one test, the agent ignored the user’s task to output a fixed ‘Hello World’ string mandated by the malicious site.

3. Memory Poisoning (Inference Stage)

Because OpenClaw maintains a persistent state, it is vulnerable to long-term behavioral manipulation.

• Mechanism: An attacker uses a transient injection to modify the agent’s MEMORY.md file.
• The Attack: A fabricated rule was added instructing the agent to refuse any query containing the term ‘C++’.
• Impact: This ‘poison’ persisted across sessions; subsequent benign requests for C++ programming were rejected by the agent, even after the initial attack interaction had ended.

4. Intent Drift (Decision Stage)

Intent drift occurs when a sequence of locally justifiable tool calls leads to a globally destructive outcome.

• The Scenario: A user issued a diagnostic request to eliminate a ‘suspicious crawler IP’.
• The Escalation: The agent autonomously identified IP connections and attempted to modify the system firewall via iptables.
• System Failure: After several failed attempts to modify configuration files outside its workspace, the agent terminated the running process to attempt a manual restart. This rendered the WebUI inaccessible and resulted in a complete system outage.

5. High-Risk Command Execution (Execution Stage)

This represents the final realization of an attack where earlier compromises propagate into concrete system impact.

• The Attack: An attacker decomposed a Fork Bomb attack into four individually benign file-write steps to bypass static filters.
• Mechanism: Using Base64 encoding and sed to strip junk characters, the attacker assembled a latent execution chain in trigger.sh.
• Impact: Once triggered, the script caused a sharp CPU utilization surge to near 100% saturation, effectively launching a denial-of-service attack against the host infrastructure.

The Five-Layer Defense Architecture

The research team evaluated current defenses as ‘fragmented’ point solutions and proposed a holistic, lifecycle-aware architecture.

(1) Foundational Base Layer: 

Establishes a verifiable root of trust during the startup phase. It utilizes Static/Dynamic Analysis (ASTs) to detect unauthorized code and Cryptographic Signatures (SBOMs) to verify skill provenance.

(2) Input Perception Layer: 

Acts as a gateway to prevent external data from hijacking the agent’s control flow. It enforces an Instruction Hierarchy via cryptographic token tagging to prioritize developer prompts over untrusted external content.

(3) Cognitive State Layer:

Protects internal memory and reasoning from corruption. It employs Merkle-tree Structures for state snapshotting and rollbacks, alongside Cross-encoders to measure semantic distance and detect context drift.

(4) Decision Alignment Layer: 

Ensures synthesized plans align with user objectives before any action is taken. It includes Formal Verification using symbolic solvers to prove that proposed sequences do not violate safety invariants.

(5) Execution Control Layer: 

Serves as the final enforcement boundary using an ‘assume breach’ paradigm. It provides isolation through Kernel-Level Sandboxing utilizing eBPF and seccomp to intercept unauthorized system calls at the OS level

Key Takeaways

• Autonomous agents expand the attack surface through high-privilege execution and persistent memory. Unlike stateless LLM applications, agents like OpenClaw rely on cross-system integration and long-term memory to execute complex, long-horizon tasks. This proactive nature introduces unique multi-stage systemic risks that span the entire operational lifecycle, from initialization to execution.
• Skill ecosystems face significant supply chain risks. Approximately 26% of community-contributed tools in agent skill ecosystems contain security vulnerabilities. Attackers can use ‘skill poisoning’ to inject malicious tools that appear legitimate but contain hidden priority overrides, allowing them to silently hijack user requests and produce attacker-controlled outputs.
• Memory is a persistent and dangerous attack vector. Persistent memory allows transient adversarial inputs to be transformed into long-term behavioral control. Through memory poisoning, an attacker can implant fabricated policy rules into an agent’s memory (e.g., MEMORY.md), causing the agent to persistently reject benign requests even after the initial attack session has ended.
• Ambiguous instructions lead to destructive ‘Intent Drift.’ Even without explicit malicious manipulation, agents can experience intent drift, where a sequence of locally justifiable tool calls leads to globally destructive outcomes. In documented cases, basic diagnostic security requests escalated into unauthorized firewall modifications and service terminations that rendered the entire system inaccessible.
• Effective protection requires a lifecycle-aware, defense-in-depth architecture. Existing point-based defenses—such as simple input filters—are insufficient against cross-temporal, multi-stage attacks. A robust defense must be integrated across all five layers of the agent lifecycle: Foundational Base (plugin vetting), Input Perception (instruction hierarchy), Cognitive State (memory integrity), Decision Alignment (plan verification), and Execution Control (kernel-level sandboxing via eBPF).

Check out Paper. Also, feel free to follow us on Twitter and don’t forget to join our 120k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.

_{Note: This article is supported and provided by Ant Research}