Network-Level Prompt and Trait Leakage in Local Research Agents

TL;DR

This paper reveals that local research agents using language models are vulnerable to network-level inference attacks that can leak user prompts and traits, highlighting significant privacy risks and proposing mitigation strategies.

Contribution

It introduces a novel network-level attack on Web and Research Agents that infers prompts and user traits solely from network metadata, demonstrating high accuracy and robustness.

Findings

Over 73% prompt recovery rate.

Up to 19 of 32 user traits inferred accurately.

Mitigation reduces attack effectiveness by 29%.

Abstract

We show that Web and Research Agents (WRAs) -- language-model-based systems that investigate complex topics on the Internet -- are vulnerable to inference attacks by passive network observers. Deployment of WRAs \emph{locally} by organizations and individuals for privacy, legal, or financial purposes exposes them to DNS resolvers, malicious ISPs, VPNs, web proxies, and corporate or government firewalls. However, unlike sporadic and scarce web browsing by humans, WRAs visit $70{-}140$ domains per each request with a distinct timing pattern creating unique privacy risks. Specifically, we demonstrate a novel prompt and user trait leakage attack against WRAs that only leverages their network-level metadata (i.e., visited IP addresses and their timings). We start by building a new dataset of WRA traces based on real user search queries and queries generated by synthetic personas. We define a behavioral metric (called OBELS) to comprehensively assess similarity between original and inferred prompts, showing that our attack recovers over 73\% of the functional and domain knowledge of user prompts. Extending to a multi-session setting, we recover up to 19 of 32 latent traits with high accuracy. Our attack remains effective under partial observability and noisy conditions. Finally, we discuss mitigation strategies that constrain domain diversity or obfuscate traces, showing negligible utility impact while reducing attack effectiveness by an average of 29\%.

Tables

Table 1. Table 1: Traces of Web and Research Agents collected from different base datasets.

Base Dataset	Target	# Total	# Test	Agent	Avg. # Dom	Avg. # URLs	Prompts $\times$ Sessions
FEDWEB13 [trec13-fedweb-topics]	Prompt	50 prompts	20	GPT-Researcher	77.5	143.0	1 prompt $\times$ 1 session
SESSION14 [trec14-session-data]	Prompt	60 prompts	20	GPT-Researcher	69.9	145.9	1 prompt $\times$ 1 session
DD16 [trec16-domain-data]	Prompt	53 prompts	20	GPT-Researcher	64.8	155.8	1 prompt $\times$ 1 session
PERSONA [castricato2024persona]	Trait	50 personas	3	AutoGen	144.1	173.7	3–5 prompts $\times$ 7 sessions
		(of 997)					= 21–35 queries

Table 2. Table 2: 5-shot ICL vs. supervised fine-tuning across inference LLMs. ICL outperforms fine-tuning on all metrics, making it the stronger approach for prompt leakage attack.

Models (Method)	SBERT	LLM-Judge	OBELS
			$E_{\text{func}}$	$E_{\text{dom}}$	$E_{\text{sem}}$	$T_{\text{ent}}$
GPT-4o (ICL)	0.492	0.415	0.770	0.735	0.520	0.640
GPT-4o (FT)	0.469	0.340	0.675	0.690	0.485	0.615
GPT-4.1 nano (ICL)	0.430	0.330	0.735	0.700	0.500	0.665
GPT-4.1 nano (FT)	0.369	0.210	0.610	0.605	0.440	0.510
Llama 3.1-8B (ICL)	0.466	0.310	0.695	0.675	0.475	0.630
Llama 3.1-8B (FT)	0.416	0.230	0.705	0.710	0.470	0.525
Qwen 2.5-32B (ICL)	0.489	0.400	0.770	0.72	0.525	0.670
Qwen 2.5-32B (FT)	0.404	0.225	0.595	0.640	0.410	0.530
Gemma 3-4B (ICL)	0.429	0.280	0.675	0.670	0.475	0.635
Gemma 3-4B (FT)	0.335	0.175	0.510	0.485	0.355	0.420

Table 3. Table 3: Prompt recovery performance depending on different numbers of ICL examples. 5-shot offers the best overall balance across evaluation metrics.

No. of Examples	SBERT	LLM-Judge	OBELS
			$E_{\text{func}}$	$E_{\text{dom}}$	$E_{\text{sem}}$	$T_{\text{ent}}$
0-shot	0.395	0.295	0.665	0.630	0.465	0.615
5-shot	0.492	0.415	0.770	0.735	0.520	0.640
8-shot	0.490	0.400	0.760	0.730	0.540	0.610
12-shot	0.504	0.405	0.750	0.710	0.530	0.640
15-shot	0.487	0.385	0.770	0.685	0.525	0.645

Table 4. Table 4: Prompt recovery performance on SESSION14 across WFAs. All agents are evaluated on 20 prompts with 5-shot ICL, except Deep Research ∗ (5 prompts, 3-shot). GPT-Researcher traces leak the most, while Deep Research shows comparable leakage despite fewer shots.

Agent	SBERT	LLM-Judge	OBELS
			$E_{\text{func}}$	$E_{\text{dom}}$	$E_{\text{sem}}$	$T_{\text{ent}}$
AutoGen	0.356	0.225	0.565	0.625	0.400	0.495
Browser-Use	0.368	0.240	0.540	0.590	0.390	0.485
GPT-Researcher	0.492	0.415	0.770	0.735	0.520	0.640
Deep Research∗	0.574	0.360	0.680	0.720	0.480	0.640

Table 5. Table 5: Prompt recovery on trace by GPT-Researcher with different backbones across datasets. Local backbones leak less than GPT-4 traces but remain informative.

Model	Dataset	SBERT	LLM-Judge	OBELS
				$E_{\text{func}}$	$E_{\text{dom}}$	$E_{\text{sem}}$	$T_{\text{ent}}$
GPT4	SESSION	0.492	0.415	0.770	0.735	0.520	0.640
Local	SESSION	0.512	0.355	0.735	0.745	0.520	0.630
GPT4	FEDWEB	0.505	0.305	0.755	0.735	0.540	0.695
Local	FEDWEB	0.493	0.310	0.750	0.745	0.515	0.645
GPT4	DD	0.453	0.190	0.585	0.615	0.430	0.545
Local	DD	0.445	0.180	0.550	0.635	0.430	0.515

Table 6. Table 6: Prompt recovery with different ICL inference models. Proprietary models yield the highest scores.

Models	SBERT	LLM-Judge	OBELS
			$E_{\text{func}}$	$E_{\text{dom}}$	$E_{\text{sem}}$	$T_{\text{ent}}$
Claude-opus-4-1	0.544	0.445	0.765	0.785	0.570	0.670
Gemini-2.5-pro	0.506	0.420	0.710	0.705	0.505	0.645
GPT-5	0.470	0.240	0.710	0.715	0.535	0.670
GPT-5-mini	0.479	0.315	0.710	0.685	0.500	0.635
GPT-4o	0.492	0.415	0.770	0.735	0.520	0.640
GPT-4.1 nano	0.430	0.330	0.735	0.700	0.500	0.665
Llama 3.1 8B	0.466	0.310	0.695	0.675	0.475	0.630
Qwen 2.5-32B	0.489	0.400	0.770	0.72	0.525	0.670
Gemma 3-4B	0.429	0.280	0.675	0.670	0.475	0.635

Table 7. Table 7: Average similarity scores across trait categories. Δ \Delta shows the improvement of full sessions over three sessions.

Trait Category	3 Sessions	7 Sessions	$\Delta$ (%)
Demographic	0.39	0.45	+15.4%
Occupational	0.68	0.73	+7.4%
Psychographic	0.48	0.56	+16.7%
Behavioral	0.41	0.46	+12.2%

Table 8. Table 8: Effect of decoy prompts and domain shuffling on prompt leakage attacks.

Defense	SBERT	LLM-Judge	OBELS
			$E_{\text{func}}$	$E_{\text{dom}}$	$E_{\text{sem}}$	$T_{\text{ent}}$
