Summary
OpenClaw before 2026.3.28 contains an agentic consent bypass issue where LLM agents can silently disable execution approval using the config.patch parameter.
Remote attackers who can influence or invoke an agent with crafted configuration patches may bypass security controls and trigger unauthorized operations without explicit user consent.
Affected context
This vulnerability affects OpenClaw deployments that rely on agent execution approval or consent gates to ensure that potentially sensitive or irreversible actions are explicitly confirmed by a human.
The weakness appears when agents are allowed to modify their own or other agents' configuration through config.patch (or similar configuration mutation) without strong authorization and consistency checks.
In such environments, a remotely triggered or integrated agent can adjust approval-related settings at runtime, effectively downgrading or removing the requirement for user confirmation prior to executing protected operations.
Exploit preconditions
- Attack surface: Any interface (API, workflow orchestration, plugin integration, or external connector) that accepts or constructs
config.patchparameters for OpenClaw agents. - Required access: Ability to send or influence agent tasks, prompts, or configurations that include a
config.patchpayload, either directly via an API or indirectly via an integrated system. - Trigger point: Submission of a configuration patch that alters execution approval settings, which the system applies without enforcing separate, higher-privilege authorization.
- Why exploitation is possible: Changes to consent or approval-related configuration are not adequately protected by independent authorization or policy checks, allowing the same channel that requests work from an agent to also weaken or disable the safety controls governing that work.
Why this happens
The underlying bug aligns with CWE-862: Missing Authorization, where security-critical operations proceed without verifying that the actor is permitted to perform them.
In this case, consent and execution approval behave like an authorization layer for high-risk actions, yet the configuration path (config.patch) that governs these safety controls is treated as a regular runtime parameter.
Because the system does not enforce a stronger, separate permission check or policy boundary around modifications to approval settings, an agent (or caller controlling the agent) can silently flip those settings off.
Abstractly, this represents an insecure pattern where:
- Safety or authorization configuration is mutable at runtime,
- The same untrusted input channel is used both to request actions and to alter the guardrails for those actions, and
- No higher-privilege or out-of-band consent is required to modify those guardrails.
Potential impact
- Agents may execute high-risk operations (file access, network calls, data exfiltration, system changes) without human review or consent.
- Security and compliance workflows that depend on explicit approvals can be silently bypassed.
- Unauthorized modification or deletion of data handled by OpenClaw-integrated agents can occur.
- Chained actions through connected tools, plugins, or APIs may amplify impact, leading to broader system or account compromise.
- Audit trails may misleadingly suggest that operations were performed under normal policy, obscuring the loss of consent enforcement.
General mitigation guidance
Effective mitigation revolves around treating consent and approval controls as privileged configuration and separating them from routine agent runtime parameters.
Recommended patterns include:
- Separate privilege for safety controls: Require a distinct, higher-privilege channel or role to modify approval/consent-related configuration (e.g., admin-only or out-of-band UI), disallowing regular tasks or prompts from changing these settings.
- Immutable consent at runtime: Treat execution approval requirements as immutable for the lifetime of an agent session or task, so they cannot be altered by
config.patchor similar runtime updates. - Configuration whitelisting: Restrict what fields
config.patch(or equivalent mechanisms) may touch, explicitly excluding safety, auth, and policy-related flags from being modified via untrusted input. - Policy-based enforcement: Introduce a policy layer that enforces minimum safety requirements (such as mandatory approvals for certain operation types) regardless of per-agent configuration.
- Least-privilege tools and connectors: Ensure downstream tools and integrations invoked by agents are themselves scoped to the minimum capabilities needed, reducing the damage if consent checks degrade.
How teams detect issues like this
Detection approaches should focus on identifying unauthorized changes to safety configuration and patterns where untrusted inputs reach consent controls:
- Static analysis and configuration linting:
- Flag uses of generic configuration patching (e.g.,
config.patch, dynamic merges) that can affect safety or auth-related fields. - Detect code paths where consent/approval flags are derived from request parameters, agent prompts, or other low-trust sources.
- Enforce architectural rules such as "approval_required must not be settable from user-controlled input."
- Code review signals:
- Pay attention to any code that:
- Adjusts approval/consent flags,
- Mutates agent configuration mid-execution, or
- Accepts broad JSON/YAML patches without field-level validation.
- Review that all such changes are guarded by explicit authorization checks or restricted to administrative flows.
- Runtime monitoring and policy enforcement:
- Log all changes to execution approval or consent-related settings, including who/what initiated them.
- Add alerts for suspicious patterns such as:
- Approval requirements being turned off.
- Frequent toggling of consent flags.
- High-risk actions occurring without corresponding approval events.
- Use automated governance tools or security scanners that understand policy metadata to verify that safety controls cannot be disabled from normal agent invocation paths.

