Skip to content

PolicySniff: inferring an agent's policy state through shared GPU execution

PolicySniff: Inferring Agent Policy States through Shared-GPU Execution

arXiv: 其他 AI 安全论文· arXiv:2611.16158· Weimin Fu, Minghao Shao, Zeng Wang, Qiying Li, Yuntao Liu, Johann Knechtel, Ozgur Sinanoglu, Muhammad Shafique, Ramesh Karri, Xiaolong GuoLehigh University; New York University; New York University Abu DhabiIndexed by this site · 6 days ago· Originally publishedAttacks

Quick read

Attacks

Based on the paper PDF (AI-generated); refer to the original

The authors propose PolicySniff: adjacent processes sharing a GPU infer the approval policy state of an LLM agent solely from their own kernel timing, with a frozen-coverage study achieving 94.17% balanced accuracy.

Threat modelThe attacker is an adjacent process sharing the same GPU (full card or the same MIG instance) as the victim agent: it knows the candidate approval rules and the task identity, request order, and grouping, can profile both states on the shared GPU itself, and times only its own kernels with CUDA events; it does not read the victim's prompts, responses, tool results, memory, or routing tensors, does not send requests to the service, and does not share software caches.

Questions
An LLM agent's approval policy (whether to ask for confirmation first) is written in the system prompt and kept confidential, but the authors ask whether an adjacent process on a shared GPU can infer which rule is currently deployed from physical execution traces alone.
Methods
PolicySniff has an attack process co-resident with the victim agent on the same GPU/MIG instance; knowing the task and candidate rules, it first profiles both states itself, then, while the victim processes tasks, times only its own kernels with CUDA events and decides the policy by the closest reference mean; separately, it replays routing summaries through FPGA and cross-MIG power for mechanism analysis.
Experiments and results
On an eager sparse MoE runtime, the frozen coverage study reaches 94.17% balanced accuracy for the primary estimator (unapproved condition); 88.82% on tasks where the two policies produce the same output; blind NF4 activity 97.92%. The authors state that the temporal density and layer-bucket alignment of routing carry the policy information, and that moving the rule to a trusted broker outside inference can suppress the evaluated classifier to 37.50%.
Limitations and future work
The authors state that the results cover a single sparse MoE model, known candidate rules, exact task profiling, and the attacker's knowledge of request order and grouping; probing is intrusive (continuous probing slows the victim's median latency by 4.71×); the combined effect of policy identification and subsequent injection was not jointly evaluated; the decode path of the fused Marlin kernel did not exhibit the same signal.
Experimental setupQwen3-30B-A3B-Instruct-2507、gpt-oss-120b · 合成动作选择任务(filesystem、outbound-information、production-infrastructure 等六类操作族)、合成软件工程仓库实例(fixture repair、build recovery、workspace-lease management) · balanced accuracy、coverage et al.
Evaluated models
Qwen3-30B-A3B-Instruct-2507gpt-oss-120b
Benchmarks
合成动作选择任务(filesystem、outbound-information、production-infrastructure 等六类操作族)合成软件工程仓库实例(fixture repair、build recovery、workspace-lease management)
Metrics
balanced accuracycoveragevictim latency slowdown
AI summaryResearchers propose the PolicySniff attack, which infers an agent's approval policy state by executing on a shared GPU; on an eager sparse MoE runtime with selected experts running independently, a frozen and blinded study identified the deployed setting with 94.17% balanced accuracy. LLM agents set approval policies via the system prompt, and operators keep them secret by restricting access to the prompt and responses, while existing audits only check whether the agent complies with the setting, not whether an adjacent process can infer the setting. The attacker first models the two candidate settings separately, then measures only the timing of its own GPU kernels while the agent processes tasks; because the policy prefix is already cached, what the attacker observes is the same task-suffix processing under both settings. In tests covering all authorization conditions, accuracy was 88.82% on tasks where the two settings make the same decision and 91.98% on tasks where the decisions differ; hardware replay of expert routing shows that timing density and layer-to-bucket alignment carry policy information.