Without Defense	0.492	0.415	0.770	0.735	0.520	0.640
1 Decoy	0.390	0.190	0.610	0.615	0.420	0.545
3 Decoys	0.376	0.210	0.645	0.615	0.420	0.555
5 Decoys	0.368	0.175	0.565	0.590	0.395	0.500
1 Decoys + shuffle	0.455	0.285	0.725	0.715	0.510	0.610
3 Decoys + shuffle	0.415	0.235	0.685	0.645	0.455	0.610
5 Decoys + shuffle	0.403	0.220	0.650	0.695	0.465	0.570

Table 9. Table 9: Median inference accuracy across trait categories.

Trait Category	No Defense	w. Defense	$\Delta$ (%)
Demographic	0.4440	0.4080	$-8.1\%$
Occupational	0.8975	0.6790	$-24.3\%$
Psychographic	0.5250	0.5030	$-4.2\%$
Behavioral	0.4550	0.4550	$0.0\%$

Table 10. Table 10: Prompt recovery under different trace visibility. URL-level traces leak the most; adding timing metadata shows no consistent benefit.

Trace Visibility	SBERT	LLM-Judge	OBELS
			$E_{\text{func}}$	$E_{\text{dom}}$	$E_{\text{sem}}$	$T_{\text{ent}}$
Domains	0.492	0.415	0.770	0.735	0.520	0.640
Domains + Timing	0.486	0.455	0.725	0.695	0.525	0.640
URLs (100%)	0.624	0.600	0.810	0.805	0.620	0.695
Partial URLs (80%)	0.618	0.590	0.795	0.795	0.635	0.680
Partial URLs (60%)	0.622	0.590	0.820	0.755	0.585	0.690

Table 11. Table 11: Leakage vs. utility under varying visibility. Reducing visibility lowers prompt recovery accuracy but leaves the report quality nearly unchanged.

Visibility	Utility	SBERT	LLM-Judge	OBELS
				$E_{\text{func}}$	$E_{\text{dom}}$	$E_{\text{sem}}$	$T_{\text{ent}}$
100%	8.55	0.492	0.415	0.770	0.735	0.520	0.640
80%	8.72	0.491	0.415	0.750	0.725	0.515	0.645
60%	8.54	0.489	0.355	0.765	0.730	0.520	0.650
40%	8.50	0.453	0.350	0.765	0.700	0.515	0.650
20%	8.60	0.438	0.300	0.725	0.695	0.475	0.615
10%	8.54	0.375	0.225	0.610	0.555	0.395	0.485
5%	8.32	0.319	0.185	0.530	0.455	0.335	0.395
2%	7.65	0.238	0.095	0.345	0.410	0.275	0.315

Table 12. Table 12: Few-shot ICL configuration for each attack task.

Task	ICL Shots	Output Format	Prompt Details
Prompt Recovery	5	Natural language query	Trace $\to$ prompt
Trait Inference	3	Structured list	Trace $\to$ trait list

Table 13. Table 13: Prompt recovery: 5-shot vs. contrastive ICL.

Type of ICL	SBERT	LLM-Judge	OBELS
			$E_{\text{func}}$	$E_{\text{dom}}$	$E_{\text{sem}}$	$T_{\text{ent}}$
5-shot ICL	0.492	0.415	0.770	0.735	0.520	0.640
Simple (1 neg)	0.495	0.405	0.740	0.745	0.525	0.645
Simple (3 neg)	0.490	0.355	0.755	0.750	0.510	0.625
QF (1 neg)	0.493	0.385	0.765	0.680	0.520	0.590
QF (3 neg)	0.492	0.355	0.750	0.740	0.505	0.640

Table 14. Table 14: Prompt recovery: example selection strategies.

Ex Selection Strategy	SBERT	LLM-Judge	OBELS
			$E_{\text{func}}$	$E_{\text{dom}}$	$E_{\text{sem}}$	$T_{\text{ent}}$
Random	0.492	0.415	0.770	0.735	0.520	0.640
Embedding-based	0.481	0.375	0.740	0.755	0.515	0.605

Table 15. Table 15: Prompt recovery: different example orderings

Ex Ordering	SBERT	LLM-Judge	OBELS
			$E_{\text{func}}$	$E_{\text{dom}}$	$E_{\text{sem}}$	$T_{\text{ent}}$
Random	0.481	0.375	0.740	0.755	0.515	0.605
Ascending	0.493	0.415	0.725	0.735	0.525	0.645
Descending	0.481	0.380	0.755	0.745	0.495	0.620

Equations

$$\hat{p}=M_{\text{PR}}(\tilde{t}),\max \mathrm{Sim}(M_{\text{PR}}(\tilde{t}),p).$$

$$\hat{\tau }=M_{\text{TI}}({\tilde{t}}^{1:N}),\max \mathrm{Score}(M_{\text{TI}}({\tilde{t}}^{1:N}),\tau ).$$

Full text

Specifically, we demonstrate a novel prompt and user trait leakage attack against WRAs that only leverages their network-level metadata (i.e., visited IP addresses and their timings). We start by building a new dataset of WRA traces based on real user search queries and queries generated by synthetic personas. We define a behavioral metric (called OBELS) to comprehensively assess similarity between original and inferred prompts, showing that our attack recovers over 73% of the functional and domain knowledge of user prompts. Extending to a multi-session setting, we recover up to 19 of 32 latent traits with high accuracy. Our attack remains effective under partial observability and noisy conditions. Finally, we discuss mitigation strategies that constrain domain diversity or obfuscate traces, showing negligible utility impact while reducing attack effectiveness by an average of 29%.

††Code, prompts available at https://github.com/umass-aisec/wra

1 Introduction

Web and Research Agents (WRAs) are reshaping how users interact with information. Unlike traditional assistants that answer isolated queries, these Large Language Model (LLM)-powered systems autonomously plan, browse, and synthesize knowledge across the web [huang2025deep]. Major AI providers are integrating such agents directly into their flagship assistants or browsers, including OpenAI [openai2025introducingdeepresearch], Google Gemini [google2025geminideepresearch], Grok [xai2025grok3], Mistral [mistral2025lechat], and Perplexity [perplexity2025deepresearch]. Open-source counterparts such as LangChain’s Local Deep Researcher [langchain2025localdeepresearcher], GPT Researcher [elovic2023gptresearcher], and Agent Laboratory [schmidgall2025agent] are also widely adopted in academic and developer communities. Their growing deployment in assistants, productivity platforms, and enterprise environments, particularly within privacy-sensitive sectors such as healthcare, law, and finance, raises urgent concerns about their security and privacy implications. While on-device execution through locally-deployable models and TLS-encrypted access could suggest privacy guarantees, this perception is misleading. Yet WRAs leave unavoidable, structured metadata traces that can reveal sensitive user intent, creating an underexplored leakage vector.

As autonomous agent systems, WRAs inherit vulnerabilities from both LLMs and traditional web browsing  [hui2024pleak, carlini2021extracting, siby2019encrypted, bird2020replication]. Yet they also expose a distinct, underexplored vulnerability: behavioral traces determined by an LLM acting on a user’s query. Prior work has shown that user intent and goals can be inferred from search queries and browsing activity  [rose2004understanding, jones2007know]. Even when content is encrypted, metadata such as domain names, access order, payload size, and timing can silently reveal what a user is trying to accomplish  [oliveira2023browsing, su2017anonymizing].

Crucially, these behavioral traces are operationally distinguishable. WRAs generate dense cascades of semantically related domain visits within short time windows [perplexity2025deepresearch]. Unlike cognitively paced, irregular, and opportunistic human browsing [kellar2007field], WRAs follow deterministic retrieval-and-synthesis loops with low variance in per-step timing. As a result, a single WRA session often traverses 40–100 distinct domains, whereas human sessions typically rely on few sites [wang2025ai]. These structured, high-throughput access patterns make WRA traffic reliably separable from human activity and particularly amenable to profiling and inference attacks [chiang2025web, mudryi2025hidden].

