A local configuration flaw exposed how attackers can turn an AI agent's existing permissions into a path for unauthorized actions.
TL;DR
The attack: Security researcher Patrick Wardle disclosed a zero-day vulnerability in Meta's Muse macOS application that allowed an unprivileged local process to redirect the agent's dictation traffic to an attacker-controlled endpoint. The attack required existing local code execution under the victim's account; it was not an initial remote-access exploit.
The impact: Once the endpoint was redirected, an attacker could intercept dictated prompts, inject instructions, access authentication material, and exploit capabilities already granted to Muse. The reported research included demonstrations involving file creation and camera access.
The Lineaje analysis: The vulnerability was in a conventional application configuration, but the consequences extended into AI agent security. A process with limited local privileges could influence an agent with considerably broader access. Lineaje maps this progression across the AI Kill Chain and identifies where configuration integrity, runtime policy enforcement, tool restrictions, and human authorization can interrupt the attack. UnifAI's Guardrail Server provides controls designed to enforce security boundaries as agents execute.
What Happened
Meta introduced Muse as a personal AI agent capable of performing tasks through connected applications and services, including email, web browsing, and other user-authorized actions.
Wardle identified an undocumented macOS configuration setting, endo_voyager_dictation_endpoint, that a local process running under the user's account could modify without elevated privileges. By changing this setting, an attacker could redirect Muse's dictation traffic away from its intended destination and toward attacker-controlled infrastructure.
In the reported proxy-based attack path, the malicious endpoint could intercept a legitimate voice command, modify the instructions, and forward the altered request for processing. The resulting exposure extended beyond prompt manipulation. The research also identified access to Muse authentication material and opportunities to misuse permissions the user had already granted the agent.
Meta subsequently issued a hot-fix.
The attacker did not need to obtain the agent's permissions directly. The attacker needed to influence the communication path of an agent that already had them.
The Lineaje View: The Trust Boundary Was the Agent's Communication Path
The defining security failure in Muse was not simply that an attacker could inject a prompt. It was that an unprivileged local process could modify a configuration value controlling where a trusted AI instruction stream was delivered. That made a software configuration weakness an agent authority problem.
Once the communication path was redirected, attacker-controlled instructions could enter the agent's workflow while appearing within the context of a legitimate user session. The agent's existing permissions amplified the potential consequences. Actions involving files, cameras, credentials, and connected services could become available through an instruction path the attacker had influenced.
For Lineaje, the lesson is clear: securing an AI agent requires protecting both the integrity of its instruction channels and the authority it exercises after receiving instructions.
A trusted agent cannot make an untrusted instruction channel safe simply by executing the request with legitimate permissions.
From Local Configuration to Agent Authority
The attack progression illustrates how a conventional endpoint weakness can create an AI-native security failure.
1. The attacker gains a local foothold
The vulnerability required the attacker to execute code under the victim's local user account. It did not independently provide remote access.
2. The trusted dictation endpoint is redirected
The attacker modifies endo_voyager_dictation_endpoint, causing Muse's dictation traffic to reach attacker-controlled infrastructure.
3. Legitimate instructions are intercepted and modified
In the reported proxy-based scenario, the attacker can insert additional instructions into a legitimate user request before it reaches the agent's processing workflow.
4. The agent executes with existing authority
Muse may process the altered request using permissions previously granted by the user. The reported proof of concept demonstrated file and camera actions.
5. Authentication material creates additional exposure
The redirected traffic could expose Muse authentication material, potentially extending the compromise beyond an individual intercepted request.
The result: A lower-privileged local process can influence a more capable AI agent without independently acquiring all the permissions assigned to that agent.
Attack Across the AI Kill Chain
S1 — Reconnaissance: Not demonstrated. The disclosed vulnerability assumes the attacker already has local code execution.
S2 — Trust Manipulation: Active. The attacker exploits a locally writable configuration setting that determines the destination of a trusted agent communication channel.
S3 — Input / Instruction Weaponization: Active. Attacker-controlled infrastructure intercepts dictation traffic and can insert malicious instructions into legitimate requests.
S4 — Reasoning-Time Execution: Active. Muse processes the altered instruction stream within the user's authenticated agent workflow.
S5 — Tool Invocation: Active. The compromised instruction flow can direct Muse to exercise existing capabilities, including file and camera operations.
S6 — Privilege Escalation: Active. Privilege amplification through delegated authority. The attacker could exploit permissions already granted to Muse. No conventional operating-system privilege escalation was demonstrated.
S7 — Lateral Movement: Not demonstrated. The reported attack did not establish lateral movement between independent systems.
S8 — Persistence: Potential. Stolen authentication material could enable continued access, depending on token validity and authentication controls.
S9 — AI-Native Command and Control: Active. The attacker-controlled endpoint intercepts and manipulates the agent's trusted instruction stream.
S10 — Actions on Objectives: Active. Reported outcomes include unauthorized file and camera operations, with potential exposure of sensitive information and connected services.

