Researchers have discovered hidden instructions on WhatsApp help pages that appear to target large language models. Their concern is not data theft, but whether these instructions can alter the compliance guidance produced by customer support Agents. For AI Agents connected to websites, email, or RAG systems, external content can feed directly into business decisions.
The finding reached the front page of Hacker News, receiving about 505 points and 146 comments. The original research appears in redact.dev's analysis, with the broader discussion available on the Hacker News thread.
What Was Hidden in the Help Pages
A typical help page explains how users can submit a request, track an order, request a refund, or contact platform support.
The text discovered by the researchers was different. It may be invisible to humans or visually unobtrusive, while an LLM can still read it through page content, HTML structure, or retrieval results.
This type of text attempts to alter model behavior. For example, it may discourage a support Agent from proactively directing users to a regulator or downplay available appeal channels.
The key issue is not whether an attacker can make the model produce an unusual sentence. It is what happens with that response afterward.
If a user asks, “My account was suspended. Besides contacting support, who else can I contact?” the model's answer may influence whether the user files a complaint, seeks outside assistance, and holds the platform accountable for its compliance obligations.
This is therefore more than ordinary website tampering or a malicious support script. It exploits a model's ability to read context to redirect a product's output.
This Is Not Ordinary Prompt Injection
Direct prompt injection comes through user input, giving the system an opportunity to filter, flag, or isolate content at the input boundary.
Indirect prompt injection works differently. The attack text does not appear in a chat box. It may be hidden in:
- Webpage text or HTML
- Email content
- PDFs and attachments
- Search result snippets
- Customer support knowledge base pages
- Documents retrieved by an Agent through a browser or RAG system
When the model reads these materials, it may not know which trust level they belong to.
A simplified workflow looks like this:
User question
↓
LLM customer support Agent
↓
Reads help page, email, and retrieval results
↓
Adds external text to the context
↓
Generates compliance guidance or invokes tools
If the system treats everything it reads as “reference material,” an attacker does not need to compromise the model itself. He or she only needs to make a piece of external content look like a credible operational instruction.
Invisibility to humans does not mean invisibility to models. CSS comments, hidden elements, metadata, and machine-specific content can all enter the model's context. A security policy cannot rely solely on what appears on screen.
Why Agents Are More Vulnerable
A conventional chatbot usually generates text. Even if manipulated, the worst outcome may be an inaccurate statement.
A customer support Agent may also:
- Visit websites and help centers.
- Query internal data such as orders, accounts, and support tickets.
- Issue refunds, close tickets, or escalate cases.
- Recommend contacting regulators or filing complaints based on policy.
- Write conversation results to a CRM, email system, or ticketing platform.
A single case of context contamination can escalate from “an incorrect response” to “an incorrect business action.”
For example, after reading malicious text, an Agent might create one fewer escalation ticket or invoke a workflow that should have required manual approval. It could even send an external email containing incorrect compliance guidance.
The output may resemble normal support language, with a courteous tone and plausible logic. A reviewer may not immediately notice that a critical option has disappeared.
The risk has three layers:
Context contamination: External text influences model judgment
Action amplification: The model invokes high-privilege tools
Responsibility shift: The enterprise delegates policy decisions to a probabilistic model
The first layer is a security problem. The second is a permissions problem. The third is a product design problem.
Adding a system prompt that says “ignore malicious instructions” generally does not solve the third layer. Even when the model understands an attack, it may have no reliable way to prove that external text is untrustworthy.
How Enterprises Can Break the Chain
Enterprises cannot depend entirely on a model's ability to reject harmful requests. A more practical approach separates external content, tool permissions, and business rules.
1. Downgrade External Content to Data
Webpages, emails, and search results should be treated by default as untrusted data, not system instructions.
Before they enter the context, they can be wrapped with explicit metadata:
from dataclasses import dataclass
from typing import Any
@dataclass
class RetrievedDocument:
source: str
content: str
trust_level: str
def as_model_context(self) -> dict[str, Any]:
return {
"type": "untrusted_reference",
"source": self.source,
"content": self.content,
"instructions_allowed": False,
}
This is not a complete defense, but it establishes a clear boundary. Commands found on a webpage should not occupy the same authority level as internal compliance policy.
RAG systems should also preserve each document's source, time, and version. Internal corporate policy and external help pages must not receive equal weight.
2. Restrict Tool Permissions
A customer support Agent should not receive default permission to complete every business action.
One approach is to distinguish between:
- Low-risk actions: looking up orders, searching help documents, and drafting responses.
- High-risk actions: issuing refunds, suspending accounts, deleting accounts, and sending formal documents to regulators.
High-risk actions should require controls such as:
requires_human_approval = action in {
"refund",
"account_suspension",
"regulatory_escalation",
"external_complaint_submission",
}
The model may propose an action, but it should not be allowed to complete the entire workflow on its own. Actions involving regulators, appeals, or funds should pass through a rules engine before the system decides whether to approve them.
3. Validate Compliance Paths
Compliance guidance should not rely entirely on unrestricted model generation.
When a user explicitly asks about regulators, consumer protection agencies, or legal remedies, the system must return an approved route or clearly transfer the case to a human.
A basic validation function might look like this:
def needs_human_review(user_question: str, answer: str) -> bool:
regulatory_terms = (
"监管机构",
"消费者保护",
"formal complaint",
"regulator",
)
return any(term in user_question for term in regulatory_terms) and (
"人工" not in answer and "联系" not in answer
)
A production system would also need approved policy versions, review queues, and regional variations. The underlying principle is straightforward: a mandatory compliance path should not be left to the discretion of a probabilistic model.
4. Preserve Auditable Logs
Every response should record:
- The user's question
- Which documents were used
- Each document's URL, version, and timestamp
- Which text was marked as untrusted external content
- Which tools were invoked
- Which rules blocked or approved each action
- Who ultimately reviewed or approved the result
After an error, the team needs to distinguish among model misinterpretation, retrieval of the wrong page, and incorrect permission configuration.
Anomaly detection can provide another layer. If support responses repeatedly avoid regulatory appeal paths, or a group of users receives identical compliance guidance, the system should alert the appropriate team automatically.
Design Implications
This matters for more than the familiar problem of “the model was fooled again.” It exposes a foundational design issue: enterprises have assigned responsibility to an LLM that can read websites, invoke tools, and express conclusions freely, even when those responsibilities should be defined by policy and code.
Customer support security failures will increasingly appear in “how should this be handled?” decisions, rather than only as errors in generated text. A model may never make an obvious privilege violation or execute a dangerous command. A hidden context can still continuously redirect its guidance, affecting user rights and platform accountability.
What distinguishes this case from earlier forms of web-based prompt injection is its target. The attacker is pursuing compliance paths rather than simply trying to make the model disclose secrets. Page content is no longer passive reference material; it is beginning to shape business decisions.
One uncertainty remains: the disclosed text may have different effects across models, browser rendering methods, and Agent architectures. Enterprises can still take two immediate steps: label external content as untrusted and place high-risk actions behind deterministic rules and human approval. Security boundaries cannot exist only in prompts.