We adopt a realistic threat model in which a passive adversary, (e.g., DNS resolver, ISP, enterprise firewall, or local network operator) observes only domain-level traffic metadata, without access to prompts, page contents, or model internals. Despite this limited visibility, we show that adversaries can reliably recover what users asked and who they are.

Motivating Examples. Consider a user seeking reproductive health information: their research agent may visit clinics, support forums, and medical sites. Even without access to page contents, these traces alone can expose the agent’s internal reasoning process and deeply stigmatized intent. As WRAs become integrated into daily decision-making, their behaviors present a new leakage channel. In essence, privacy failures emerge not from what agents say, but from how they act.

Our Work. We present privacy leakage attacks that exploit metadata traces of WRAs deployed locally. The attacks include (1) Prompt Recovery, which recovers a user’s original prompt from observed domain sequences, and (2) Trait Inference, which profiles latent attributes (e.g., gender, ideology) from the agent’s multi-session browsing patterns. The adversary trains an inference model using task-specific strategies such as In-Context Learning (ICL) and fine-tuning to map browsing traces to inference targets (Table 2). Our results show that the attacks remain effective even when 40% of the traces are masked or fully obfuscated, revealing that encrypted content alone cannot guarantee privacy (Table 10). We observe that WRAs visit dozens of marginal or redundant domains that do not improve the final report but still expand the adversary’s visibility (Table 11). To mitigate these risks, we propose and evaluate practical defenses that either hide traces, by injecting LLM-generated decoy prompts and virtual personas to confuse inference (Section 8.1), or block traces, by redirecting tasks to multipurpose sources or LLM knowledge, avoiding uniquely identifying domains (Section 8.2).

Our contributions are as follows:

• •

New attack surface: We introduce metadata-based privacy attacks from behavioral traces produced by WRAs and propose a general two-stage pipeline for prompt recovery and trait inference.

• •

Benchmark dataset and OBELS metric: We construct and release a dataset linking domain traces to prompts and persona traits, and introduce OBELS, an ontology-aware metric for evaluating privacy leakage through behavioral traces.

• •

Ablation and mitigation: We conduct extensive experiments across agents, LLMs, and masking conditions, and evaluate mitigation that constrain domain diversity or obfuscate traces while negligibly affecting utility.

2 Background and Related Work

2.1 AI, Web, and Research Agents

Standalone LLMs to AI Agents. LLMs excel at language understanding but are limited as static knowledge systems [achiam2023gpt, team2024gemini]. They cannot access real-time information, call external APIs, or execute multi-step plans, but produce responses based only on their pretrained knowledge. Early solutions such as RAG [lewis2020retrieval, guu2020retrieval] and tool-augmented LLMs [schick2023toolformer, shen2023hugginggpt, qin2023toolllm, chen2024advancing] improved grounding and tool use, but remain constrained to pre-indexed corpora and invoking tools only when explicitly instructed. AI agents address this by embedding LLMs into a perception–action loop [yao2023react, autogpt, wang2023voyager], where the model plans, executes, and adapts across multiple steps, enabling autonomous reasoning and dynamic interaction with external environments.

Web Agents. Generic agents can reason about which queries to run, but often lack robust capabilities for controlling browsers, parsing dynamic content, handling JavaScript-heavy pages, or managing session state across multiple sites. Web agents integrate LLM planning with browser control: issuing search queries, navigating between sources, extracting content, and deciding which actions to perform based on the evolving context [chiang2025web]. Frameworks like AutoGen [wu2023autogen] and Browser-Use [browser_use2024] exemplify these capabilities, though evaluations often emphasize narrow navigation tasks.

Research Web Agents (WRAs). WRAs operationalize deep evidence synthesis through a search–retrieve–extract–synthesize loop across many sources (Figure 2). Given a user query, the agent generates sub-queries and issues them via APIs such as Tavily [tavily] to minimize token overhead and retrieve relevant documents efficiently. Retrieved content is parsed into evidence, distilled into notes, and evaluated to decide whether further exploration is needed. This process repeats until sufficient coverage is achieved, at which point the agent composes a comprehensive, citation-rich output [huang2025deep, schmidgall2503agentrxiv, zheng2025deepresearcher, perplexity2025deepresearch, chiang2025web]. Systems exemplifying this paradigm include GPT Researcher [elovic2023gptresearcher], LangChain’s Local Deep Researcher [langchain2025localdeepresearcher], OpenAI Deep Research [openai2025introducingdeepresearch], Grok DeepSearch [xai2025grok3], and Gemini Deep Research [google2025geminideepresearch].

Because WRAs generate dense browsing traces over dozens of domains, they amplify metadata-leakage risks. This risk has been underscored when Grok and OpenAI misconfigurations exposed private prompts to public indexing [bbc2025example, stokel-walker2025google]. Locally deployed agents can be one of the mitigation strategies against such threats. Running on personal machines or servers, they preserve confidentiality while offering lower latency, offline use, and lower cost. Examples include GPT-Researcher [elovic2023gptresearcher] with self-hosted backends such as Ollama [ollama2025] and AMD’s GAIA [amd_gaia_github] to operate fully on-device, giving users more control over both their data and their agent workflows.

2.2 Privacy Attacks

*Threats in LLMs. * LLMs introduce unique privacy risks due to their training data and the ways users interact with them. One major class of attacks focuses on hidden-input inference, recovering sensitive inputs such as training data, system prompts, or user queries [carlini2021extracting, zhang2023effective, hui2024pleak, pasquini2024llmmap, liu2025evaluatingllm, carlini2024remote, weiss2024your]. Other work has focused on recovering hidden system prompts used internally by providers [zhang2023effective, hui2024pleak], where adversaries probe model input and output patterns to elicit protected instructions. Unlike these approaches, our setting assumes no direct access to the model and relies instead on indirect behavioral signals.

Beyond direct extraction, studies show that semantic leakage occurs even when the attacker only observes generated outputs. Pasquini et al.[pasquini2024llmmap] and Liu et al.[liu2025evaluatingllm] found that reconstructed prompts often preserve enough semantic content for intent inference, while Carlini et al.[carlini2024remote] and Weiss et al.[weiss2024your] demonstrated that response timing and token-length patterns can reveal coarse-grained information about prompt topics. These attacks, however, assume access to model outputs or fine-grained response timings. By contrast, we show that passively observable network-level metadata alone, without accessing queries or responses, can be sufficient to infer hidden prompts.

LLMs also introduce privacy risks through trait inference and user profiling. Their outputs carry author-identifying signals [narayanan2012feasibility, schwartz2013personality, hovy2015demographic, azucar2018predicting], allowing inference of attributes such as age, gender, and personality. Other risks include speculative decoding revealing fragments of private inputs [wei2024privacy] and long-context memory retaining user data across sessions for later retrieval [wang2025unveiling]. Unlike these works, we assume a strictly weaker threat model: the adversary does not observe model inputs, outputs, or internal states, relying solely on external traffic traces (e.g., domain sequences, timing, payload sizes).

*Threats in Web Privacy. * Metadata leakage has long been recognized as a central privacy risk on the web. Classical work on anonymous communications (e.g., MIX Nets [chaum1981untraceable] and Tor [dingledine2004tor]) demonstrated that encrypting content is insufficient when traffic patterns remain exposed. Website Fingerprinting (WF) studies [wright2009traffic, cai2012touching, hayes2016k, juarez2016toward] showed that adversaries can infer visited pages based on encrypted flow patterns, while large-scale deanonymization attacks like the Netflix attack[narayanan2008robust] revealed that sparse behavioral traces are often enough to re-identify individuals. Subsequent work confirmed that traffic features, such as packet sizes, burst patterns, and inter-arrival timing, can fingerprint websites even under protections like Tor [hintz2002fingerprinting, panchenko2011website]. Parallel work in web tracking exposed persistent profiling vectors, including cookie-based tracking [lerner2016internet], cookieless fingerprinting [nikiforakis2013cookieless, acar2014web], and evercookies [ayenson2011flash].