How to Break the Attack Chain
The Muse vulnerability highlights multiple opportunities to prevent a compromised instruction path from becoming unauthorized agent activity.
1. Protect Agent Configuration and Communication Paths
Treat agent endpoints, proxy settings, credential brokers, and other control-plane configurations as security-sensitive assets. Restrict unauthorized modification and monitor unexpected changes.
2. Enforce Approved Destinations
Restrict agent communications to authorized endpoints through independent network or runtime controls. Destination enforcement must not depend exclusively on configuration that the attacker can modify.
3. Limit Agent Privileges and Tool Access
Apply least privilege to files, cameras, microphones, credentials, and connected services. Agents should have access only to the capabilities required for their authorized tasks.
4. Require Approval for Consequential Actions
Use independent authorization controls for sensitive operations, including credential access, executable file creation, sensitive-data export, and other high-risk activities.
5. Protect Authentication Material
Isolate agent credentials, limit token exposure, and establish mechanisms for revocation and monitoring. A compromised instruction channel should not automatically provide durable access to an authenticated agent session.
6. Monitor for Configuration and Behavioral Anomalies
Detect unexpected endpoint changes, unusual network connections, unsafe tool invocations, and suspicious agent behavior. Correlate activity across the endpoint, agent, and connected services to identify attack progression.
The objective is to prevent a compromised communication path from becoming unrestricted agent authority.
How UnifAI Helps Enforce the Boundary
Meta Muse demonstrates why Lineaje built UnifAI. Securing agentic AI requires more than detecting malicious prompts. Organizations must govern what agents can access, which tools they can invoke, and what actions they are permitted to execute.
Through its Guardrail Server, UnifAI provides runtime visibility and policy enforcement across interactions with models, MCP servers, tools, data, other agents, and users. Centrally managed policies can block unauthorized actions, restrict tool usage, protect sensitive information, and require human approval before consequential operations.
The critical security boundary is between what an agent is instructed to do and what it is authorized to execute.
UnifAI enforces these boundaries through six core security and governance capabilities:
Prompt Injection and Untrusted Content
Detect and block malicious instructions and AI-specific threats before they lead to unauthorized agent behavior.
Data and Sensitive Information Controls
Protect sensitive information through policy-based restrictions, masking, and redaction to help prevent unauthorized disclosure.
Destination Controls
Apply policies governing agent communications and outbound actions to restrict unauthorized data exposure through connected tools and integrations.
Tool and Action Governance
Allow or block tool invocations, restrict access to sensitive capabilities, and require human approval before high-risk operations proceed.
Runtime Monitoring
Maintain visibility into agent interactions, tool execution, and policy violations as agents operate.
Evidence and Compliance
Generate audit-ready evidence of policy violations, enforcement decisions, remediation activity, and control coverage to support investigations and continuous governance.
Together, these capabilities create multiple opportunities to interrupt malicious activity even when an attacker has influenced an agent's instruction stream.
UnifAI's ability to interrupt any particular step depends on the integration, configured policies, and visibility into that operation.
The Lineaje Takeaway
Meta Muse exposes a fundamental risk of agentic AI: an attacker does not always need to compromise an agent's permissions to exploit its authority. In this case, an unprivileged local process could redirect a trusted communication channel, potentially turning legitimate agent capabilities toward unauthorized objectives.
Meta's hot-fix addressed the disclosed vulnerability. But the broader security requirement extends beyond any single application or configuration setting. Organizations must protect agent control paths, constrain delegated privileges, and enforce authorization at the point of execution. Because when an AI agent can act on behalf of a user, protecting what it is allowed to do matters as much as protecting what it is told to do.
Trust the agent's permissions only when you can control how they're used.
When an AI agent's instruction channel is compromised, its permissions become the attack surface.
Secure it with UnifAI →