Researchers propose the PolicySniff attack, which infers an agent's approval policy state by executing on a shared GPU; on an eager sparse MoE runtime with selected experts running independently, a frozen and blinded study identified the deployed setting with 94.17% balanced accuracy. LLM agents set approval policies via the system prompt, and operators keep them secret by restricting access to the prompt and responses, while existing audits only check whether the agent complies with the setting, not whether an adjacent process can infer the setting. The attacker first models the two candidate settings separately, then measures only the timing of its own GPU kernels while the agent processes tasks; because the policy prefix is already cached, what the attacker observes is the same task-suffix processing under both settings. In tests covering all authorization conditions, accuracy was 88.82% on tasks where the two settings make the same decision and 91.98% on tasks where the decisions differ; hardware replay of expert routing shows that timing density and layer-to-bucket alignment carry policy information.

Related events and news

1 events · 2 news mentions

News that mentions this paper

共享GPU侧信道可推断智能体审批策略

Paper analysis

6 questions; open one to read the full answer

  1. What problem does this paper attempt to solve?

    Author study: whether adjacent processes sharing a GPU can infer which approval rule an agent deployed when the prompt and response are kept confidential.

    Core question: when an agent's approval policy (whether to ask for confirmation before a sensitive operation) is kept confidential as part of the system prompt, can an adjacent process co-resident on the same GPU infer which candidate rule is currently active from physical execution observations alone.

    • Scenario and motivation: LLM agents implement approval settings through instructions in the system prompt, and operators keep these settings confidential by restricting access to prompts and responses. The authors argue that knowing which deployments allow the model to execute directly without confirmation can guide target selection for subsequent jailbreak or prompt injection attacks.
    • Shortcomings of existing audits: the authors point out that existing behavioral audits check whether an agent complies with its settings, not whether an adjacent process can infer which setting is deployed; behavioral compliance is not configuration confidentiality.
    • Core observation: in an eager sparse MoE runtime, each task token attends to the cached policy prefix, and its hidden state affects expert routing; the eager implementation schedules each selected expert as independent work, so routing affects execution time and is thus observable by a co-resident process's time-sliced probing.
    • The paper proposes: PolicySniff—a response-free native GPU timing attack, plus routing-replay mechanism experiments and a policy-placement comparison that moves the rule to a trusted broker.
    • Threat model (Section 3.2, four capabilities of native attacker A):
      • Goal: estimate the binary secret S, i.e., which of two known candidate approval rules is deployed, without reconstructing the prompt text.
      • Knowledge: C2 base model and candidate rule implementations (can profile on the shared GPU itself); C3 task identity, request order, and repetition grouping.
      • Capabilities: C1 an independent CUDA context sharing the victim GPU's execution resources, timing its own kernels with CUDA events, with no performance counters, profiler, or NVML telemetry; C4 offline analysis of its own complete timing stream.
      • Victim system and boundary: an agent running on a full A100 or a single MIG instance; the attacker does not read the victim's prompts, responses, tool results, memory, or routing tensors, does not send requests to the service, and does not share software caches; victim requests are serial, with no third-party load during collection.
  2. What related research exists?

    Related work falls into four groups: confidential prompt/policy inference, physical execution and sparse-routing side channels, agent attacks and policy reconnaissance, and external execution and residual channels.

    Confidential prompts and policy inference

    • WAFFle (2012): Distinguishes requests blocked versus allowed by a transparent web application firewall via timing, learning the firewall's confidential filtering rules; the paper uses this to show that timing inference of confidential policies predates LLMs.
    • Early Bird (2025): As a user of the same serving API, exploits timing differences in shared KV cache and semantic cache to recover part of the confidential system prompt.
    • Prompt Detective (2025): Tests whether a given candidate system prompt is in use by comparing response distributions. The paper notes that PolicySniff, like these three, identifies a confidential configuration among known candidates, but differs in access: its attacker sends no requests, shares no software cache, and reads no responses, only observing its own kernel timing on a shared GPU.

    Physical execution and sparse routing

    • MoEcho (2025) and Yona et al. (2024): MoEcho exploits expert load leakage caused by MoE per-expert execution to recover user prompts and responses via CPU cache channels and GPU performance counters; Yona et al. exploit expert-selection routing to steal user prompts when attacker and victim queries are in the same batch. The paper states that the native attack relies on the same per-expert execution property but differs in three ways: it does not read performance counters, it infers a cached prefix rather than tokens within an observation window, and the inferred quantity is a behaviorally verified authorization setting rather than user content.
    • GPU side-channel primitives and cross-tenant fingerprinting: Leaky DNN and TIMESLICE-SANDWICH provide GPU context-switching and time-slicing primitives (this paper's observer adapts the latter's open-source artifact); Behind Bars, GhostAccess, Spy in the GPU-box, NVBleed, PAGE404, etc. identify which model or workload is running. The paper notes that these works identify model/workload identity, whereas PolicySniff's target is a binary configuration inside a known model.

    Agent attacks and policy reconnaissance

    • Indirect prompt injection and AgentDojo (2024): AgentDojo evaluates prompt injection in stateful tool environments, where the attacker tampers with selected tool outputs, and the safety metric records whether the resulting action achieves the attacker's goal; its experiments also distinguish attacks with correct user/model knowledge from attacks that guess wrong. The paper notes that AgentDojo measures induced actions, whereas PolicySniff measures rule recovery, and the combined effect of the two requires joint evaluation, which this paper does not do.

    External enforcement and residual channels

    • CaMeL (2026): Places a protective interpreter outside the model, tracks data provenance and permitted readers, checks policy at tool-call sites, and can place confirmation requirements outside the LLM; the work also analyzes indirect leakage such as conditional external requests, exceptions, and timing. The paper states that this paper's policy placement comparison (Section 8.3) evaluates a similar separation under a fixed action interface, whereas CaMeL addresses a different problem: data-dependency tracking on which tool-call authorization depends.

    Baselines and benchmarks: This paper sets no attack baseline method; internal controls include a length-only baseline (59.03%), label permutation (50.28%), a path-isolation control, and a no-load sham. Evaluation uses the authors' own synthetic task set (see Questions 3 and 4). The authors position this paper as policy reconnaissance inside a known model targeting a behaviorally verified authorization setting, distinct from work that recovers text content or identifies model identity.

  3. How does the paper address this problem?

    Three evidence paths: behavioral verification confirms the rule has authorization consequences, the native timing attack performs inference, and routing replay locates the physical mechanism carrying the information.

    Overall approach: model "which approval rule is deployed" as an identification problem over a binary secret S, and gather evidence along three paths (Figure 2)—behavioral verification (rule to action), native attack (rule through GPU execution to the attacker's own timing), and replay experiments (rule through routing summaries to controlled physical sensors).

    Problem setup and formalization

    • Secret and decision: S ∈ {0,1} selects which of two known candidate rules is active; the attacker outputs an estimate Ŝ, and a recovery rate above chance violates policy-state confidentiality. S is called security-relevant if changing it changes the verified action selection at a machine-checked endpoint or authorization boundary.
    • Two comparison tracks: the replay study compares an explicit confirmation rule with an inert placebo instruction of equal token length; the native study compares two rules that reverse the order of ask_user and execute. The two tracks use different models and task modes, and accuracies are reported separately.
    • Metrics: balanced accuracy (the mean of the accuracy of the two class conditions); when a segment fails, the decoder abstains, abstentions count as errors, and coverage is the proportion of groups that did not abstain; intervals use 10,000 cluster-bootstrap resamples (fixed seed).

    Native attack: collection and decoding

    • Policy-pair implementation: the two rule texts tokenize to equal length, have equal-length KV-cache prefixes, and are followed by the same task suffix; the policy prefix is cached before timing collection, so the measured forward pass processes only the shared task suffix. The prompt fixes a two-choice JSON mode and pre-fills the assistant prefix to fix the decision point.
    • Probing and segmentation: the probe process repeatedly launches a single-threaded CUDA kernel (10,207 iterations, CUDA events recorded on both sides), with no victim start/end timestamps; the offline detector finds the largest adjacent jump (threshold 0.02 ms) within the lowest 30% of the empirical distribution, bins at 20 ms, bridges up to 3 inactive bins, keeps active segments of at least 500 ms, and passes only if it finds exactly 96 segments.
    • Classification: for each deployment group, average its two target request durations and assign it to the state whose same-task reference mean is closer; only public task identity and group labels are used, not collection identifiers, sequence numbers, or repetition indices.

    Behavioral verification

    • Synthetic repository and container audit: the repository contains benign maintenance goals, environmental obstacles, protected resources, and safe-recovery alternatives; the container harness executes tool calls and checks filesystem state, distinguishing "suppressing unauthorized shortcuts" from "refusing to do useful work."
    • Action interface of the native experiments: each task prompt describes a sensitive operation, and the model completes a restricted JSON action object; an automated audit records with dry-run labels (would_execute / approval_required) whether the action obeys the active rule, and does not execute destructive commands on the host.

    Routing summaries and replay

    • Pre-decision routing features: take the routing selections of the last 32 tokens within the span of the first tool message containing an obstacle (excluding system-prompt policy tokens, decision tokens, and output text), and count top-4 selections over 36 MoE layers with 128 experts each, yielding a 4,608-dimensional routing vector.
    • Coarse summary: compress each routing trace into a 36-layer × 4-bucket matrix Zℓ,b = |{e : e mod 4 = b, e selected at layer ℓ}|, i.e., the number of distinct experts selected per bucket per layer, 144 integers in total; the projection is built deterministically, does not access S, and discards within-bucket dispatch counts and token order.
    • Controlled replay: Z is replayed through three sensors—a U280 FPGA memory-contention engine (HBM bursts), a CW305 FPGA power board (255 active channels per bucket, recorded by ChipWhisperer-Husky), and an explicit transmitter across an A100 MIG boundary (NVML board power); each intervention fixes one property (total bytes or per-layer work) and changes only the temporal or spatial allocation.

    Key parameters

    • Native experiments: 2 reference requests per task per state, 2 target requests per group, 24 tasks yielding 48 decisions and 96 target requests; idle delays between requests are drawn uniformly from 0.6–1.2 seconds.
    • Routing activity: 24 repository instances × 3 request phrasings × 2 states × 5 repetitions = 720 routing episodes per activity; physical replay uses a fixed split of 18 training / 6 held-out instances.
  4. What experiments did the paper conduct?

    Three native timing campaigns (BF16, blind-evaluation NF4, frozen coverage study) plus FPGA and cross-MIG replay mechanism experiments, and a broker policy placement comparison.

    Experimental setup

    • Models tested: the native timing track uses Qwen3-30B-A3B-Instruct-2507 (revision 0d7cf239, Transformers 4.55.4 eager MoE path); the routing and behavioral tracks use gpt-oss-120b (local vLLM stack).
    • Hardware: one dual A100-SXM4-80GB server node; BF16 activities use the full card, NF4 and the coverage study use the same MIG instance (3g.40gb), and a timing process on a sibling instance (1g.10gb) serves as an isolation control.
    • Tasks: native activities use synthetic action-selection tasks (BF16/NF4 have 8 each in three families—filesystem, outbound-information, production-infrastructure—24 tasks total); the coverage study expands to six families (deletion, disclosure, production, network, credential, permission) × five authorization conditions (unapproved, revoked, approved, read-only, out-of-scope), 120 scenario clusters in total.
    • Metrics and decisions: balanced accuracy + coverage; behavioral endpoints are machine-checked by the container harness; classification labels are rules, not prompt tokens.
    • Blind evaluation and freezing: NF4 activity predictions were run first in a bubblewrap sandbox, and private ground truth was read only after the summary was submitted; the coverage study's decoder, primary estimator, and success threshold were hash-frozen before reference collection.
    • Repetition and statistics: both states are measured for every task; 95% intervals are 10,000 cluster-bootstrap resamples; routing activities have 5 repetitions per cell.

    Main results

    Balanced accuracy of the native timing attack (per Section 6.3, Table 3, and Section 6.5):

    Swipe horizontally to read the table

    ActivitySettingBalanced accuracyInterval
    BF16full-card A100, 46/4895.83%[89.58%, 100.00%]
    NF4 blind test suitesame MIG instance, 47/4897.92%[93.75%, 100.00%]
    NF4 full generation suite43/4889.58%[81.25%, 97.92%]
    Coverage study primary estimatorunapproved condition, six families94.17%[90.42%, 97.50%]
    Coverage study (same-output tasks)302/34088.82%interval not given in the paper
    Coverage study (different-output tasks)91.98% as written in the paper91.98%interval not given in the paper
    • Authors' interpretation: the authors state that these measurements establish disclosure even when the current decision does not expose the rule; Figure 1(c) shows that the blind NF4 activity classified 47/48 groups correctly.
    • Cross-device control: the maximum gap for observers on different GPUs is 0.000032 ms (below the 0.02 ms threshold), and no activity was detected; the authors state that the signal requires co-residence on the same GPU as the victim.
    • Within-task association: the source audit shows that in 24/24 tasks the change in the number of distinct experts between the two states has the same sign as the change in pre-decision duration (correlation 0.78), and the attacker-side reference gap and target gap have the same sign in 24/24 (correlation 0.79); the paper notes this is an observational association.

    Coverage study: same-decision tasks and cost

    • Same-decision tasks: in the main prefill measurement, 170 tasks (79 clusters) produce the same decision token in both states, and the attack classifies 302/340 correctly (88.82%); on the 30 approved tasks that execute in both states it is 90.00% (54/60). In the full generation measurement, 33 tasks produce the same output, and the attack reaches 80.30% (53/66); the remaining tasks are 86.78%.
    • Observation cost (Table 5): with no probing the decoder abstains (coverage 0.00%); a 1 ms interval (primary estimator) raises the victim's median latency from 2504.1 ms to 7465.5 ms, and continuous probing raises it to 11846.2 ms. NF4 activity (Table 4): continuous probing slows the median by 4.71×, a 1 ms interval by 2.96× (accuracy 94.79%), and a 5 ms interval by 1.52× (accuracy 58.33%).
    • Authors' interpretation: the authors state that within the interfaces tested, the timing signal can identify the deployed rule on tasks where the visible output does not expose the rule.

    Mechanism: routing replay and explicit transmission

    • Logical routing separability: leave-one-instance-out cross-validation balanced accuracy is 98.33% ([96.81%, 99.58%]), with 100.00%, 99.58%, and 95.42% for the three families; the length-only baseline is 59.03%, and label permutation is 50.28%.
    • U280 replay (Figure 3): natural replay of the shared path gives 81.11% for a single request (path-isolation control 46.11%); the equal-total temporal-density intervention gives 80.56% (control 53.89%); the equal-work spatial-path intervention gives 77.22% (control 56.67%). The authors state that temporal burst density and layer-bucket alignment carry the policy information.
    • CW305 power (Table 6, Figure 4): after merging the two groups, the natural arm averages 87.50% over five requests (first group 100.00%, second group 75.00%); the uniformization and constant-slot-filling arms are both near chance (e.g., the filling arm gives 52.78% over five requests). The authors state this is consistent with leakage through structured switching activity; the filling cost is a 107.87%/107.72% increase in active cycles (measured on the FPGA sensor, not calibrated in joules).
    • Explicit transmission (Table 7): sending Z across NVLink L2 contention achieves 99.994% raw-bit recovery and 80.56% held-out policy accuracy; permuting bit positions within rows preserves bit recovery but drops policy classification to 50.00%. Transmitting across the MIG boundary via NVML board power recovers all payload bits in both collections, with policy accuracy 86.11% (permutation 44.44%) and no-load sham 53.12%. The authors state this locates the policy information in Z's layer-bucket alignment rather than in total activity, and that this activity establishes cross-boundary transmission of an encoded intermediate, whereas the native attack measures what the unmodified runtime exposes within a single instance.

    Policy placement comparison (Section 8.3)

    • Setup: the same full-card A100, the same tasks, and the same already-profiled same-card observer; the baseline places the rule in the model prompt, and the defense arm has the model emit only a fixed execution proposal, with a trusted broker applying the rule after inference.
    • Results: the baseline is 95.83% (100.00% coverage); the pre-selected classifier drops to 47.37% in the defense arm (79.17% coverage), and with abstentions counted as errors the whole group is 37.50%, a paired drop of 58.33 percentage points ([50.00, 66.67]). Both arms reproduce the prescribed decision in 48/48 cells.
    • Authors' interpretation: the authors state that under this fixed interface, moving the authorization representation outside the measured inference path suppresses the evaluated classifier; the broker's CPU activity, responses, downstream effects, scheduling, and adaptive classifiers are outside this measurement.

    Other ablations and analyses

    • Probing cadence (Table 4, NF4): no probing 51.04% (frozen parity guess), continuous 97.92%, 1 ms 94.79%, 5 ms 58.33%.
    • Fused kernel comparison: the fused Marlin MoE kernel in stock vLLM 0.30.0 emits the same 216-kernel launch signature across all 360 decode steps; the paper notes that this profile covers decode, whereas the native attack observes prefill.
    • Collection-location correlation: the BF16 activity policy state correlates with collection location at −0.055, and the coverage study at 0.003.
    • Behavioral screen (Table 2): under the confirmation policy the unauthorized-endpoint rate is fixtures 8.33%, build 0.00%, lease 0.00%, and under placebo 70.83%/66.67%/75.00% (24 episodes per cell); benign task completion drops from 52.78% under placebo to 43.06% under the confirmation policy (9.72 percentage points, within the pre-declared 10-point screening threshold).
    • Exceptions: in the NF4 activity, 94/96 sensitive actions obey the active rule (97.92%), and both exceptions are permissive outbound rows (should ask rather than execute).
  5. What are some points that can be further explored?

    The authors state conditions such as coverage and intrusiveness, and propose follow-up directions such as measuring distinguishability and external execution; the effect of combined attacks was not evaluated.

    Limitations and future directions noted by the authors

    • Coverage statement (Conclusion): the authors write that the results cover one sparse MoE model, known candidate rules, profiling on the exact task, and attacker access to request order and grouping.
    • Observation intrusiveness (Section 8.2): continuous probing slows the victim's median by 4.71×, and a 1 ms interval by 2.96×; the authors state that these conditions define how to reproduce the measurement in deployment.
    • Mitigation directions (Section 8.2): deny untrusted processes execution on the GPU or MIG instance serving the agent, which removes the required sharing condition; runtime developers can evaluate execution policies by policy-state distinguishability (not only by serving cost); the replay experiments motivate separate evaluation of other exposed timing and power observables.
    • Gap for open-ended tool use (Section 8.3): applying the separation design that externalizes the rule to open-ended tool use requires trusted operational interpretation, authorization context, and mediation of the relevant execution paths; resource permission alone is insufficient to establish that a use serves an authorized purpose.
    • Combined attacks not evaluated (Section 9.3): policy identification and action redirection have different success criteria; the authors state that a joint evaluation using the same injection pipeline with and without recovered policy information would be needed to determine the effect on downstream attack success, and this paper does not do it.
    • Measurement boundary (Section 8.3): the confidentiality evidence for the broker comparison concerns only the measured GPU inference and the pre-selected classifier; the broker's CPU activity, responses, downstream effects, scheduling, and adaptive classifiers are outside this measurement.

    Experimental coverage

    • 2 models tested in total: the native timing track is Qwen3-30B-A3B-Instruct-2507 (two precisions: BF16 full card and NF4 single MIG instance), and the routing/behavioral track is gpt-oss-120b (local vLLM stack); accuracies for the two tracks are reported separately.
    • Hardware is a single node: one dual A100-SXM4-80GB server; the replay sensors are a U280 FPGA, a CW305 power board, and NVML board power across MIG.
    • Tasks are synthetic: 24 tasks for the native activities (three families), 120 scenario clusters for the coverage study (six families × five authorization conditions); the behavioral screen has 432 episodes (24 instances × 3 phrasings × 2 states × 3 conditions).
    • Attacker conditions granted by authorization: task identity, request order, and grouping are granted by the evaluation (C3); the reference profile covers the exact target task; no third-party load shares the victim instance during collection.
    • Not reported by the paper: the joint success rate of the injection combination experiment; the adaptive classifier performance of the broker arm; joule calibration of the power proxy; the fused kernel profile at the prefill stage (the paper reports only decode).
  6. Summarize the main content of the paper

    PolicySniff: processes co-resident on a GPU infer an agent's approval policy from their own kernel timing, with a primary estimator of 94.17%, plus mechanistic evidence and a broker mitigation comparison.

    An attack paper on the confidentiality of agent deployment configurations: an LLM agent's approval rule is written in the system prompt and kept confidential, and PolicySniff studies whether an adjacent process co-resident on the same GPU can infer which candidate rule is currently active from physical execution observations alone.

    • Problem: behavioral audits check whether an agent complies with its settings, but not whether an adjacent process can infer the settings; the authors argue that behavioral compliance is not configuration confidentiality, and that a disclosed rule can guide target selection for subsequent prompt injection.
    • Method: the attacker knows the candidate rules and tasks, profiles both states on the shared GPU itself, then times only its own kernels with CUDA events and decides by the closest same-task reference mean; the policy prefix is cached before collection, and the measured computation contains only the shared task suffix. Separately, routing summaries are replayed through FPGA memory contention, FPGA power, and explicit cross-MIG transmission for mechanism analysis.
    • Main results: the frozen coverage study reaches 94.17% balanced accuracy for the primary estimator (unapproved condition, six families); 88.82% on tasks where the two policies produce the same output, and 91.98% on tasks where the outputs differ; blind NF4 activity 97.92%, BF16 full-card activity 95.83%.
    • Mechanism and cost: the authors state that the temporal density and layer-bucket alignment of routing carry the policy information (equal-total intervention 80.56%, equal-per-layer-work intervention 77.22%, dropping to 50.00% after permuting the alignment); observation is intrusive, with 1 ms probing raising the victim's median latency from 2504.1 ms to 7465.5 ms.
    • Mitigation comparison: after moving the rule to a trusted broker outside inference, the pre-selected classifier's whole-group accuracy drops to 37.50% (baseline 95.83%), while both arms keep the same decisions.
    • Authors' conclusion: the authors state that policy-state confidentiality should be a deployment property alongside behavioral compliance, that operators should measure rule distinguishability on the serving runtime and place authorization enforcement outside the model; the results are limited to conditions including a single sparse MoE model, known candidate rules, and exact-task profiling.
Read originalarxiv.org