Recent work has shifted to domain-level metadata as a source of behavioral leakage. Oliveira et al.[oliveira2023browsing] showed that as few as four domains can uniquely re-identify most users in real-world datasets. Crichton et al.[crichton2025rethinking] found that domain sequence fingerprints remain stable across years, even after cookie resets. Cross-context linkage is also possible: Naini et al.[naini2015you] and Su et al.[su2017anonymizing] demonstrated that anonymized browsing logs can be matched across platforms, breaking assumed protections. Whereas classical WF identifies which site a user visits, our attack infers user’s task or intent from agent-driven traversals. The two are complementary: WF reveals destinations, while our method reconstructs prompts or traits from the resulting domain sequences.

While protocol-level defenses such as HTTPS, DNS-over-HTTPS (DoH), and DNS-over-TLS (DoT) aim to hide domain names too, they often fail to conceal key identifiers. Hoang et al.[hoang2020assessing] showed that TLS handshakes frequently leak domain information, while Sunahara et al.[sunahara2025framework] pointed out widespread misconfigurations in encrypted DNS deployments, enabling persistent metadata leakage. Similarly, Wang et al. [wang2025wechat] demonstrated that in-app telemetry (e.g., navigation events, click logs, and tracking APIs) leaks fine-grained behavioral patterns to platforms. Unlike these works, we assume a weaker adversary: a passive network observer without privileged telemetry access, relying only on network-level domain sequences and packet metadata.

Agentic Privacy and Security Threats. AI agents amplify privacy risks by combining LLM reasoning with active browsing and external tool integration [googlereport]. Kim et al. [kim2024llms] showed that compromised agents can scrape PII from visited pages and reuse it in phishing, while InjecAgent [zhan2024injecagent] demonstrated that crafted payloads in webpages can trigger secret retrieval or unauthorized service access. Defenses such as AirGapAgent [bagdasarian2024airgapagent] and CHeaT [ayzenshteyncloak] aim to counter these threats through context isolation, behavior cloaking, and honey-token traps.

However, these prior studies assume an adversary with visibility into the agent’s queries, outputs, or injected prompts. In contrast, our work identifies a new and underexplored attack surface: even without access to agent inputs, outputs, or model internals, domain sequences and packet-level metadata alone can be exploited to reconstruct hidden prompts and infer sensitive user traits. This highlights a distinct dimension of privacy leakage introduced by web and research agents, where autonomous decision-making produces metadata-rich browsing patterns vulnerable to adversarial inference. To our knowledge, this is the first study to identify and exploit metadata-driven leakage in WRAs.

3 Overview: Prompt and Trait Leakage Attack

We study a passive network adversary that monitors encrypted traffic between the AI agent (acting on behalf of the user) and the internet. Without access to page contents or search queries, the adversary can exploit metadata leakage to recover sensitive information about the user’s inputs and attributes.

Problem Definition. WRAs execute user prompts by issuing queries, following links, and retrieving information, leaving behind browsing traces that encode sensitive signals. Even if the underlying page contents or prompts are hidden, the sequence and diversity of domains can reveal the intent behind a query, while recurring patterns across sessions expose persistent user traits. An adversary has clear incentives to exploit these inferences: prompt recovery compromises user intent privacy, while trait inference enables long-term profiling that can be monetized, surveilled, or used for manipulation.

Prompt Recovery. With proxy dataset $D_{\text{PR}}=\{(WRA(p_{j}),p_{j})\}$ consisting of pairs indexed by $j$, the adversary constructs an inference model $M_{\text{PR}}$. For a new prompt $p$ with trace $t=WRA(p)$ (optionally filtered to $\tilde{t}$), the adversary recovers the prompt $\hat{p}$, aiming to maximize functional similarity:

[TABLE]

Trait Inference. Let $\tau$ denote a user’s latent trait vector and $\{p_{i}\}_{i=1}^{N}$ the prompts across $N$ sessions, yielding $t^{1:N}=WRA(\{p_{i}\}_{i=1}^{N})$. From proxy dataset $D_{\text{TI}}=\{(WRA(\{p_{i}^{(j)}\}_{i=1}^{N}),\,\tau_{j})\}$, the adversary instantiates an inference model $M_{\text{TI}}$. On a new multi-session trace $t^{1:N}$ and infers trait $\hat{\tau}$, maximizing agreement:

[TABLE]

where $\mathrm{Sim}$ and $\mathrm{Score}$ denote task-appropriate semantic similarity and trait-agreement metrics, respectively.

3.1 Threat Model

Adversary Goals. The adversary’s objective is to infer sensitive user information from the browsing trace. We focus on two representative leakage goals that capture both short- and long-term risks. The first is prompt recovery, where the adversary seeks to infer queries functionally equivalent to the user’s original input (e.g., detecting that a user asked about “signs of depression and seeking professional mental health support”). The second is trait inference, where the adversary profiles latent attributes such as gender, religion, and political ideology by correlating patterns across multiple browsing sessions. Together, these illustrate how metadata can expose both immediate user intent and persistent personal characteristics.

Adversary Capabilities. The adversary observes domain-level metadata generated by the agent’s web activity, including domain names (via plaintext DNS or TLS handshake metadata such as SNI), the order of domain visits, and coarse packet-level features such as timing and payload sizes. The adversary does not observe full URLs (e.g., query strings), page contents, user prompts, or the agent’s intermediate queries.

In practice, visibility may be further reduced by Content Delivery Networks (CDNs), reverse proxies, or load balancers that aggregate multiple services under a small number of endpoints. To capture such weaker settings, we explicitly evaluate partial-visibility scenarios in which only a fraction of domains (e.g., 80%–10%) is observable (Table 11). These capabilities correspond to realistic on-path observers such as local ISPs, corporate firewalls, DNS resolvers, VPN providers, or shared network operators that collect encrypted metadata without decryption or manipulation.

Adversary Assumptions. We assume the user interacts with a local web or research agent that autonomously performs web browsing in response to a natural language prompt. The adversary is aware of the agent’s general browsing capabilities, such as issuing web searches, clicking links, scrolling pages, or scraping structured data from web pages. The adversary monitors the session between the agent and the Internet but does not alter traffic. We treat full-session metadata visibility as an upper bound: weaker adversaries such as DNS resolvers or enterprise firewalls may see only subsets of domains, yet our experiments show that WRA traffic remains highly distinguishable due to its structured, high-volume access patterns. We further assume that DNS and TLS handshake metadata remain visible (i.e., no DoH, DoT, or ECH) and that users do not employ VPNs, Tor, or other anonymizing proxies that would conceal domain sequences completely.

3.2 Attack Scenarios

In this section, we illustrate when a passive adversary would actually deploy our prompt and trait leakage attack. Locally deployed WRAs are especially relevant in settings where users avoid reliance on remote APIs, reduce recurring costs, maintain control over proprietary workflows, or process highly confidential information that cannot be shared externally. In such cases, browsing traffic is generated directly on the client machine, exposing metadata to on-path observers.

Personal WRAs. An individual running a local WRA for personal tasks, such as health research, financial planning, or private study, may assume that confidentiality is preserved by avoiding cloud services. Yet even with local deployment, ISPs, enterprise firewalls, or other intermediaries can still observe traces and reconstruct prompts or infer private traits, enabling targeted advertising, discrimination, or phishing.

Academic WRAs. In university, students and faculty use local WRAs for daily tasks, coursework, or research, leaking information about politics or unpublished work. External observers like ISPs or competing research entities could exploit traces to reconstruct prompts or profile academic interests.

Industrial WRAs. At the company level, employees use local WRAs for competitor analysis, strategic planning (e.g., product roadmaps, M&A interests, financial planning), or handling confidential information (e.g., legal case files or patient records). These traces can be mined for business intelligence by competitors, ISPs, cloud providers, or even internal IT monitors. In startup companies, small teams could rely on local WRAs for cost savings or planning, but this may lead to leaks about funding strategies, partnership negotiations, or technical stack decisions. ISPs or data brokers could harvest and resell the information or insights to competitors.

State WRAs. At the government or state level, state-operated firewalls or regulators monitoring domestic traffic could reconstruct politically sensitive prompts or identify activists and vulnerable communities for closer surveillance.

