A model cascade saves money by answering easy questions with a small, cheap model on the user's device and sending only hard questions to a large model in the cloud. Every privacy method proposed for cascades so far protects the content of what gets sent: it masks names, rewrites the prompt, or keeps sensitive queries local. This proposal argues that the act of sending also leaks. Suppose someone passively listens to the wireless link, the kind of silent eavesdropper that physical-layer security usually assumes. Even if every packet is encrypted, that listener sees whether a query left the device, when, and how large it was. Cascades decide to escalate based on difficulty, topic, and, in privacy-aware designs, on whether the query is sensitive. The on/off transmission pattern is therefore a readable signal about what the user is asking.
We propose to measure this leak and then close it. We measure it by training eavesdropper classifiers on encrypted escalation traces from real cascades running on standard benchmarks. We close it with a deferral rule that adds a small, calibrated number of decoy transmissions and pads packet sizes into buckets, so that the probability of transmitting is nearly the same whatever the sensitive attribute of the query. The result is a leakage–cost frontier. At one end sits the naive cascade (cheap, leaky); at the other sits "always transmit something" (no leakage, expensive in energy and latency). The research question is how much of the cascade's savings survive when leakage is bounded.
Core Claim
Three things are claimed, each testable. First, a passive eavesdropper who sees only encrypted uplink metadata can predict query attributes from cascade escalation traces well above chance. Such attributes include subject area, whether the query came from a clinical or email workload, and whether it contains private entities. Second, privacy-aware deferral makes this worse, not better. Privacy-preserved LLM Cascade via CoT-enhanced Policy Learning (P³Defer) trains a reinforcement-learning deferral agent that keeps private queries local and masks private tokens in the ones it sends. By design, that agent correlates "no transmission" with "this query was private," which turns its content protection into a metadata leak. Third, a parity-constrained decoy policy recovers most of a cascade's cost savings under a bounded leakage budget, and does so more cheaply than full constant-rate cover traffic.
The guarantee we target is simple. Let $T \in \{0,1\}$ indicate whether a transmission is observed for a query, and let $a$ range over values of a sensitive attribute. We require
$$\frac{P(T=1 \mid a)}{P(T=1 \mid a')} \le e^{\varepsilon} \quad \text{for all } a, a',$$
where $\varepsilon$ is a user-chosen leakage budget. A real escalation always transmits. A local answer transmits a decoy with probability $q_a$, and we set $q_a$ just high enough to lift every attribute's transmission rate to within $e^{\varepsilon}$ of the highest one. Across $n$ queries from the same user, the budget grows with $n$, just as repeated observations compose. Part of the work is quantifying how fast a user's attributes become identifiable from long traces, and whether per-session decoy scheduling slows that.
Threat Model and Relation to Prior Work
Our adversary is the classical passive eavesdropper of physical-layer security: silent, non-colluding, and unable to decrypt. Most of that literature spends the passive assumption on shrinking the eavesdropper's signal. One example is A robust artificial noise aided transmit design for MISO secrecy, which injects noise into the null space of the legitimate channel and reports roughly 1.5 bps/Hz secrecy gain over non-robust noise. Another is Resource Allocation and Secure Wireless Communication in the Large Model-based Mobile Edge Computing System, which keeps the secrecy rate positive while uploading fine-tuned adapters and reports about 44% energy and 37% latency savings. Both works motivate our setting, since both treat the edge-to-cloud model link as an eavesdropping surface. Neither studies per-query inference deferral, and neither considers that the timing of transmission reveals anything. We deliberately take the weakest adversary. If even a passive listener behind encryption learns query attributes, stronger adversaries only make things worse. Those stronger adversaries include the proactive jammer of Proactive Eavesdropping via Cognitive Jamming in Fading Channels and the representation-inverting attacker of The Model Inversion Eavesdropping Attack in Semantic Communication Systems.
On the cascade side, content-privacy work motivates our problem and also serves as its foil. Can LLMs get help from other LLMs without revealing private information? replaces raw prompts with synthetic analogous problems and grouping, cutting entity leakage to 0.1–0.2%. It still warns that structure-based "mapping leaks" remain. Its adversary is the curious server, not a network observer, and its grouping of queries is incidentally a partial traffic defense we will test. P³Defer, as noted, conditions deferral on privacy risk. The metadata observation that grounds our claim comes from traffic-security work: Provably Secure Steganography models a passive warden who inspects statistical properties of traffic rather than payloads.
The cost machinery we reuse comes from the cascading literature. RouteLLM: Learning to Route LLMs from Preference Data supplies learned routers. Gatekeeper: Improving Model Cascades Through Confidence Tuning supplies confidence-tuned small models. C3PO: Optimized Large Language Model Cascades with Probabilistic Cost Constraints for Reasoning supplies threshold calibration from under 100 unlabeled prompts with high-probability cost guarantees. We borrow C3PO's calibration style to set decoy rates so that the parity bound and a cost budget hold together with high probability on held-out prompts. None of these routers models the link as observable.
Research Program
The first stage is measurement. We run several cascades on mixed workloads, recording for each query the escalation decision, the time of transmission relative to query arrival, uplink and downlink byte counts after standard encryption, and response latency. The cascades are Llama-3-8B paired with Llama-3-70B, routed by RouteLLM's matrix-factorization router, a Gatekeeper-tuned confidence threshold, C3PO thresholds, and a reimplementation of P³Defer. The link is simulated as a fading wireless uplink, so that timing reflects both channel conditions and the delay of small-model inference before a decision. The eavesdropper is a family of classifiers trained on these traces to predict a held-out attribute, at three levels. The first is per query: from one trace, which subject or workload is this? The second is per session: from a window of $n$ traces, which user profile is this? The third is sensitivity: did this query contain private entities? We report attacker AUC and accuracy against the attribute's base rate. We ablate the observables (escalation bit only; plus size; plus timing) to see which channel carries the leak.
The second stage is the defense. It has three parts. The first is parity-constrained decoys, in which local answers trigger a fixed-format encrypted decoy with probability $q_a$, set as above. The server discards decoys cheaply, so they cost uplink energy and bandwidth but no large-model compute. The second is size bucketing, which pads uplink and downlink payloads to a few fixed sizes. The third is latency shaping, which optionally delays a fraction of local answers so their response-timing distribution overlaps with cloud answers. The sensitive attribute is not known at run time. The device therefore uses the small model's own prediction of it, and we measure how much the guarantee degrades when that prediction is wrong. All three parts expose a single budget $\varepsilon$, and we trace the accuracy/cost/energy/latency frontier as $\varepsilon$ varies.
The third stage is analysis. We relate the achievable frontier to how strongly each router's escalation rate varies across attributes. Our hypothesis is that decoy cost scales with the gap between the highest and lowest attribute-conditional escalation rates, because the decoy rate must lift every attribute to the maximum. This suggests a second lever: train routers whose escalation rates are more uniform across attributes to begin with. We test this with a parity penalty added to the RouteLLM matrix-factorization objective.
Baselines
The naive reference point is the unprotected cascade with encrypted payloads. It is RouteLLM's matrix-factorization router over the Llama-3-8B/70B pair, whose paper reports 50% performance-gap recovery on MT-Bench while calling the strong model on about 13% of queries. This baseline defines the cost savings we are trying to keep and the leakage we are trying to remove. The same router, data, and calibration prompts are used across all conditions, so the only change is the transmission policy.
The strongest cost-efficiency competitor is C3PO. It reports 62.5% accuracy at $0.0019 per question on MATH-500, against 57% at $0.0053 for self-consistency with the most powerful model, and it stays under budget in 299 of 300 runs. We run it with its published under-100-prompt calibration and add our decoys on top. Beating it means matching its accuracy within one point at a stated $\varepsilon$ while keeping total cost, now including decoy energy, below the always-large-model cost.
The strongest privacy competitor is P³Defer. It reports a 92.61% safe call rate on GSM8K, private-token leakage reduced by 75.35% (GSM8K), 68.64% (MedSum), and 74.81% (EmailSum), and accuracy gains over the server model of 3.11%, 2.72%, and 4.70% on those datasets. We reimplement it on the same model pair and budget. We report its content-leakage numbers alongside our metadata-attacker AUC for the sensitivity attribute. Our prediction is that it scores well on content and badly on metadata. Our method, applied to P³Defer's decisions, should keep its content numbers while pushing sensitivity-attack AUC toward 0.5. The social-learning grouping of Can LLMs get help from other LLMs without revealing private information? is included as an existing batching-style defense.
The zero-leakage endpoint is full constant-rate cover traffic. Every query produces a fixed-size exchange, and every answer is delayed to cloud latency. Our method must dominate it on energy and median latency at a meaningfully small $\varepsilon$. If it cannot, the contribution collapses to the measurement.
Two ablations isolate the key ingredient. The first uses uniform random decoys at the same total rate, without attribute-conditioning, which tests whether parity targeting matters or whether any decoy noise suffices. The second uses size bucketing alone, without decoys, which tests whether the binary escalation bit or the payload size carries the leak.
Why not just…?
Why not just encrypt the uplink with TLS? We assume it is encrypted. Encryption hides payloads but not the existence, timing, or size of transmissions, which is exactly the passive-warden observation of Provably Secure Steganography. The measurement stage tests this directly by giving the attacker only encrypted-trace features. If attacker AUC is near 0.5 on every attribute, our premise is false and we will say so.
Why not just always send a padded packet for every query? This is the real threat, because it gives zero leakage from the escalation bit at no large-model cost. Its price is that every query pays uplink energy. It must also delay local answers to cloud timing, since otherwise response latency still reveals which answers were local, and that delay erases the latency benefit that motivates on-device inference. We include it as a baseline rather than argue it away. The decisive comparison is whether parity-targeted decoys reach, say, $\varepsilon \le 0.5$ at a fraction of its energy and latency cost. If they do not, then constant cover traffic is the correct answer and our paper becomes a measurement plus that recommendation.
Why not just run everything locally? Then nothing is transmitted and nothing leaks, but accuracy falls. C3PO's MATH-500 cascade reaches 62.5%, and RouteLLM shows the weak model alone forfeits much of the strong model's quality. We report local-only accuracy on every benchmark as the floor, so readers can see what leakage-free-by-abstention costs.
Why not just randomize the deferral threshold? Random thresholds add noise to the escalation bit but do not equalize rates across attributes. A clinical-heavy user still escalates more on average, and that shows up in long traces. The uniform-random-decoy ablation is the fair version of this idea, and the session-level attack is where we expect it to fail.
Proposed Experiments and Decisive Checks
Workloads are built by mixing GSM8K, MedSum, and EmailSum (workload identity as the attribute), MMLU subjects grouped into medical, legal, and other (topic attribute), MT-Bench categories, and P³Defer-style private-entity annotations on MedSum and EmailSum (sensitivity attribute). Cost uses a per-token API price plus a per-bit uplink energy model for the simulated fading channel. Metrics are task accuracy (or summarization quality where applicable), total cost, device energy, median and p95 latency, and attacker AUC per attribute at the query and session levels.
Three results decide the proposal. The first is the existence check. On the unprotected RouteLLM and P³Defer cascades, a trace-only attacker must beat base rate clearly on at least one attribute. We expect P³Defer to leak sensitivity more than RouteLLM, and if it does not, the second claim is false. The second is the frontier check. At a fixed $\varepsilon$, parity decoys must keep accuracy within a point of the unprotected cascade while costing less energy and latency than constant cover traffic, and they must beat uniform-random decoys at equal decoy rate on session-level attack AUC. The third is the robustness check. The parity bound, calibrated on under 100 unlabeled prompts in C3PO's style, must hold on held-out prompts. It must also hold when the device's predicted attribute is wrong, which we test by degrading the attribute predictor. As a last stress test, we give the eavesdropper the ability to induce retransmissions by jamming, in the manner of the proactive monitor of Proactive Eavesdropping via Cognitive Jamming in Fading Channels. We then check whether retransmission patterns reopen the leak that decoys closed. This marks where the passive assumption, which our guarantee depends on, stops protecting the user.
References
- Privacy-preserved LLM Cascade via CoT-enhanced Policy Learning
- A robust artificial noise aided transmit design for MISO secrecy
- Resource Allocation and Secure Wireless Communication in the Large Model-based Mobile Edge Computing System
- Proactive Eavesdropping via Cognitive Jamming in Fading Channels
- The Model Inversion Eavesdropping Attack in Semantic Communication Systems
- Can LLMs get help from other LLMs without revealing private information?
- Provably Secure Steganography
- RouteLLM: Learning to Route LLMs from Preference Data
- Gatekeeper: Improving Model Cascades Through Confidence Tuning
- C3PO: Optimized Large Language Model Cascades with Probabilistic Cost Constraints for Reasoning