2605.23330v1
This paper systematically investigates the security, privacy, and ethical risks, as well as the traceability challenges of OpenClaw, a locally executable AI agent system for natural language interaction and real-world task completion. While OpenClaw shows strong potential for personal assistance, office automation, cross-platform task management, and information integration, it also raises serious security, privacy, and ethical concerns. By analyzing its system architecture, core functionalities, deployment model, and representative application scenarios, this paper aims to reveal the risks that may arise when such a highly privileged agent is integrated into personal and organizational digital environments. We focus in particular on the challenges associated with persistent local storage, tool invocation, cross-context information aggregation, multi-user interaction, and the integration of plugins and external services. We argue that these issues constitute major barriers to the trustworthy deployment and widespread adoption of this technology. Finally, we summarize the open challenges in security defenses, privacy protection, ethical governance, and traceability in agent use, and call for joint efforts from researchers, developers, deployers, and regulators to build AI agent systems that are safer, more reliable, and more trustworthy.
Recent advances in large language models (LLMs) have enabled the emergence of autonomous AI agents capable of executing complex tasks with minimal human supervision [ 37 ] . Unlike traditional conversational systems, autonomous agents can go beyond response generation by invoking tools, accessing external resources, and maintaining state across interactions [ 36 , 2 ] . OpenClaw [ 39 ] exemplifies this shift as an open-source platform that connects LLMs with persistent sessions, browser interaction, messaging channels, and extensible skills. The OpenClaw agent is not limited to answering questions. It can and summarize information from external sources, send and receive messages across communication channels, open webpages and carry out browser-based tasks, maintain context across long-running sessions, and call specialized tools or skills to complete multi-step workflows. Compared with earlier LLM-based systems that mainly focused on constrained text generation or task-specific natural language processing, platforms such as OpenClaw move language models from passive text generation toward action-oriented digital assistance. This shift substantially broadens the potential applications of AI systems in personal assistance, workflow automation, communication, and productivity support, while also making OpenClaw a useful case study for understanding the broader development of agent-based AI platforms.
However, the capabilities of AI agents introduce new security, privacy, and ethical concerns. An agent that can read files, browse webpages, invoke tools, and send messages can also be manipulated into performing actions that ordinary conversational models could never directly carry out. For example, content controlled by an attacker may shape the agent’s interpretation of a task, and browser-based workflows may expose local files or authenticated user sessions; persistent transcripts and session state may retain sensitive information beyond a single interaction; and poorly designed or malicious skills may expand the system’s behavior in unsafe ways. In addition, once such platforms are deployed in real communication and workflow settings, their risks are no longer limited to incorrect text generation. They can affect privacy through unintended disclosure, affect security through unsafe actions on local or remote resources, and raise broader concerns trust, accountability, transparency, and the responsible use of AI-driven automation [ 40 , 11 , 22 , 20 ] . Therefore, a careful identification and structured analysis of the risks of platforms such as OpenClaw is necessary, both to improve risk awareness in real-world use and to support the design of more effective safeguards, ultimately enabling more trustworthy deployment of such systems.
In this paper, we examine OpenClaw, a recent autonomous AI agent designed for natural language interaction and real-world task execution, through the analytical framework shown in Fig. 1 . Specifically, we organize the discussion around four closely related dimensions: security, privacy, ethics, and traceability. This structure allows us to connect OpenClaw’s architectural design with the risks, impacts, and safeguards associated with execution-capable agent systems. Our aim is to draw greater attention to these challenges and to clarify directions for building safer and more trustworthy AI agents. The main contributions of this paper are as follows.
• We present a structured overview of OpenClaw as an autonomous AI agent platform, covering both the general agent capabilities of planning, memory, and tool use, and the specific design of its self-hosted gateway, embedded runtime, tool layer, skill mechanism, and persistent sessions. We also representative applications and show how these capabilities introduce new trust boundaries together with practical utility.
We present a structured overview of OpenClaw as an autonomous AI agent platform, covering both the general agent capabilities of planning, memory, and tool use, and the specific design of its self-hosted gateway, embedded runtime, tool layer, skill mechanism, and persistent sessions. We also representative applications and show how these capabilities introduce new trust boundaries together with practical utility.
• We analyze the principal security risks of OpenClaw across its gateway, runtime, tool layer, skill ecosystem, and persistent session state, including indirect prompt injection through external content ingestion, unsafe and over-privileged tool execution, browser risks from authenticated sessions, supply-chain vulnerabilities in third-party skills, and cross-session contagion enabled by persistent state and weak trust boundaries.
We analyze the principal security risks of OpenClaw across its gateway, runtime, tool layer, skill ecosystem, and persistent session state, including indirect prompt injection through external content ingestion, unsafe and over-privileged tool execution, browser risks from authenticated sessions, supply-chain vulnerabilities in third-party skills, and cross-session contagion enabled by persistent state and weak trust boundaries.
• We the major privacy issues raised by OpenClaw, including broadened privacy boundaries, persistent memory and workspace storage, over-broad access to tools and accounts, leakage across users and contexts, and additional privacy risks introduced by plugins, untrusted external content, and insufficient auditing.
We the major privacy issues raised by OpenClaw, including broadened privacy boundaries, persistent memory and workspace storage, over-broad access to tools and accounts, leakage across users and contexts, and additional privacy risks introduced by plugins, untrusted external content, and insufficient auditing.
• We analyze the broader ethical concerns associated with OpenClaw and similar agent systems, including accountability, transparency, trust, misuse, and the social consequences of increasingly capable AI assistants.
We analyze the broader ethical concerns associated with OpenClaw and similar agent systems, including accountability, transparency, trust, misuse, and the social consequences of increasingly capable AI assistants.
• We outline the open challenges and future research directions for improving the security, privacy, and trustworthiness of OpenClaw like autonomous agent platforms.
We outline the open challenges and future research directions for improving the security, privacy, and trustworthiness of OpenClaw like autonomous agent platforms.
2.1 Autonomous AI Agent Architecture
Autonomous AI agents are commonly built around a LLM that serves as the core reasoning engine. In contrast to traditional conversational systems, an autonomous agent is not limited to generating textual responses; it can plan, retain and retrieve contextual information, and interact with external tools or environments in order to achieve a user goal [ 47 , 36 , 32 ] .
A common conceptual view of LLM-powered agents is to consider three major capabilities that enable autonomous behavior: planning, memory, and tool use [ 45 ] . This decomposition has become a common conceptual framework for describing modern autonomous agents.
Planning refers to the agent’s ability to decompose a complex task into intermediate steps, select actions, and revise its strategy over multiple iterations. In many agent systems, this capability is implemented through a reasoning–action loop, where the model alternates between generating internal reasoning traces and taking actions in the external environment. Representative examples include ReAct-style trajectories, where the model iteratively produces Thought , Action , and Observation sequences [ 47 ] . More advanced agent architectures may also incorporate self-reflection or refinement mechanisms to improve task execution over time.
Memory allows the agent to retain and retrieve information beyond a single prompt window. Agent memory can be organized at different temporal scales. Short-term memory corresponds to information available within the current context window, while longer-term memory is often implemented through external storage mechanisms such as vector databases or persistent files [ 45 , 32 ] . Memory is particularly important for long-running tasks, contextual continuity, and experience accumulation across sessions.
Tool use refers to the ability of an agent to invoke external functions, APIs, or execution environments in order to obtain information or perform actions that are not directly achievable through language generation alone. Examples include web retrieval, code execution, access to proprietary data sources, and interactions with external software systems. Tool-augmented language models have been shown to significantly improve task-solving capabilities in realistic environments [ 36 , 47 ] .
Overall, planning, memory, and tool use transform an LLM from a passive text generator into an active task-oriented system. Meanwhile, the integration of these capabilities introduces multiple trust boundaries between the models, external resources, and persistent state, which motivates the security analysis presented in the following sections.
2.2 OpenClaw System Architecture
OpenClaw is an open-source autonomous AI agent platform built around a self-hosted gateway architecture [ 39 ] . Unlike a conventional chat system that mainly provides a stateless conversational interface, OpenClaw is designed as a long-running system that manages communication, session continuity, access control, and agent execution within a unified framework. According to its official documentation, the platform can connect to multiple communication channels, including WhatsApp, Telegram, Slack, Discord, Signal, iMessage, and WebChat, while also supporting local and remote control clients.
From a system perspective, OpenClaw can be understood through five closely related components: the gateway, the agent runtime, the tool layer, the skill mechanism, and persistent sessions with stored state. Beyond describing what each component does, it is also important to note that these components define where trust boundaries are created and how risks may later arise in practice.
The gateway serves as the central coordination point of the platform. It maintains channel connections, receives incoming events, routes requests into active sessions, and returns outputs to external interfaces. OpenClaw can also attach optional device nodes to the same gateway through WebSocket, with each node declaring its role and available capabilities. As a result, the gateway functions not only as a routing hub, but also as a control layer for pairing, authentication, access management, and other system-level decisions. This centralization is functionally useful, but it also makes the gateway a key trust boundary, since channel access, routing logic, and session association all affect how information and influence can enter and propagate through the system.
At the core of OpenClaw is an embedded runtime that combines language model generation with a structured reasoning and action process. Rather than treating the model as an isolated conversational endpoint, OpenClaw manages the full session lifecycle within its own runtime. This includes prompt construction, event handling, tool injection, streaming, and session updates. User inputs therefore do not simply produce text replies. They may also trigger tool calls, state changes, and external actions. Because the runtime is responsible for assembling context and mediating between model outputs and tool-enabled behavior, it is also a key point at which untrusted content, prior state, and retrieved information may shape later reasoning and execution.
OpenClaw includes a structured tool system that allows the agent to interact with external resources and digital environments. These tools may involve file access, browser operations, messaging functions, session utilities, automation support, and other platform-specific capabilities. Through this layer, model outputs can be translated into actions that affect files, services, devices, or web content. This is one of the main features that distinguishes OpenClaw from a standard chatbot. At the same time, it also makes the tool layer a major risk-amplification point, because errors in reasoning, unsafe context interpretation, or injected instructions may be converted into real actions on local or remote systems.
Another important part of the platform is its skill mechanism, which allows reusable capabilities to be added without modifying the core runtime. A skill typically includes a SKILL.md file that defines its intended use and may also contain supporting metadata or integration logic. This design improves extensibility and task adaptability, but it also broadens the operational surface of the platform and introduces additional points of risk. In particular, third-party skills expand the system’s trust boundary by introducing external logic and capabilities that may influence reasoning, permissions, and execution behavior.
OpenClaw also differs from ordinary prompt-response systems in its use of persistent sessions, transcripts, and task-related artifacts. Session keys support continuity across interactions, while stored state allows information from earlier exchanges to shape later behavior. This persistence is valuable for long-running and multi-step tasks, but it also increases the importance of state management, data handling, and access control. More importantly, it means that errors, injected content, or sensitive information may survive beyond a single interaction and continue to affect later behavior across time, channels, or users.
Taken together, these components make OpenClaw a stateful agent system that can participate directly in digital workflows rather than merely generate text. More importantly, they also define the main trust boundaries through which risk arises. The gateway concentrates cross-channel access and routing authority, the runtime constructs the context that shapes reasoning and action, the tool layer converts model outputs into real-world effects, the skill mechanism extends the platform through third-party logic, and persistent sessions allow information and influence to carry across interactions. For this reason, OpenClaw’s architecture is not only a functional design, but also the basis of its later security, privacy, and governance risk profile.
2.3 Representative Applications
Communication and information coordination assistant: The agent can access and operate across multiple messaging channels while maintaining persistent context over time. It can retrieve, aggregate, and process incoming messages from platforms such as Slack or WhatsApp, and assist users in managing ongoing communication based on prior interactions stored in the session. For example, a user could request “summarize my recent conversations and generate a to-do list.” The agent can then extract key points from messages, identify actionable items, and produce a structured to-do list. In more advanced scenarios, it may further execute actionable items from the list, such as scheduling meetings, sending follow-up messages, or creating tasks in external tools. As a result, OpenClaw can function as a unified coordination layer, reducing the need for users to manually track action items across conversations and applications.
Information aggregation and retrieval: The agent integrates data from multiple sources and produces structured outputs. Unlike conventional systems that rely on isolated queries, the agent can combine information from web resources, local files, prior conversations, and user preferences to support more context-aware results. For instance, a user may ask the agent to “recommend a refrigerator for a small apartment within a given budget.” The agent can retrieve product information from online sources, incorporate constraints such as space, budget, and brand preferences, and generate a structured comparison of suitable options.In more advanced cases, it may further cluster products by use scenarios, align recommendations with user profiles or demand patterns, and prepare procurement plans across multiple units or locations. This capability extends beyond individual query-based retrieval by enabling cross-source integration, constraint-aware filtering, and structured decision support within a continuous interaction context.
Technical task execution and iteration: persistent context and tool access enable the agent to carry out and refine technical tasks over time. For example, a user may ask the agent to “set up a comparative benchmark of object detection methods on my dataset.” The agent can retrieve relevant implementations, standardize input formats, and prepare a consistent preprocessing pipeline tailored to the dataset. It may then generate initial configurations and scripts to run multiple methods under comparable settings, and produce structured summaries of results. In more advanced cases, it may further refine implementations by reorganizing modules, adjusting configurations, or integrating improved components based on observed performance. By maintaining continuity across iterations and coordinating actions over multiple tools, OpenClaw supports the efficient execution and refinement of dataset-specific technical workflows without requiring repeated manual setup.
These examples illustrate the practical value of OpenClaw, but they also clarify why the platform deserves closer scrutiny. Because it is designed not only to respond, but also to act, store context, and interact with external systems, its deployment raises broader questions security, privacy, and trust. These issues are examined in the following sections.
3 OpenClaw vs. Security
OpenClaw’s security analysis requires a threat model that reflects both its architecture and its deployment conditions. Unlike conversational chatbots that operate only on text inputs and outputs, OpenClaw exposes a multi-layered attack surface through its gateway, runtime, tool layer, skill mechanism, and persistent session state. The severity of these risks depends on how the platform is deployed, for example whether it is used by a single user or shared by multiple users, whether it is reachable through external channels, whether third-party skills are enabled, and whether it is connected to sensitive accounts or authenticated browser sessions. This section therefore defines the threat model along three dimensions: adversary identity, adversary capability, and adversary objective.
3.1.1 Adversary Identities and Attack Entry Points.
Adversaries may initiate attacks from multiple layers of the OpenClaw architecture. At the channel layer, the adversary may be an external user who sends malicious inputs through messaging channels such as WhatsApp, Telegram, or Slack, or a participant in a public channel who posts content containing hidden instructions. At the content layer, the adversary may control third-party content such as webpages, documents, or emails that OpenClaw retrieves during task execution. At the skill layer, the adversary may be a developer who distributes malicious skills through ClawHub. At the device layer, the adversary may attempt to impersonate a legitimate device node and connect to the gateway through the WebSocket interface. In shared deployments, another user of the same system may also become a source of cross-session or cross-context influence.
3.1.2 Adversary Capabilities.
The adversary’s core capabilities include injecting adversarial instructions into content that enters the OpenClaw context window, achieving persistent influence by poisoning session state or retrieved memory, exploiting trust relationships between sessions, and expanding the platform’s attack surface by uploading skills that contain malicious logic. These capabilities depend on concrete preconditions. For example, indirect injection requires control of content that the agent is likely to ingest, skill-based attacks require a path for extension installation or activation, and session-contamination attacks require shared state, weak isolation, or later access to a context shaped by earlier malicious input.
3.1.3 Adversary Objectives.
The adversary’s objectives can be grouped into three broad categories: goal hijacking , that is, redirecting the agent’s execution flow so that it performs operations specified by the adversary rather than those intended by the user; data exfiltration , that is, extracting conversation history, local file contents, user credentials, or other sensitive contextual information; and destructive execution , that is, triggering harmful tool-mediated actions such as file deletion, unauthorized message sending, or malicious code execution.
Several threat modeling frameworks have provided systematic analyses of agent security. Narajala and Narayan [ 22 ] proposed a taxonomy of nine threat categories across five domains, with each category mapped to the STRIDE framework. Su et al. [ 40 ] further argued that the risks facing agent systems include fundamentally new threats arising from agent autonomy, persistent state, and the capacity for irreversible actions, beyond known vulnerabilities inherited from the underlying LLM. Crucially, the research community has already distinguished between threats to the agent and threats through the agent [ 11 , 40 ] . As autonomy increases, the agent shifts from a vulnerable attack target to a powerful attack vector, a transition clearly reflected in the architecture of OpenClaw. In practice, the relative importance of these risks varies across deployment settings, with stronger cross-user risks in shared instances, stronger remote-input risks in internet-facing deployments, and stronger exfiltration and destructive-execution risks when sensitive accounts or high-privilege tools are enabled. To make this threat model more concrete, Table 1 summarizes representative attack scenarios in OpenClaw and the architectural components they primarily target.
This section examines the principal security risks of OpenClaw, organized by the architectural component from which each risk primarily arises.
3.2.1 External Content Ingestion and Indirect Prompt Injection
OpenClaw is designed in a way that requires it to process large amounts of content from untrusted sources during normal workflows. In a typical use case, such as “summarize my recent Slack conversations and generate a to-do list,” the agent needs to retrieve content from multiple messaging channels, gather information from the web, read local documents, and reason over all of this content within a single context window. At the architectural level, this process passes through the gateway layer, the agent runtime, and the tool layer. This creates ideal conditions for indirect prompt injection.
The key difference between indirect prompt injection [ 12 ] and direct prompt injection is that the attacker does not need to interact with the agent directly. Instead, the attacker places malicious instructions in third-party content that the agent is likely to retrieve during task execution, such as web pages, shared documents, messages in communication channels, email attachments, or database entries. When the agent retrieves and processes this content during normal operation, the malicious instructions become part of the context and may alter the agent’s understanding of the task and its subsequent actions.
For OpenClaw, the risk of indirect injection is significantly amplified by three architectural features. First, OpenClaw processes untrusted input from multiple messaging channels and web sources at the same time. Second, OpenClaw has direct access to sensitive systems, including the file system, the shell, APIs, and authenticated web sessions. Third, the tool layer allows it to produce irreversible state changes, such as sending messages, executing code, and modifying or deleting files. The simultaneous presence of these three conditions violates the so-called Rule of Two in agent security, which states that an agent should satisfy at most two of the following three conditions: processing untrusted input, accessing sensitive systems, and producing external state changes [ 8 ] . OpenClaw satisfies all three by design.
Consider a concrete attack path. A user asks OpenClaw to summarize recent Slack conversations. An attacker posts an apparently normal message in a public Slack channel that the user belongs to, embedding a hidden instruction through Unicode control characters or visually indistinguishable formatting. When OpenClaw retrieves messages from that channel and constructs the context during runtime, the embedded instruction enters the reasoning process. This may cause the agent to forward the conversation summary to a channel chosen by the attacker, or to embed content from local files into an otherwise normal-looking , while the to-do list itself appears normal to the user.
Benchmark results confirm that this risk is real. InjecAgent [ 49 ] found that GPT-4 using the ReAct paradigm was affected by indirect injection in 24% of cases under the baseline setting and 47% under the stronger attack setting. AgentDojo [ 9 ] showed that even without adversarial pressure, state-of-the-art LLMs completed fewer than 66% of tasks correctly, while the most effective attack achieved a targeted success rate of 53.1%. Researchers from OpenAI, Anthropic, and Google DeepMind jointly evaluated 12 recently proposed defense mechanisms and found that the attack success rate exceeded 90% against most of them [ 23 ] . Evaluations of OpenClaw itself reflect the same reality. Chen et al. [ 3 ] reported that OpenClaw achieved only 57% prompt injection robustness in a trajectory-based security audit.
3.2.2 Tool Execution, Permission Control, and Browser Risks
The tool layer is the key component that turns OpenClaw from a conversational system into an action execution system. Through the tool layer, the output of the language model can be translated into actual operations on the file system, browser, messaging channels, shell, and external APIs. This means that any error in model reasoning, whether caused by prompt injection, misunderstanding of user intent, or the model’s own limitations, may directly turn into harmful operations on real digital assets.
The tool layer in OpenClaw is designed to give the agent broad execution authority. The file access tools can read and write files on the local file system, the messaging tools can send messages across multiple channels on behalf of the user, and the browser tools can access web pages and interact with authenticated web sessions. However, the current architecture lacks a fine-grained mechanism for permission separation across tools. A tool invoked to “read text files in a specified directory” may, at the architectural level, also have the ability to read system configuration files or access sensitive files in other directories. This permission model violates the principle of least privilege.
Many operations supported by the tool layer are irreversible. A sent message cannot be withdrawn, a deleted file may not be recoverable, and executed code may produce persistent side effects. The security audit by Chen et al. [ 3 ] found that the pass rate on the intent misunderstanding dimension was 0%, meaning that every test case involving ambiguity in user intent resulted in an unsafe outcome. The audit also identified an important cascade effect, where a small early misunderstanding of user intent is gradually amplified through later tool calls that change system state. The event documented by Deng et al. [ 10 ] , described as Instruction Amnesia via Context Compression, provides a concrete example. The context compression mechanism silently pushed out safety constraints from the system prompt, causing the agent to delete the user’s entire email inbox without any confirmation step.
The browser tool introduces additional risks. When the agent accesses a web page, it may inherit the user’s existing authenticated session, such as a logged-in email account, bank account, or enterprise intranet. Under indirect injection or misunderstanding of user intent, the agent may be steered into performing actions in these authenticated sessions that the user never intended. Similarly, the combination of browser tools and file tools may allow local assets to be uploaded to external services or embedded into outgoing messages. This cross-tool permission composition means that even if the permissions of each individual tool appear reasonable, coordinated calls across tools may still create an exposure surface beyond what was expected.
Deng et al. [ 10 ] systematically evaluated tools contributed by the OpenClaw community and found that 26% of them contained security vulnerabilities. Ying et al. [ 48 ] showed that OpenClaw had a defense success rate of only 17% in tool-calling scenarios when no human approval step was included, while adding human approval increased the rate to between 19% and 92%.
3.2.3 Skill Ecosystem and Supply Chain Risk
OpenClaw’s skill mechanism allows new capabilities to be added to the agent without modifying the core runtime. Skills are distributed as modules containing a SKILL.md definition file and can be shared through the ClawHub platform. ClawHub already hosts more than 5,700 third-party skills. This extensibility extends the platform’s security boundary from its own codebase to the entire skill ecosystem.
ClawHub’s open skill distribution model faces supply chain attack risks similar to those in software package ecosystems such as npm and PyPI. Existing records show that 335 malicious skills have appeared on ClawHub, often using professional documentation and harmless-looking names. A skill’s SKILL.md file defines its purpose, trigger conditions, and available operations. When a skill is loaded, its definition is incorporated into the agent’s context and influences the model’s reasoning process. A malicious skill can embed adversarial instructions in SKILL.md , use execution privileges to access local files or network resources and transmit sensitive information externally, or interact with other legitimate skills to expand the scope of malicious behavior. The MCP protocol that supports OpenClaw’s extensibility has itself become a security concern. Wang et al. [ 44 ] reported that attacks against tool-using agents based on MCP achieved a success rate as high as 72.8%.
The risk in the skill supply chain does not come only from external malicious actors. We observed that OpenClaw recently underwent a large architectural refactoring driven by AI-assisted programming, and that this refactoring caused a large number of existing skill interfaces to fail in batches. For users whose workflows depend on specific skills, a partially broken skill may silently return incomplete or incorrect results without reporting an error, and these results may then be used as the basis for later decisions in the agent’s reasoning and action loop, thereby triggering the cascade effect discussed above. This event also exposed the absence of versioned API contracts in the OpenClaw skill ecosystem. More than 5,700 third-party skill developers built their skills against the current interfaces, but the platform did not provide guarantees of backward compatibility, advance notice mechanisms for interface changes, or transition periods for version migration. Development in the style of “vibe coding” often emphasizes fast iteration and functional delivery, while systematic evaluation of downstream compatibility impact may be weakened. For a platform with a large third-party skill ecosystem, changes to core interfaces are not merely technical decisions but also alter a trust commitment made to thousands of downstream developers and users. This event shows that for agent platforms that depend heavily on third-party skill ecosystems, platform stability is itself a security property.
3.2.4 Multi-Session Contagion and Trust Boundaries
OpenClaw’s gateway layer manages multiple communication channels and sessions, and its persistent session mechanism allows information from earlier interactions to affect later behavior. The combination of these two architectural features means that security risk is no longer confined to a single session, but may spread across sessions and across users.
OpenClaw’s persistent session mechanism maintains contextual continuity across interactions through session keys. If adversarial content from one interaction is persisted, for example if a malicious instruction inserted through indirect injection is saved as a user preference or a task record, it may continue to influence the agent’s behavior in future interactions even after the original attack source no longer exists. Building on the attack scenario described in Section 3.2.1, if the state of a compromised session is persisted, adversarial influence may spread when the same user later initiates a follow-up interaction through another channel. If OpenClaw is then used to generate and send messages into channels involving other users, the contaminated output may create chained propagation across the platform.
Research confirms that such propagation is realistic. Gu et al. [ 13 ] showed that in a system containing up to one million agents, injecting a single adversarial image into the memory of one agent can eventually infect all agents through normal pairwise interactions. Cohen et al. [ 6 ] demonstrated a self-replicating AI worm that spread across interconnected generative AI applications by poisoning RAG databases, with each compromised client able to infect 20 new clients within one to three days. Lupinacci et al. [ 20 ] found that across 18 state-of-the-art LLMs, 100% could be compromised through inter-agent trust exploitation, executing malicious requests from peer agents that they would have rejected from human users. This reveals a key blind spot in current safety training, which is mainly designed for human-to-AI interactions rather than AI-to-AI interactions. Peigné-Lefebvre et al. [ 33 ] further identified a fundamental security-collaboration tradeoff: defenses intended to reduce adversarial propagation also reduce legitimate collaboration. This tradeoff is especially sharp in OpenClaw, because the platform’s value is built on seamless collaboration across channels and sessions, while the information flow required for that collaboration is exactly the carrier of adversarial propagation.
3.3 Defense Assessment
The trajectory-based security audit of OpenClaw by Chen et al. [ 3 ] provides integrated empirical support for the risks discussed above. The audit evaluated 34 representative test cases across six risk dimensions and found an overall pass rate of only 58.9%. The 100% pass rate in the hallucination and reliability dimension shows that the agent does not fabricate nonexistent tools or information. However, the 57% pass rate for prompt injection and the 0% pass rate for intent misunderstanding reveal a critical asymmetry: the system performs much worse at avoiding harmful actions than at avoiding fabricated facts. For pure text generation systems, hallucination is the main risk; for action-executing agents, incorrect actions and their irreversible consequences are the more serious threat.
The combined evidence from this section leads to the following assessment of the current defense posture.
First, the attack surface spans all architectural layers. From channel access at the gateway, to context construction in the runtime, to tool execution, to skill extension, and to persistent state management, every component introduces specific security risks that amplify one another.
Second, current defense mechanisms are seriously inadequate. The 17% native defense rate reported by Ying et al. [ 48 ] , the 58.9% overall audit pass rate, and the systematic bypassing of 12 defense methods with over 90% attack success rates [ 23 ] together indicate that no single defense mechanism, whether training-based, detection-based, or prompt-engineering-based, is sufficient to address these threats.
Third, non-adversarial risks are equally serious. The platform refactoring event and the instruction amnesia incident show that the platform’s own development practices and internal failures can lead to severe consequences even without a malicious attacker.
Fourth, architectural defenses appear to be the most promising direction. An emerging consensus in the research community [ 8 , 5 ] points toward combining privilege separation, sandboxed execution, and mandatory human-in-the-loop approval for irreversible actions. However, such strategies require deep architectural changes and continuous evaluation against adaptive attackers, and the security-collaboration tradeoff identified by Peigné-Lefebvre et al. [ 33 ] demands careful balance between protection and usability.
4 OpenClaw vs. privacy
In this section, we examine the privacy implications of OpenClaw as a self-hosted, execution-capable AI agent. Unlike centralized chatbot services, OpenClaw is designed to operate under the deployer’s control and may integrate persistent memory, local workspace files, external tools, messaging channels, and account credentials [ 29 ] . This architectural model alters the locus and character of privacy risk. Rather than being governed primarily by the centralized data practices of a single provider, privacy in OpenClaw is shaped to a large extent by deployment choices, including system configuration, enabled tools and plugins, accessible data sources, and the presence or absence of isolation and auditing controls [ 25 ] . Consequently, although OpenClaw may alleviate certain privacy concerns associated with provider-side data governance in cloud-hosted AI services, it also introduces new privacy risks related to local privilege concentration, persistent storage, cross-context aggregation, and plugin supply chains [ 25 , 21 ] . The following subsections therefore examine, in turn, OpenClaw’s privacy boundaries and architecture, the principal privacy risks arising from this design, and the safeguards required for privacy-preserving deployment and use.
4.1 Privacy boundaries and privacy architecture of OpenClaw
Privacy boundaries refer to the practical limits on what data an AI system can access, retain, combine, and disclose. In OpenClaw, privacy boundaries are broader than in a conventional chatbot because the agent may draw not only on the current prompt, but also on resources beyond the immediate conversation. For instance, a single task may involve information stored in memory files, data from a linked email or calendar account, or actions performed through tools with access to local files. Accordingly, the relevant privacy question is not limited to what the user explicitly requests, but extends to what information the agent can in fact traverse across memory, credentials, tools, sessions, and channels during task execution.
Consider a seemingly narrow request as figure 4 shown: a user asks OpenClaw only to to one email. On the surface, the task appears to require access only to that message. In practice, however, a broadly privileged deployment may also expose mailbox history, contacts, calendar entries, local files, stored preferences in memory, and context from other connected channels. The apparent scope of the task is therefore narrower than the system’s actual scope of accessible data. Privacy should thus be understood first as a boundary problem: in OpenClaw, the relevant boundary is defined less by the user’s immediate instruction than by the system’s effective scope of accessible context.
If privacy boundaries describe the scope of possible exposure, privacy architecture describes the system design that produces and governs that scope. In this paper, privacy architecture refers to the structural arrangement through which OpenClaw accesses, stores, isolates, and propagates private data.According to OpenClaw’s official documentation, this architecture is shaped by self-hosting, persistent memory, workspace-based storage, tool permissions, plugin mechanisms, session handling, and credential management [ 29 , 26 , 25 , 28 , 27 ] .
This architectural perspective is necessary because privacy in OpenClaw is not determined by hosting location alone. Official documentation notes, for example, that memory is stored as plain Markdown files in the workspace, that files on disk serve as the source of truth, and that agent directories, authentication profiles, and session isolation require careful separation and configuration. These are privacy-relevant architectural choices rather than incidental implementation details, since they determine where sensitive data reside, how long they persist, and how easily they may cross contexts. Therefore, privacy in OpenClaw should be understood as an architectural and governance issue rather than a simple consequence of local deployment, since its privacy posture depends on how storage, permissions, isolation, and persistence are organized in practice. This in turn gives rise to a distinct set of privacy risks.
4.2 Privacy risks in OpenClaw
OpenClaw introduces privacy risks because it can access, retain, combine, and reuse information beyond the immediate task context. The central privacy issue is not only whether the system can be attacked, but whether it can reach or preserve more personal data than users reasonably expect. In practice, these risks arise through persistent storage, over-broad data access, weak separation across users or contexts, plugin-mediated exposure, privacy disclosure triggered by untrusted input, and limited visibility into what data the agent has actually touched.
4.2.1 Persistent memory and workspace storage.
A major privacy risk in OpenClaw comes from the fact that information may remain on disk long after a single interaction has ended. Official documentation notes that memory can be written into workspace files such as daily notes and long-term memory files like MEMORY.md , which means that what the agent remembers is not only a temporary conversational context but a durable local record [ 26 , 25 ] .
The privacy problem here is accumulation. A user may separately ask OpenClaw to help schedule a doctor visit, remember food preferences for an event, and draft messages in a particular tone. None of these requests looks especially sensitive on its own. However, if the system stores all of them over time, it may gradually build a detailed record of the user’s routines, health-related activities, social habits, and communication style. The resulting profile may be far more revealing than any single interaction. Even without an attacker, long-term retention increases the chance that personal information will later appear in the wrong context, be exposed through local compromise, or be reused in ways the user did not expect.
4.2.2 Over-broad tool and account access.
OpenClaw is designed to complete real tasks, which often requires access to email, calendars, files, browsing, messaging, and other connected services. The privacy concern here is not unsafe execution as such, but unnecessary data reach. A narrow request can open a much broader data path than the user realizes [ 29 , 25 ] .
A concrete example is a user asking OpenClaw to to one email. From the user’s perspective, the task concerns a single message. In practice, a broadly privileged deployment may also expose the rest of the mailbox, records, past conversations with the same sender, calendar entries related to the topic, and even local files that help draft the . This matters even when the system does not explicitly quote private content back to the user. The surrounding metadata alone may reveal who the user communicates with, how often, at what times, and in what patterns. Over time, such access can support inference work routines, personal relationships, or periods of absence. The privacy risk is therefore created by excessive data reach rather than by the visible wording of the task.
4.2.3 Multi-user and cross-context interaction.
OpenClaw also creates privacy risks when one agent instance is used across multiple people or contexts. Official documentation notes that direct messages may the main session for continuity unless stronger isolation is configured, and also notes that session isolation does not by itself solve the broader host or operator trust problem [ 25 ] . This means that privacy boundaries in OpenClaw are often weaker than the boundaries users assume from the visible conversation alone.
A shared deployment makes this risk easy to see. Imagine a lab environment in which one student asks OpenClaw to remember that they will be away Friday afternoon for a medical appointment. Later, another student asks the same agent to summarize Friday availability or help schedule a meeting. If the deployment keeps context too broad, the first student’s private information may shape the second interaction even though the two users did not intend to context. The privacy harm here does not depend on an attacker. It arises from ordinary use when the separation between users, tasks, and contexts is weaker than the separation users reasonably expect.
4.2.4 Plugins, skills, and supply-chain trust.
Plugins and skills create a further privacy risk because they can enlarge what the system is able to see and process. Official plugin documentation states that native plugins run in the same process as the gateway and are not sandboxed [ 28 ] . In privacy terms, this means that installing a plugin is not just adding a new function. It may also expand the set of memory, session data, configuration files, and connected services that become reachable during execution.
A concrete example is a plugin advertised as helping with file organization or communication summaries. A user may install it because it appears useful and because the visible task seems routine. Once running, however, that plugin may be able to read stored memory, inspect session history, or access connected services while performing its helper function. Even if the plugin is not overtly malicious, an overly broad implementation may still collect or expose more data than the task requires. The privacy problem therefore lies not only in whether a plugin is intentionally malicious, but in whether users can realistically judge what data it will touch once it becomes part of the execution path. For this reason, plugin provenance, installation review, and restriction of extension paths are privacy controls as much as security controls [ 28 , 25 ] .
4.2.5 Untrusted input and privacy disclosure.
OpenClaw may also create privacy harm when external content changes what information the agent chooses to retrieve, combine, or reveal. The security section already discusses indirect prompt injection as an attack mechanism. From a privacy perspective, the key issue is different. Even if the host remains intact, untrusted content may still redirect otherwise legitimate access toward unintended disclosure of personal data [ 25 ] .
Consider a user who asks OpenClaw to summarize recent communications a project. During this process, the agent may read messages from Slack, email, attached files, and stored notes. If one retrieved source contains manipulative instructions, the privacy consequence may be that the agent includes unrelated personal details, pulls in information from another connected account, or sends a summary to a broader audience than the user expected. The task still looks ordinary, which makes the resulting privacy failure difficult for the user to notice or explain.
4.2.6 Transparency and privacy auditing.
A final privacy risk comes from limited visibility. OpenClaw gives operators more local control than a centralized service, but local control is not the same as practical transparency. Users and operators still need to know what data the agent accessed, which tools it invoked, what memory or files it updated, and whether any information left the local environment. If these steps are difficult to inspect, privacy exposure may remain hidden even when the system is self-hosted [ 24 , 25 ] .
A simple example is a user asking OpenClaw to summarize recent communications. The user may think this requires only reading a few messages. In practice, the agent may read several channels, retrieve stored preferences, consult a connect...
The full story
This article is one source in a clustered incident — the cluster page carries the summary, timeline and every other outlet covering it.