Overall, local deployment makes browsing activity directly observable in ways that remote, server-side agents do not. For adversaries, such visibility creates actionable opportunities to reconstruct immediate user prompts or build long-term trait profiles, depending on the target and setting.

4 Attack Methodology

We present the end-to-end pipeline for our privacy attacks against AI agents. Both tasks—prompt recovery and trait inference—follow a shared two-stage process: (1) offline model construction on proxy datasets $D_{\text{PR}}$ or $D_{\text{TI}}$, yielding $M_{\text{PR}}$ or $M_{\text{TI}}$; and (2) online attack execution on real user traces $t$ or $t^{1:N}$ to produce $\hat{p}$ or $\hat{\tau}$. The pipeline remains structurally consistent across tasks, though the input sources and inference targets differ.

Figure 3 illustrates our two-stage attack pipeline, separating the adversary’s model construction from the attack execution. A two-stage design is necessary because the adversary cannot directly obtain a large set of real user prompts paired with their browsing traces. Instead, the adversary first trains an inference model on proxy data that mimics real-world interactions, and then applies this trained model to actual users.

4.1 Proxy Prompt Generation

To train the inference model in Stage 1, the adversary generates proxy prompts that realistically simulate user behavior and produce informative traces $t$. Effective proxy prompts must balance realism, browsing induction, and inferential utility. (a) Prompts resemble natural-language queries real users might issue (health, education, planning). (b) They must reliably trigger multi-page browsing, rather than being satisfied by a single source (e.g., Wikipedia) or by the agent’s prior knowledge; to enforce this, we prepend instructions requiring at least five distinct page visits. (c) Prompts must be sufficiently detailed to produce distinguishable traces; underspecified inputs are rewritten into instruction-complete forms to avoid trivial queries that yield little signal. (d) Prompts and resulting traces remain semantically linked, so the trace encodes sufficient signal for inference.

Prompt recovery. We draw proxy prompts from public query datasets (FEDWEB13 [fedweb13], SESSION14 [trec14-session-data], DD16 [trec16-domain-data]) to build $D_{\text{PR}}=\{(WRA(p_{j}),p_{j})\}_{j}$. Some prompts are underspecified to reliably induce meaningful browsing, and agents differ in how they handle such inputs. GPT-Researcher [elovic2023gptresearcher] internally refines vague prompts, but ChatGPT Deep Research UI asks clarifying questions, while Deep Research API, AutoGen, and Browser-Use execute inputs as-is. To align behaviors, Deep Research API prompts are rewritten into detailed variants (denoted -DR) to match the interactive interface.

Trait inference. From persona profiles, we construct $D_{\text{TI}}=\{(WRA(\{p_{i}^{(j)}\}_{i=1}^{N}),\tau_{j})\}_{j}$, embedding selected traits either explicitly or implicitly into prompts. This mirrors real user behavior, where personal context guides information seeking (e.g., health questions tied to age or history). A persistent adversary linking sessions over time (e.g., by IP) would observe recurring patterns tied to these traits ($\tau_{j}$). Executing such prompts through agents produces labeled traces that reveal stable user attributes, enabling training of trait inference models ($M_{\text{TI}}$). Dataset-specific sampling and generation details are described in Section 6.1.

4.2 Domain Trace Collection

To characterize how different prompts induce distinct browsing behavior, we collect domain-level metadata from agents via Playwright or built-in system logs. For each prompt $p$, this yields a trace $t=\langle(d_{k},u_{k},s_{k})\rangle_{k=1}^{L}$, where $d_{k}$ denotes accessed domain, $u_{k}$ timestamp, and $s_{k}$ payload size. The ordered trace captures whether an agent revisits the same domains or explores the set of sources during a single prompt execution. Although TLS application data does not expose full URLs or domain names directly, domain attribution remains feasible through DNS queries, SNI fields in TLS handshakes, or correlated DNS/HTTPS timing, all of which are observable to ISPs or other on-path entities. This matches realistic adversarial capabilities today, though we note that CDN consolidation or future deployment of DoH/DoT/ECH could reduce visibility.

Noise Filtering.
A passive adversary observes all outbound requests, including primary domains, embedded resources, ads, and trackers. Because much of this traffic is incidental rather than agent-driven, an effective adversary would attempt to filter noise to isolate the domains most indicative of user intent. We apply domain-based noise filtering to remove well-known advertising and tracking services (e.g., doubleclick.net, onetrust.com, taboola.com). This represents the simplest plausible filtering approach and can be implemented using standard blocklists (e.g., EasyList [easylist2025]). More advanced adversaries could employ refined techniques (e.g., traffic classification or resource analysis) to further separate incidental requests from meaningful domains, which we leave to future work.

4.3 Inference Model Construction and Use

The adversary builds an inference model from proxy datasets, then applies it to new traces simulating real-user activity.

For prompt recovery, the task is to reconstruct a natural-language prompt that captures the functional intent of the user’s original input. The adversary constructs an inference model ($M_{\text{PR}}$) from proxy (trace, prompt) pairs in the proxy dataset ($D_{\text{PR}}$), using either ICL, where a small set of examples is included in the inference prompt without parameter updates, or fine-tuning, where the same proxy pairs are used to train a direct mapping from traces to prompts (Table 2). Given a user prompt $p$ producing trace $t=WRA(p)$ (optionally filtered to $\tilde{t}$ per Section 4.2), the resulting model $M_{\text{PR}}$ is then applied to new traces to reconstruct real user prompts $\hat{p}=M_{\text{PR}}(\tilde{t})$.

For trait inference, the goal is to infer latent user attributes ($\hat{\tau}$) from browsing traces ($\tilde{t}^{\,1:N}$). Here, the proxy dataset ($D_{\text{TI}}$) is generated, consisting of proxy (trace, traits) pairs for each annotated persona profile, and the adversary adopts ICL to construct $M_{\text{TI}}$, since it outperformed fine-tuning in the prompt recovery task. For a new user with sessions $\{p_{i}\}_{i=1}^{N}$ and trace $t^{1:N}=WRA(\{p_{i}\}_{i=1}^{N})$, the adversary output $\hat{\tau}=M_{\text{TI}}(\tilde{t}^{\,1:N})$. This enables an adversary to recover persistent attributes such as demographics, ideology, or lifestyle from observed browsing activity.

5 Ontology-aware Behavioral Leakage Score

We introduce OBELS (Ontology-aware Behavioral Leakage Scores), a multi-metric scoring scheme that decomposes leakage into dimensions of preserved functionality, domain targets, and semantic entities, providing a structured alignment with attacker goals and real-world agent behavior.

5.1 Limitations of Existing Metrics

In AI agent contexts, leakage risk stems from functional equivalence: prompt recovery is risky if it leads the agent to similar sites, services, or goals, despite differences in wording. Existing metrics fall short because they assess what prompts say, not what they do.

SBERT score, computed as cosine similarity between sentence embeddings [reimers2019sentence], captures high-level semantic alignment but suffers from paraphrastic inflation. It misleadingly assigns high scores to verbose, generic, or loosely related prompts [steck2024cosine, you2025semantics], overlooking task-specific behavior or intent.

LLM-as-Judge methods leverage LLMs to rate similarity through natural language instructions. While more tolerant to paraphrase and flexible, they are prompt-sensitive and often lack interpretability [razavi2025benchmarking, lee2024one], producing scalar scores without indicating which semantic elements were preserved or lost.

These shortcomings are evident in practice. For example, rephrasing “Compare Italy and Spain’s digital nomad visas” as “How do work visas differ across southern Europe?” yields low cosine similarity, yet the agent navigates to similar government portals and retrieves overlapping content. From a privacy standpoint, this is a successful reconstruction, yet traditional metrics fail to capture it.

5.2 Semantic Triplet Scoring with OBELS

To address these gaps, we propose OBELS, a set of four complementary scores designed to capture behavioral alignment. Rather than collapsing leakage into a single scalar, OBELS decomposes alignment into distinct dimensions so that failures in one area (e.g., entity granularity) are not masked by strong similarity elsewhere. This decomposition yields interpretable diagnostics and aligns more directly with attacker goals and real-world agent behavior. It does so by abstracting prompts into structured triplets:

(intent, source_type, entity)

Here, intent denotes the high-level goal (e.g., learn, explore, analyze, compare, summarize, plan, decide, book, watch, read, evaluate); source_type identifies the class of information or service sought (e.g., travel, symptom, policy_area, event, visa_process, treatment_method, academic_field, cuisine, etc); and entity specifies the core topic (e.g., Rome, Italy, depression, face transplant, immigration, PhD, Business, Swahili dish, etc). Removing any triplet component collapses distinct browsing behaviors, whereas variations in tone or sentiment do not meaningfully alter domain traversal.

We evaluate each reconstruction across four dimensions:

• •

Functional Equivalence ($E_{func}$): Do the two prompts express the same high-level intent or task (e.g., finding a product, booking a service)?

• •

Domain-Type Equivalence ($E_{domain}$): Do they engage with the same category of services or information sources (e.g., travel agencies, health databases)?

• •

Semantic Equivalence ($E_{semantic}$): Are entities semantically aligned (e.g., “side effects of Prozac” vs. “adverse reactions to fluoxetine”)?

• •

Entity Granularity Tolerance ($T_{entity}$): Are differences in specificity (e.g., “Italy” vs. “Rome and Venice”) minor enough to preserve meaning?

Each dimension is scored from 0.0 (unrelated) to 1.0 (fully equivalent) using a standardized evaluation template applied to GPT-4, which compares triplet sets holistically and assigns fine-grained similarity scores.

Different applications may weight these components differently. For instance, entity granularity and semantic precision dominate in high-risk healthcare scenarios; domain-type alignment matters most in regulatory tasks; and intent alignment is sufficient for lower-risk consumer scenarios such as travel planning. Collapsing these dimensions into a single score would obscure such task-sensitive variation and misrepresent leakage risk.

6 Experimental Setup

We evaluate our metadata-based prompt and trait leakage attacks on held-out test prompts. The objective is to assess how well an adversary can reconstruct user prompts that induce the same downstream behavior as the originals, or infer sensitive latent traits from domain traces, thereby capturing both immediate intent leakage and longer-term profiling risks.

6.1 Datasets

We target two scenarios: prompt and trait leakage. Table 1 summarizes all datasets; full details are in Appendix C.1.

Prompt Recovery (TREC). We use three TREC datasets: FedWeb 2013 (50 topics) [trec13-fedweb-topics], Session 2014 (60) [trec14-session-data], and Dynamic Domain 2016 (53) [trec16-domain-data], referred to as FEDWEB13, SESSION14, and DD16. For FEDWEB13 and DD16, we concatenate the <description> and <narrative> fields to match SESSION14’s instruction-style and prompt specificity. To align with OpenAI’s Deep Research API [openai2025introducingdeepresearch], we also generate -DR variants by rewriting each prompt with GPT-4.1, while scoring is always against the original prompts. For each dataset, 20 prompts are reserved for testing, with the remainder used for training and ICL examples.

TREC query text may appear in LLM pre-training corpora, but the domain-level traces we evaluate on are newly collected and do not exist in any pre-training dataset. The attack exploits these fresh behavioral traces, not memorized prompt content.

Trait Inference (PERSONA). We sample 50 profiles from PERSONA_subset [castricato2024persona] (997 total), each annotated with 32 traits. For each, we select 5 traits and use GPT-4o to generate 3–5 prompts across 7 sessions, simulating a week of browsing. Three personas are held out for ICL, and after filtering to ages 18–70, 35 remain for testing.

6.2 WRAs and Backbone LLMs

We evaluate domain-trace leakage in settings where a passive adversary can observe network-level metadata (IPs, domains, timing, payload size). To capture the traces, we use three open-source WRAs and one proprietary API agent (details in Appendix C.2):

GPT Researcher [elovic2023gptresearcher]. An open-source autonomous research agent for deep multi-hop investigation. We run it in deep mode, which produces structured research traces. GPT Researcher strategically uses multiple LLM backbones, and we evaluate both GPT-family and open-source backbones for the prompt recovery task.

Browser-Use [browser_use2024]. An open-source web agent that automates browsing through a local browser. To ensure stable traces, we configure it to start from Bing and require at least five distinct page visits before summarization. Browser-Use is used for the prompt recovery task with GPT-4o as the backbone.

AutoGen [wu2023autogen]. An open-source web agent system we used for both prompt recovery (GPT-4o) and trait inference (Gemini 2.0 Flash), instrumented to log domains and metadata. Unlike the other agents, it produces the real packet-level traces, noisier with ads and trackers.

OpenAI Deep Research API. A proprietary research agent that serves as a commercial baseline. To fully exercise its capabilities, we provide the -DR prompt variant (e.g., SESSION14-DR), designed to approximate the behavior of accessing Deep Research through the ChatGPT interface. While browsing is remote and not locally visible, it serves as a benchmark for high-capability proprietary systems.

Each open-source agent is paired with both open and proprietary LLM backbones to reflect realistic local deployments. OpenAI Deep Research API serves as a proprietary baseline. Larger local LLMs (e.g., LLaMA 3.1 70B, DeepSeek-R1) are excluded because they require substantial resources and often bypass web search by relying on internal knowledge.

6.3 Evaluation Metrics

Metrics for Prompt Recovery. We evaluate prompt recovery performance using three metrics: (1) SBERT, computed as cosine similarity over mean-pooled Sentence-BERT embeddings [reimers2019sentence]; (2) LLM-as-Judge , where an LLM rates prompt similarity based on natural language instructions; and (3) OBELS, our proposed behavior-aware scoring scheme to capture functional equivalence (i.e., whether the reconstructed prompt would induce similar agent behavior).

Metrics for Trait Inference. For trait inference, we adopt a type-aware scoring strategy tailored to each trait’s structure:

• •

Numeric traits are evaluated using a normalized absolute difference: smaller relative errors yield higher scores, linearly decreasing toward zero.

• •

Ordinal traits are mapped to integer levels and scored by normalized distance on a 5-point scale. Closer ratings yield higher similarity scores.

• •

Categorical traits use exact match for single-token values; multi-word categories are scored using SBERT to account for semantic equivalence.

• •

Free-text traits are assessed using SBERT, which computes semantic overlap via contextual token embeddings.

This trait-type–aware evaluation avoids penalizing structured attributes with embedding-based metrics and ensures robust semantic assessment for open-ended descriptions. In contrast to prompt recovery, trait inference does not require alignment in downstream behavior; semantic similarity alone suffices to assess privacy leakage.

7 Attack Results

7.1 Prompt Recovery

Attack success is measured not by textual similarity alone, but by semantic and downstream behavior similarity, whether reconstructed prompts preserve the functional intent behind the original (see Section 6.3). The results quantify how much information about a user’s input is revealed through observable browsing activity, and how the leakage rate varies across learning strategies, datasets, agents, and agents’ LLM backbones. GPT-4o is used as the inference LLM unless stated otherwise. Appendix C.3 details the ICL setup, and additional results are reported in Appendix D.

WRA vs. Human Attribution Analysis. To assess whether WRA traffic is distinguishable from human browsing, we clustered agent traces together with human sessions from SESSION14 using only timing, burstiness, and domain-transition features. WRAs consistently remain highly separable with 0.86–1.0 cluster purity across topics and 97.9% global classification accuracy. WRAs thus form a distinct, easily identifiable behavioral mode, exposing a richer and more attributable metadata footprint than humans.

ICL vs. Fine-Tuning Across Models. To motivate our choice of ICL over fine-tuning as the primary task-specific approach, we compare their performance across closed-source models (GPT-4o and GPT-4.1 nano) and open-source models (Llama 3.1 8B, Gemma 3 4B, and Qwen 2.5 32B) (Table 2). We create our final training set by combining the training samples from the prompt recovery datasets discussed in Section 6.1. For closed-source models, fine-tuning is performed through OpenAI’s fine-tuning API [openaiFinetuningAvailable] for 3 epochs with batch size 1. For open-source models, we apply LoRA [hu2022lora] with rank 16 and $\alpha=12$. Results show that ICL generally outperforms fine-tuning across nearly all metrics, though models like Llama occasionally favor fine-tuning for functional and domain equivalence. We attribute this to limited sample diversity, which likely causes overfitting in fine-tuned models.

Impact of Example Count. Table 3 compares performance across different numbers of in-context examples. 5-shot ICL provides a balanced trade-off between functional equivalence, domain alignment, and semantic similarity, while avoiding the performance drop observed at smaller or greater counts.

Impact of Agents. As described in Sections 6.1 and 6.2, we collect traces from GPT-Researcher, AutoGen, and Browser-Use (20 prompts, 5-shot ICL) and from Deep Research (5 prompts, 3-shot) using SESSION14 prompts. Table 4 shows that GPT-Researcher traces leak the most, consistent with its broader domain coverage and richer source diversity. Deep Research exhibits comparable leakage despite fewer prompts and shots, while AutoGen and Browser-Use generate learner traces that result in weaker leakage. These differences highlight how agent design and exploration strategy directly shape the degree of leakage.

Impact of Agent Backbone: Proprietary vs. Open-Source. Using GPT-Researcher, we evaluated traces across datasets with either GPT-4 or local open-source backbones (DeepSeek-V3, Mistral family). As shown in Table 5, GPT-4 traces yield higher recovery scores, reflecting stronger reasoning capacity and broader exploration. Local models leak less overall, but still provide exploitable cues. For the remainder of our ICL experiments, we use GPT-Researcher with a GPT-4 backbone on SESSION14, as this setup offers both representativeness and clearer leakage signals for analysis.

Impact of Inference LLM. Table 6 compares inference engines for ICL-based prompt recovery, showing that model choice strongly affects reconstruction quality. Claude-opus-4-1 and Gemini-2.5-pro achieve the highest scores, while GPT-5, GPT-5-mini, and GPT-4o remain competitive. Larger models leak more information but incur higher cost and latency, especially in the Gemini, Claude, and GPT-5 families. Balancing accuracy, cost, and latency, we identify GPT-4o as the most practical option, offering strong recovery performance with lower overhead than top-scoring but slower systems.

7.2 Trait Inference

We assess how much and accurately an adversary can recover latent attributes of the user from a week-long browsing trace (see Section 6.3). The results quantify trait exposure using inference accuracy (similarity score), where higher values mean more reliable adversarial inference. Gemini 2.5 pro is used as the inference LLM.

Figure 4 ranks the fifteen most exposed traits, showing that exposure varies by attribute. Health insurance (0.98), veteran status (0.90), employment status (0.88), and household language (0.86) are inferred with near-perfect accuracy, with employment status nearly as reliable as binary traits despite being multi-class. A second tier (marital status, sex, race, religion, household type) scores 0.73–0.77, while political views, citizenship, education, family presence/age, place of birth, and income range from 0.66–0.70, still well above random. Behavioral and psychographic traits do not appear in the top 15, consistent with their lower exposure in Figure 6. Overall, the results suggest that demographic and occupational traits are most vulnerable to leakage, while lifestyle and personality attributes remain less exposed but at nontrivial levels.

Figure 5 compares similarity scores for selected and unselected traits. Selected traits typically exceed 0.7, with some personas (012, 024, 037, 045) surpassing 0.8, indicating consistent high-risk leakage [cann2025using]. Unselected traits generally fall below but often remain above 0.5, showing moderate exposure even when traits are not explicitly embedded. In a few cases (007, 025, 041), unselected traits approach or exceed selected ones, confirming leakage extends beyond explicitly mentioned attributes.

Figure 6 compares model confidence and accuracy across categories. As shown in the left plot, occupational and demographic traits are assigned very high confidence (0.8–1.0), while the other two peak in the mid-confidence range (0.6–0.8). The accuracy distributions (right plot) further distinguish the categories: occupational traits average 0.70 but with a lower median (0.53), psychographic traits are inferred with moderate accuracy (mean 0.56, median 0.46) but show extreme variability (spread 0–1). Behavioral traits are uniformly moderate to weak (mean 0.46, median 0.45) with a narrowest spread of 0.25 to 0.61, and demographic traits show the highest median (0.90), but occasional errors lower the mean (0.44). Trait categories differ not only in accuracy but also in distribution: demographic traits are most reliably inferred, occupational traits are less consistent but often highly accurate, psychographic traits are highly variable, and behavioral traits are the least exposed.

Different Number of Sessions. As part of our ablation study, Figure 7 shows the distribution of traits per persona with similarity scores above 0.7 under three vs. seven sessions. With three sessions (yellow), most personas reveal 6–10 traits with a long tail of higher counts. With seven sessions (purple), the distribution shifts rightward and concentrates around 12–14 traits, with some reaching 19. This demonstrates that additional sessions, and thus more domain traces, enable inference of more traits at high accuracy.

Table 7 confirms consistent gains across categories, with psychographic (+16.7%) and demographic (+15.4%) improving most, followed by behavioral (+12.2%) and occupational (+7.4%) traits. Overall, longer observation windows strengthen inference, increasing both the number of high-similarity traits and average accuracy.

Overall, our results show that metadata leakage enables both immediate and long-term risks. First, prompts can be reliably recovered regardless of whether traces are produced by proprietary or local LLM backbones, or by agents with varying exploration strategies. For trait inference, exposure levels differ across categories, but even traits not explicitly embedded in prompts can still be inferred at moderate to high accuracy, as shown by the recovery of unselected traits. Together, these findings demonstrate that domain traces alone reveal sensitive user intent and identity signals, underscoring metadata leakage as a significant privacy threat.

8 Defense and Realistic Deployment

Motivation.

If a task requires visiting a unique domain, the defense should hide that interaction via VPNs or randomized background queries. By contrast, if the information can be obtained without distinctive traces, blocking is preferable; for example, by querying an LLM directly or gathering information from Wikipedia. We thus identify two conceptual mitigations for metadata-based inference attacks: (1) hiding traces, where sensitive activity must occur but is camouflaged with plausible noise; and (2) blocking traces, where the activity is avoided by relying on alternative, less revealing sources.

8.1 Hiding via Decoy Prompts

Inspired by TrackMeNot [nissenbaum2009trackmenot], for each real prompt the system generates and executes additional decoy prompts that remain within the same topical space but differ in framing, intent, or implied traits. Because OBELS evaluates whether reconstructions preserve intent, domain type, and entity, breaking this alignment is critical; otherwise, an adversary can still recover the user’s functional behavior despite wording changes. For instance, a prompt about “recognizing depression and seeking medical help for a friend” can be paired with a decoy like “compare the effectiveness of yoga versus meditation for improving sleep quality”, which shifts both domain and entity, lowering OBELS score and obscuring the true goal. This ambiguity in observed traffic undermines an adversary’s ability to infer the user’s true objective, attributes, or target entity. We explore a lightweight approach using LLM-based decoy generation and a trait-aware variant that leverages virtual personas to introduce long-term behavioral divergence.

Mechanism. The defense operates in three stages. (1) Decoy prompt generation: an LLM produces multiple decoys that remain within the same topical space but differ in context, intent, or entity granularity, thereby obscuring both high-level intent and fine-grained attributes such as geographic focus or institutional target (e.g., a prompt on “Swahili food” may be paired with decoys on “Italian cuisine” or “modern American dishes”). (2) Trait-conflicting guidance (optional): decoy generation can be steered by a virtual persona, with the system maintaining a rolling estimate of the user’s traits via lightweight keyword heuristics and selecting a persona that diverges on key dimensions (e.g., ideology or religion). These divergent decoys introduce consistent but misleading patterns, weakening long-term profiling. (3) Concurrent execution: real and decoy prompts are issued in parallel; while only the real output is returned to the user, all queries leave observable traces, blending plausible yet misleading activity into the traffic and complicating adversarial inference of the user’s true intent or identity.

Impact of Defense on Prompt Leakage Attack. Table 8 summarizes the prompt recovery performance under defense applied. The defense injects a varying number of decoy prompts, each contributing its own set of visited domains, so that the agent runs for both the original and decoy prompts simultaneously. Original domains are randomly interleaved within these sets while preserving their internal order, as shown in rows 2–4 of the table. To model a stronger defender, we also consider a condition where all domains, both original and decoy, are fully shuffled (rows 5–7).

The results show a consistent reduction in inference accuracy once decoys are added. With only one decoy prompt, SBERT drops by 0.10 and LLM-Judge by 0.23 relative to the baseline. More decoys generally strengthen the defense, with the largest effect observed at five decoys. When domains are shuffled, attack performance recovers somewhat for semantic and domain-level metrics, but still remains below baseline.

Impact of Defense on Trait Inference. We evaluate the defense by re-running the trait inference attack with decoy prompts injected. In this setting, each real prompt triggers a concurrent decoy prompt from a conflicting virtual persona, selected based on the defender-side trait estimate. Table 9 reports median similarity scores between inferred and ground-truth traits across four categories. The defense yields the largest median reduction for occupational traits ($-24.3\%$), followed by demographic traits ($-8.1\%$). Psychographic traits drop slightly ($-4.2\%$), while behavioral traits remain unchanged. Additional results are provided in Appendix E.

8.2 Blocking via Alternative Sources

A complementary defense is to prevent sensitive traces from arising in the first place. When a user’s objective can be met without contacting uniquely identifying domains, the agent can instead draw from large multipurpose repositories (e.g., Wikipedia, StackExchange, Reddit) or from the LLM’s internal knowledge. By retrieving information from resources that serve diverse intents or by leveraging the model’s internal knowledge, the resulting traffic no longer maps cleanly to a specific user goal.

From the adversary’s perspective, this strategy effectively reduces visibility by collapsing domain diversity, yielding traces similar to those observed by weaker observers that see limited or non-discriminative domain information. This “blocking” approach therefore both mitigates leakage and illustrates how reduced observability weakens inference, reducing the adversary’s ability to associate domain visits with private attributes.

Table 10 and Table 11 together show that visibility of browsing traces strongly shapes leakage but has little effect on utility. Utility is how much the WRA’s output helps a human reader reach their research goals. We measure it with an LLM using the prompt template. URL-level traces leak substantially more than domain-only traces, making prompt inference easier and more accurate. Reducing visibility (e.g., observing only 80% or 60% of domains) lowers leakage but still exposes useful information. Adding timing metadata to domains yields no consistent gains, suggesting that domain identity is more informative than temporal order. In contrast, the utility of the generated reports remains relatively stable across visibility levels down to 10%. However, beyond this threshold, utility begins to drop, revealing diminishing returns from additional domain coverage. This suggests that many extra domains contribute little to report quality while disproportionately increasing exposure to adversaries. Thus, WRA behaviors that aggressively visit many domains are especially problematic: they create substantial leakage risks while providing only marginal gains in utility.

9 Discussion and Conclusion

Privacy and Security Implications. Our results show that metadata leakage is an inherent risk for locally deployed web and research agents. We find that design choices—including domain exploration breadth, backbone model capacity, and orchestration logic—directly affect the amount of information exposed. Substituting locally deployable models does not eliminate leakage: domain-level traffic is structurally unavoidable. This shifts the attack vector from content to behavior. Whereas prompt injection and data exfiltration could be mitigated through isolation [tsai2025contextual], network-level traces cannot be trivially suppressed. At scale, such leakage enables profiling by advertisers, ISPs, or state actors, raising unique questions about how to balance agent utility with user privacy.

Defense Effectiveness and Limitations. Our study has several limitations. We rely on proxy datasets and synthetic personas with limited session counts; longer-term aggregation or multimodal attacks may amplify risks. Defense evaluation is confined to decoys and blocking, and cost/latency trade-offs are only partially measured. Nonetheless, our results show that decoy prompts and trait-conflicting personas reduce both prompt recovery and trait inference accuracy, while blocking strategies help when tasks can rely on broad, non-unique sources (e.g., Wikipedia) without sacrificing utility. Yet defenses remain partial: adversaries still recover useful signals, and decoys introduce overhead in latency, bandwidth, and behavioral realism. As with prior obfuscation systems, mitigation is meaningful but incomplete; full network-level protections (e.g., VPNs or anonymity systems for agents [pham2024proxygpt]) remain the only robust safeguard.

Future Directions and Open Challenges. Future work should explore hybrid defenses that combine obfuscation, blocking, and timing perturbations; study long-term aggregation attacks across extended user histories; and integrate formal privacy guarantees such as differential privacy or traffic-analysis resistance directly into agent design. Multi-modal agents introduce additional risks, for example, as passed multi-modal content could reveal even more information [schuster2017beauty]. Overall, progress requires viewing AI agents and the web as a coupled ecosystem rather than orthogonal components.

Conclusion. We show prompt and trait leakage from network traces of local WRAs. Even with defenses, residual exposure persists because traces are structurally generated and behaviorally rich. Our study demonstrates both the feasibility of inference attacks and the incompleteness of current defenses, underscoring the need for systemic, privacy-aware agent design. Until such frameworks are developed, strong network-level protections remain the only reliable safeguard.

Acknowledgments

The work was partially supported by Schmidt Sciences SAFE-AI program and by the NSF grants 2333965 and 2131910.

Appendix A Ethical Considerations

Our research examines how WRAs can inadvertently leak sensitive information through metadata such as domain access patterns, timing, and interaction traces. While our goal is to strengthen privacy protections for agent-based systems, we recognize the potential for harmful use if such inference techniques were deployed maliciously.

Stakeholders. We identify four stakeholder groups affected by this research: (1) End-users of WRAs, who may have personal traits, goals, or intentions inferred without their awareness. This risk is not uniform; individuals in politically sensitive contexts, marginalized communities, or high-surveillance environments may face disproportionately higher harm. (2) Developers and framework maintainers, who may need to modify or harden system architectures, logging defaults, and data retention practices in response to identified risks. (3) Organizations deploying agents (e.g., educational platforms, customer service systems), which may unknowingly violate privacy expectations or regulatory obligations if leakage is not addressed. (4) The broader public, which has a collective interest in ensuring that emerging agent ecosystems evolve in privacy-preserving and autonomy-respecting directions.

Mitigating Potential Harm. To reduce risks to end-users, we designed our study so that no real user data were collected or analyzed; all experiments use public benchmark datasets (FEDWEB13, SESSION14, DD16) and synthetic personas, ensuring that no identifiable individuals can be profiled or re-identified. To support developers and framework maintainers, we present concrete mitigation strategies, such as trace obfuscation and domain suppression, that can be incorporated into WRA architectures to reduce metadata leakage. For organizations that deploy agents in educational, corporate, or customer-service environments, we do not release any tools for live traffic monitoring, and the accompanying code is limited to offline, dataset-based replay experiments, preventing misuse in operational settings. Finally, by identifying these risks early and providing actionable defenses, the work serves broader public interests by promoting privacy-preserving WRA design, rather than end-user surveillance or behavioral profiling as agents become widely deployed.

Researcher Well-being and Responsibilities. Our research did not involve direct interaction with online communities, covert participation, or exposure to disturbing or sensitive content. However, we continuously discussed the dual-use concerns throughout the project and made design choices aimed at minimizing the potential for misuse, for example, limiting our evaluation to public datasets and not designing tools that can be directly applied to live user traffic.

Societal Impact and Justification. As WRAs become integrated into productivity tools, classrooms, workplaces, and personal browsing workflows, metadata-based inference risks could scale rapidly and invisibly. By identifying and characterizing this attack vector under controlled conditions, we enable developers, regulators, and practitioners to recognize and address these vulnerabilities early, before they are exploited in real-world deployments. By focusing on public data, transparent methodology, and concrete mitigation guidance, we ensure that the research advances privacy-preserving agent design while minimizing the likelihood of harmful use.

Appendix B Open Science

Implementations, evaluation code, prompts, and the synthetic datasets derived from our study will be made publicly available. Code and prompts available at: https://github.com/umass-aisec/wra.