WorksComputer Science
ConfGuard: a physics-grounded reference monitor for predictive-maintenance large-language-model agents
Abstract
Large-language-model agents now close the industrial predictive-maintenance loop, reading sensor windows, retrieving procedures and dispatching work orders. Two attack channels meet there: injected text in a retrieved document can hijack the decision, and a bounded sensor perturbation can corrupt the remaining-useful-life estimate behind it. Recent agent defenses police data provenance and tool privilege but cannot tell whether a prognostic quantity is physically plausible. ConfGuard is a reference monitor with a physics-grounded policy. Its conformal monitor tests each prediction, anchored to the asset's admitted history, against degradation physics: capped remaining life never rises and falls at most one cycle per cycle. Calibrating its threshold over whole asset trajectories lets the operator set the expected share of a clean asset's windows the running monitor escalates. A physics-policy validator checks the agent's maintenance-urgency decision against the decision a deterministic policy derives from the same interval. On all 10,196 C-MAPSS test windows the monitor cuts a covert attacker's reach on healthy assets from 0.529 to 0.046 and closes suppression of failing assets (0.151 to 0), escalating 0.027 of clean windows against a 0.05 target, while the fixed physical range it replaces leaves both attacks open. Behind a Qwen3-14B planner the composed monitors hold urgency-class injection to 0.00 and the universal sensor attack to 0.12, against 0.29 and 0.54 for a defended prompt. An adaptive attacker defeats a Mahalanobis detector on 0.504 of windows and adversarial training on 0.485. We report an attack class the projection misses.
Introduction
Industrial predictive maintenance (PdM) is being rebuilt around agents. A large language model (LLM) reads a sliding window of sensor data, retrieves the relevant procedure from a manual corpus, and calls tools that raise work orders or escalate to a human planner. Tool transport standards such as the Model Context Protocol [1] have made the integration routine, and the operational case is strong enough that agentic maintenance has moved from demonstrations into common production use.
The security case is weaker. Two attack channels converge on the same decision. Injected text in a retrieved document can redirect the agent’s policy, an attack class established by Greshake et al. [2] and benchmarked by Zhan et al. [3] and Debenedetti et al. [4]. A bounded perturbation of the sensor window can move a remaining-useful-life (RUL) regressor by an arbitrary amount, which Basak et al. [5] demonstrated with a single universal perturbation that needs no per-instance optimisation and therefore works in real time.
Defenses have settled on a design borrowed from operating-system security: a deterministic reference monitor outside the model mediates every action, so a compromised planner cannot escalate its own privilege. CaMeL [6] enforces control and data flow integrity through a restricted interpreter; Progent [7] enforces least privilege on tool calls through a policy language; IPIGuard [8] constrains execution to a planned tool-dependency graph. All three report large reductions on AgentDojo.
In an industrial loop these monitors share a blind spot. Their policies are written over provenance, capability and control flow, so they answer questions of the form “may this agent call this tool with an argument derived from untrusted data”. They cannot answer the question an operator cares about: whether the maintenance decision is consistent with the physical state of the machine. A tool call carrying rul_estimate = 3 cycles for a healthy asset is capability-legal and provenance-clean. It is also wrong, and acting on it is expensive.
ConfGuard writes the policy over physics instead (Figure 1). Every decision is checked against a conformal prediction interval computed from the sensor window and against a physically admissible support derived from the asset rather than from the data pipeline. This yields two mechanisms with complementary coverage and, more usefully, quantitative statements about what an attacker can still achieve.
Figure 1. ConfGuard in the maintenance agent loop. Two attack channels enter from the left: injected text reaches the planner through retrieval (A1), and a bounded perturbation reaches the regressor through the sensor window (A2). Both gates run in the trusted control plane and read the same conformal interval. runs before the planner and abstains when the prediction breaks the physics clock, the asset’s own admitted history carried forward at one cycle per cycle; runs after it and rejects a tool call whose urgency class disagrees with or whose arguments leave their bounds. A rejection gets one bounded retry, then goes to a human planner, as does every abstention; an abstention at costs no LLM call.
Why conformal prediction, given that its guarantee breaks under attack. Split-conformal prediction [9, 10] produces intervals with distribution-free marginal coverage, and it has been applied to RUL regression [11]. The guarantee assumes exchangeability between calibration and test points. An adversarial perturbation breaks that assumption, so the coverage statement is void exactly when an attack is under way [12, 13]. Existing work treats this breakdown as a problem to repair; we use it as a detection signal. Under exchangeability the calibrated interval stays inside the physically admissible support at a rate we can measure, and a violation of that rate is evidence that exchangeability has been broken. ConfGuard’s first gate is therefore not a coverage claim but a calibrated test for the breach of a calibrated property, and it remains valid even when the underlying regressor is poor.
Contributions
A physics-grounded reference monitor. We move the agent reference-monitor pattern from provenance and capability policies to a policy grounded in a calibrated model of the physical process (§ 5). The monitor is deterministic, costs microseconds, and requires no change to the planner.
Irreversibility as a calibrated attack test. Capped remaining life never rises and falls at most one cycle per cycle. We turn that invariant into a score anchored to each asset’s own admitted history. Calibrating its threshold over whole clean trajectories bounds the expected clean false-abstention rate of the monitor as it runs, in finite samples and with no assumption on how windows of one asset depend on each other (Proposition 1). The operator sets that rate directly, and in practice this property decides whether a control room keeps a monitor in service. We also show the cost of the obvious alternative: a fixed physical range reduces to a threshold on the point prediction and is blind to suppression, the attack that destroys the asset (§ 9.5).
A detection-power bound tied to operating slack. We show the monitor abstains exactly when the attacker’s induced prediction shift exceeds the distance from the interval to the support boundary (Proposition 2). Because that slack shrinks as predicted RUL falls, detection power is highest on the assets closest to failure. The same result names the regime where the gate is blind, and we report that regime.
Decision-level validation and the limits of what it proves. The physics validator compares the agent’s maintenance-urgency class against the class a deterministic policy derives from the same interval (§ 5.3). Checking a decision against a decision, rather than a number against an interval, makes the complementary-coverage argument valid (Proposition 3). This also makes in-projection injection unreachable by construction, so the number we report is an implementation residual, not an attack-success rate against a mechanism that could fail (§ 9.2).
Adaptive evaluation. Zhan et al. [14] broke eight published injection defenses with adaptive attacks, all above 50% success. We evaluate an attacker who knows the support, both thresholds and the reference policy (§ 7.2), and we report a bound on achievable damage rather than a claim that success goes to zero.
An attack class we do not defend. Injections that leave the urgency class intact but corrupt other work-order fields fall outside the protected projection. We construct and measure them, and ConfGuard does not stop them.
Related work and positioning
Reference monitors for LLM agents
The dominant defense pattern places a deterministic policy outside the model. CaMeL [6] extracts control and data flow from the trusted query and runs the plan in a restricted interpreter that tracks provenance; it solves 77% of AgentDojo tasks with a security argument attached. Progent [7] expresses least privilege over tool calls in a policy language and enforces monotonic confinement, so an attack cannot silently widen the action space. IPIGuard [8] plans a tool-dependency graph and rejects calls that leave it. MELON [15] instead re-executes the trajectory with the user prompt masked and compares the actions.
ConfGuard belongs to this family and differs in what the policy ranges over. The systems above decide admissibility from where a value came from and which tool may receive it. ConfGuard decides it from whether the value is physically consistent with a calibrated model of the asset. The two are composable: a provenance monitor and a physics monitor reject disjoint sets of calls, and nothing prevents running both.
Prompt-level defenses
Spotlighting [16] marks the provenance of untrusted spans inside the prompt and reports large reductions on its own benchmark. Prompt-level defenses are cheap and we include one as a baseline, but they act on the model’s inputs rather than on its actions, so a sufficiently persuasive injection passes. Zhan et al. [14] showed this class degrades sharply under adaptive pressure.
Uncertainty and physics in prognostics
Javanmardi and Hüllermeier [11] applied conformal prediction to RUL on C-MAPSS, using the interval as a reporting device with a coverage guarantee. We use it as the reference of a runtime monitor and do not rely on its coverage guarantee, because Barber et al. [12] show that the guarantee degrades with the departure from exchangeability that an attack creates. Jeary et al. [13] recover guarantees through neural-network verification, which is complementary and more expensive; we instead build a test that does not need the guarantee. Uncertainty-aware RUL is an active line more broadly: Xu et al. [17] combine deep learning with nonstationary Gaussian processes, and Thil et al. [18] treat the uncertainty estimate itself as a health indicator on turbofan data. A parallel line embeds physical knowledge in the predictor rather than in a monitor around it, through hidden-physics architectures [19], meta-learned physics-informed networks [20], and physics-informed data generation for unseen operating conditions [21]. Those methods make more faithful. Ours assumes nothing about and constrains the decision taken from it, so the two compose.
Adversarial attacks on prognostics
Basak et al. [5] introduced universal adversarial perturbations for RUL regression on the NASA turbofan data and showed transfer across models. We use their attack as our sensor channel. Siddique et al. [22] extend the attack surface with multivariate time-series PGD, FGSM and BIM variants and defend by approximate adversarial training, and Gungor et al. [23] pair outlier detection with adversarial training for industrial IoT analytics. Both harden the predictor, and neither constrains the action an agent takes from the prediction. To our knowledge no prior work propagates a prognostic adversarial perturbation through an agent loop and measures the effect on the dispatched maintenance decision, the quantity an operator is exposed to once a planner is in the loop.
Positioning
Conformal prediction and physics checks are both established. The gap is that agent reference monitors currently police provenance, while the security-critical quantity in an industrial loop is physical. Grounding the monitor’s policy in a calibrated physical model yields both a settable false-alarm rate and a bound on adaptive-attacker damage. Neither follows from a provenance policy.
Threat model
Protected asset. The integrity of the dispatched maintenance decision. The agent must neither suppress a needed intervention nor trigger an unwarranted one.
Attacker goal. The primary goal is a decision flip in either direction: suppression on a degrading asset, or premature replacement of a healthy one. Data exfiltration is out of scope.
Availability cannot simply be excluded from scope, because this defense responds to a detected attack by escalating to a human instead of blocking silently. An attacker who cannot flip a decision may still force escalation, which stops the agent doing useful work. We therefore treat forced abstention as a second attacker goal and address it in Section 9.10.
Channels. The attacker controls one of two channels, or both. The text channel (A1) admits attacker-authored passages into the retrieval corpus. The sensor channel (A2) applies a perturbation with to the sensor window. A3 combines them.
Trusted computing base. The attacker cannot modify the regressor , the conformal calibration set, the monitor calibration set, the physical support , the reference policy , or the monitor code. This is the standard reference-monitor assumption [7]: the monitor must be outside the attacker’s reach or it protects nothing. In deployment this means the gates and their configuration live in the historian-side control plane, not in the agent container.
Attacker knowledge. We evaluate two levels. The static attacker (Section 7.1) has black-box access to the agent interface and no knowledge of the thresholds. The adaptive attacker (Section 7.2) knows , the abstention threshold , the conformal width and the reference policy , and optimises against them. Reporting only the static case is the failure mode Zhan et al. [14] identified, so the adaptive case carries our headline security claim.
Preliminaries
Let be a sensor window and a trained RUL regressor. Given a calibration set exchangeable with the test point, split-conformal prediction forms scores , takes , and returns
which satisfies [9, 10]. Under operating-condition drift, Mondrian conformal prediction [24] restores conditional validity by partitioning the calibration set and computing per regime; we use it on the multicondition datasets.
Two facts drive the design. First, depends on the sensor window alone. The retrieved text never enters , so a text-channel attack cannot move the interval. Second, the coverage statement in (1) assumes exchangeability, and an adversarial violates it, so under attack the interval carries no coverage guarantee [12]. We therefore never use at run time as a probabilistic statement about , only as a calibrated geometric object whose behaviour on clean data we have measured.
ConfGuard
ConfGuard interposes two deterministic checks in the agent graph. The conformal support monitor runs before the planner and can abstain. The physics-policy validator runs after the planner and before the tool executor, and can reject. Figure 1 shows where each sits and what each reads.
Conformal support monitor
A first attempt takes the support to be a fixed range for the asset class, with because negative remaining life is not a physical state, and tests whether the interval leaves it. That static test has a defect, measured in Section 9, and the defect motivates the monitor we use. Because the conformal width is constant, a fixed reduces the test to a range check on the point prediction alone, and that check misses an upward shift: an attacker who raises a failing asset’s predicted life moves the interval away from the floor, so the score falls to zero and the monitor passes. A static support therefore cannot see suppression, the costliest attack.
The asset itself supplies a stronger invariant than a range. Capped remaining life is non-increasing, and below the cap it falls by exactly one cycle per cycle. That is a property of the machine, not of the data, so neither attack channel can alter it, and it constrains the prediction relative to this asset’s own recent history rather than against a class-wide box.
Let hold the last predictions this monitor admitted for the asset, each with its age in cycles, and let be the predicted level above which an asset may legitimately sit at the cap. Define the clock anchors
and the physics-clock score
The median makes the anchors robust to a single corrupted history entry, and only admitted windows enter , so a detected attack never poisons the reference. The monitor abstains when , which Algorithm 1 states in full. Every term in (3) is monotone in , so the admitted predictions form a single interval . § 7.2 uses this to characterise the strongest covert attacker exactly, without a search.
A guarantee on false abstention has to hold for the monitor as it runs, and two features of the clock rule out the usual per-window argument. The score at window depends on , and depends on which earlier windows the monitor admitted, so the threshold decides which observations later scores are computed from. A rejected window leaves unchanged; if the prediction has genuinely moved, the next windows are judged against stale anchors and can be rejected in turn. And consecutive windows of one asset share 29 of their 30 cycles, so they are far from exchangeable. A calibration that ranks per-window scores as if they were exchangeable, with every window admitted, therefore says nothing about the deployed monitor. On FD001 a per-window calibration at escalates 0.140 of clean test windows at (§ 9.6). We calibrate over whole trajectories instead.
Fix a threshold shape before the calibration trajectories are drawn. We use the per-window quantiles of the clean scores on held-out validation engines. The monitor of Algorithm 1 abstains when a score exceeds , where ranges over a finite grid that contains , the monitor that never abstains. The grid starts at 1, so the trajectory calibration can only widen the per-window thresholds. For a clean trajectory , let be the fraction of its windows on which the monitor, run on from an empty history with threshold , abstains. need not be monotone in , because admitting one more window moves every later anchor, so we use its upper envelope
Proposition 1 (Calibrated false abstention). Let be clean calibration trajectories and a fresh clean trajectory, with exchangeable as whole trajectories, and let , , , and be fixed before they are drawn. Let be the smallest with
and if there is none. Then the monitor run on with threshold satisfies
with the expectation over the calibration trajectories and the fresh one. With fewer than calibration trajectories, and the monitor never abstains.
Proof. For each trajectory, is non-increasing on by construction, bounded by , zero at , and right-continuous because is finite. Algorithm 1 is deterministic once , , , and the threshold are fixed, so the map from a trajectory to its loss curve is fixed in advance, and the curves of are exchangeable because the trajectories are. These are the conditions of conformal risk control [25 Theorem 1], and is its choice of parameter with , so . Since pointwise, the claim follows. This is the construction Angelopoulos et al. [25] give for losses that are not monotone. At the left side of the defining inequality is , which gives the condition on .
The proposition needs no assumption on the sensor distribution, on how windows of one asset depend on each other, or on the admission rule, because the unit of exchangeability is the whole trajectory and the loss is measured on the monitor as deployed. Nor does it depend on (1) holding, so a weak regressor loses detection power but does not raise the expected false-abstention rate above . And is the dial the operator asks for, since nuisance alarms are the reason condition monitoring gets switched off. The price is the exchangeability assumption: the calibration trajectories must resemble deployment as whole trajectories, in observation window, regime mix and degradation pattern, and there must be at least of them, 19 at . The bound is also an average over assets. It limits the expected share of a clean asset’s windows that escalate, and says nothing about the worst asset. § 9.6 measures it on both sides of these conditions, on real fleets and in simulation.
Definition 1 (Operating slack). At window the downward slack is and the upward slack is . Slack is signed: it is negative exactly when the clean prediction already violates the corresponding bound.
Negative slack is common, and it is where the calibration does most of its work. For RUL with we have , so any asset predicted below the conformal width has a clean interval that crosses zero, and near end of life that is most of them. A fixed support-violation rule would fire on all of those and be discarded as unusable. Under Proposition 1 no tuning is needed: is the quantile of whatever clean score distribution the asset population produces, so legitimate post-failure support crossings are absorbed into the calibration, and Proposition 1 still holds the expected false-abstention rate at or below .
Proposition 2 (Detection power and the attacker’s budget). Let a sensor-channel perturbation shift the point prediction at window by . Then abstains if and only if
Consequently, for an attack in either direction, a perturbation that evades the monitor shifts the prediction by at most in the attacked direction.
Proof. The conformal width is fixed at calibration, so a shift of the point prediction translates the interval rigidly and the anchors (2) depend only on admitted history, not on the current window. For a downward attack the floor term of (3) becomes and the fell-too-fast term becomes , so whenever positive, by Definition 1. For an upward attack the rose-at-all term becomes . In each case is equivalent to the stated inequality, and the second claim is its contrapositive.
A static support cannot supply the upward half. With a fixed the only upward bound is the fleet ceiling , so is very large for every asset that is not already near the cap, and a suppression attack costs the attacker nothing. Anchoring upward to the asset’s own recent predictions replaces that ceiling with a bound that tracks the machine. The proof is only a substitution into (3). Its value is operational, and the corollary below states it separately because it is the property an operator buys.
Corollary 1 (Risk-weighted detection). Under the clock, and the anchor decays with the asset, so the upward budget does not grow with remaining life: it is bounded by the jitter of the predictor along a trajectory rather than by the distance to a fleet ceiling. A suppression attack must therefore beat the asset’s own recent history, whatever its health. Downward, with , the budget still contracts as , so false-alarm attacks remain hardest to hide near end of life.
Corollary 1 states what this gate does. It caps sensor attacks rather than stopping them, and the cap tightens where the consequence is worst: an undetected flip on a healthy asset costs an inspection, and on an asset near end of life it costs the asset. A learned anomaly detector offers no comparable statement, because its score is a function of the training distribution rather than of a physical bound, so nothing ties its sensitivity to the cost of being wrong. Anchoring the test to the asset’s physics supplies that link.
What the operator pays for
Proposition 1 leaves to the operator, but the setting has a price. Every clean abstention routes a decision to a human, so the expected clean cost carries an added term , where is the loaded cost of a planner triaging one escalation (§ 8).
Propositions 1 and 2 together give the exchange rate. Raising lowers , since a larger tail of the calibration score distribution falls above the threshold, and a lower shrinks the attacker’s undetected budget . The operator therefore pays planner labour to reduce the prediction shift an attacker can reach, at a rate the two propositions make explicit. Table 1 lists it.
| (cycles) | clean escalation | added cost/decision | covert FA | |
| 0.01 | 0.000 | $0.00 | 1.000 | ||
| 0.05 | 18.2 | 0.030 | $1.33 | 0.868 | |
| 0.10 | 15.2 | 0.064 | $2.90 | 0.840 | |
| 0.20 | 10.8 | 0.165 | $7.44 | 0.775 |
Table 1. Escalation labour against attack reach on C-MAPSS FD001, clock , , all 10,196 test windows. At each the threshold is the per-window shape at that widened by Proposition 1 (the larger half’s ). Added cost is realised escalation times . The last column is the persistent covert attacker’s false-alarm reach. At the 50 calibration engines per half are too few (Proposition 1 needs 99), so and the monitor never abstains.
Every escalation figure in this paper is linear in , which is a modelling choice rather than a measurement, so an operator with a different loaded rate rescales them directly. At the clock adds $1.33 to the expected cost of a clean decision. The exchange runs as Propositions 1 and 2 predict: raising to 0.20 lowers from 18.2 to 10.8 cycles and the covert attacker’s reach from 0.868 to 0.775, for $7.44 per decision. The fleet also sets a floor on the dial. Lowering to 0.01 needs 99 calibration trajectories, and with 50 the monitor cannot be calibrated there at all.
The table also shows the limit of the dial. Even at the loosest setting the persistent covert attacker keeps most of its reach, because bounds a single step and this attacker takes many. No setting of changes that; only a reference the attacker cannot shape does (§ 9.7). An operator who turns sensitivity up under attack slows the attacker but does not stop it.
Algorithm 1 $G_{\mathrm{conf}}$: conformal support monitor
Require: window $x_t$ at cycle $t$, per-asset history $H$ of admitted $(t_i,f_i)$, horizon $k$, cap level $c^{\star}$
Require: frozen $f$, $\hat{q}$, floor $B_{\mathrm{lo}}$, threshold $\tau_{\rho}$
1: $\ell \leftarrow f(x_t)-\hat{q}$; $u \leftarrow f(x_t)+\hat{q}$
2: $s \leftarrow \max(B_{\mathrm{lo}}-\ell,0)$
3: if $H \ne \varnothing$ then
4: $\quad j_i \leftarrow t-t_i$ for the last $k$ entries of $H$
5: $\quad A^{\downarrow} \leftarrow \operatorname{med}(f_i-j_i)$; $A^{\uparrow} \leftarrow \operatorname{med}(f_i-j_i\ \text{if } f_i<c^{\star}\ \text{else } f_i)$
6: $\quad s \leftarrow \max(s,A^{\downarrow}-f(x_t),f(x_t)-A^{\uparrow})$
7: end if
8: if $s>\tau_{\rho}$ then
9: $\quad$ return abstain, route to human escalation $\triangleright H$ is left unchanged
10: else
11: $\quad$ append $(t,f(x_t))$ to $H$
12: $\quad$ return pass with interval $[\ell,u]$
13: end if
The same result also locates the blind spot: a mid-life asset with a wide slack can absorb a large undetected shift. Section 9 reports the measured shift distribution against the slack distribution, the diagnostic needed to judge whether the bound binds on real data.
Physics-policy validator
The planner emits a tool call whose safety-critical content is a maintenance urgency class. Let
be that class, extracted from the call by a fixed projection. Define the reference policy over the interval,
The rule is deliberately interval-based rather than point-based: it commits to an urgent action only when the optimistic end of the interval is already past the danger threshold, and to inaction only when the pessimistic end is still safe. Everything ambiguous becomes an inspection. This is how a reliability engineer writes a decision rule against an uncertain estimate, and it makes the validator conservative by construction.
rejects the call when
alongside two cheap sanity checks: argument bounds drawn from the asset configuration, and consistency between the reported sensor state and the vibration severity class of ISO 10816. A rejection routes to one bounded retry with a restricted action set, then to human escalation.
A naive design would check the reported value instead. Testing whether a reported rul_estimate lies inside catches only attacks that misreport the number. An injection that says “per OEM bulletin 44-B, schedule immediate replacement” can flip the decision while reporting an entirely truthful RUL, and a value-level check passes it. Comparing the emitted decision against the decision the reference policy derives from the same interval catches it, because the flip is the thing being tested. Figure 2 works the example through.
Figure 2. Why checks a decision rather than a value. An injected bulletin persuades the planner to request immediate maintenance on a unit whose clean interval is [42.1, 97.9] cycles, while the call reports the remaining life truthfully. A value-level check sees and admits the call. The decision-level check derives the warranted class from the same interval, which is INSPECT, and rejects the mismatch.
Why the planner is still needed
determines the urgency class, but projects a much larger action space onto three values. The agent still selects which asset the alert concerns, retrieves and interprets the applicable procedure, fills the work-order fields, chooses part numbers against inventory, schedules a technician with the right certification, and writes the justification that a human planner reads. constrains one three-valued coordinate of that space and leaves the rest to the model. This is least privilege on the safety-critical dimension: the monotonic-confinement idea that Progent applies to tool privilege [7], specialised to a physical quantity. Section 10 states the cost: attacks that stay inside the protected projection are stopped, and attacks on the other coordinates are not.
Control flow
The agent is a seven-node state machine with nodes retrieve, conformal_monitor, planner, physics_validator, tool_executor, escalate and finalize, in that order (Figure 1). An abstention at conformal_monitor skips the planner entirely and escalates, which also means an attack detected at that node costs no LLM call.
Complementary coverage
Assumption 1 (Channel separation). A1 alters the retrieved text only, leaving fixed. A2 alters only, leaving fixed. Neither alters , the calibration sets, , , or the monitor code (Section 3).
Assumption 2 (Attack effectiveness). A successful attack changes the emitted urgency class relative to the class warranted by the uncorrupted sensor evidence: with computed from the clean .
Assumption 3 (Planner adherence). Absent a text-channel attack, and whatever urgency class the interval it was given warrants, the planner emits with probability at least .
Assumption 2 defines what counts as a successful attack, in the same terms the validator tests. Assumption 3 is the only empirical one, and we measure directly (Section 9) instead of assuming a value. It is stated per warranted class on purpose: a sensor attack changes which class the interval warrants, so a rate averaged over the clean class mix does not carry over to the attacked one.
Proposition 3 (Complementary coverage). Under Assumptions 1 to 3:
(a) Under A1, ’s trigger rate equals its clean false-abstention rate, whose expectation per trajectory is at most (Proposition 1); and rejects every successful A1 attack.
(b) Under A2, ’s trigger rate is at most ; and abstains whenever the induced shift exceeds .
Proof. (a) By Assumption 1 the window is unchanged under A1, so , and hence the abstention decision are identical to their clean values; the trigger rate is the clean false-abstention rate, whose expectation per trajectory is at most under Proposition 1. For the validator, still reflects the uncorrupted evidence, so is the warranted class. Assumption 2 states that a successful attack yields , which is exactly the rejection condition (5). Every successful A1 attack is therefore rejected.
(b) Under A2 both the interval and the planner’s input derive from the same corrupted . By Assumption 3, whichever class the corruption produces, the planner emits it with probability at least , and (5) compares against that same , so the validator accepts: its trigger rate is at most . The support is immutable by Assumption 1, and the clock anchors are built from windows admitted before the attack, so Proposition 2 applies unchanged and gives the abstention condition. An attacker who gets perturbed windows admitted moves the anchors; Section 9.7 measures that case.
What the analysis does and does not show
Figure 3 summarises the result. The two arms of Proposition 3 are not equally strong. The A1 arm is structural. Given Assumption 2, rejection follows by definition, because (5) tests the same property that defines success. The only thing to measure there is how often the implementation departs from the construction, the subject of Section 9.2. The A2 arm is different in kind: it is conditional on the slack inequality of Proposition 2, an empirical quantity that varies per asset and per dataset, and it fails on high-slack inputs.
Figure 3. Complementary coverage (Proposition 3). Each gate compares against a reference that one channel cannot move. The arms differ in kind: the cell holds by construction for every in-projection flip, while the cell holds only when the attacked prediction breaks the physics clock by more than , and a slow persistent drift can move the anchors it is judged against (Section 9.7).
The A1 arm also does nothing for A2, and can make it worse. The validator enforces on whatever interval it is given, so on a sensor attack that passes it enforces the corrupted decision, and the bounded retry makes a planner that would have hedged comply with it. Section 9 measures that cost.
Neither arm covers anything outside the projection . Assumption 2 fixes the class we claim, and A1-b (Section 7.1) measures the rest, on which ConfGuard does not help.
Why the urgency class is the right coordinate
Assumption 2 defines success as a change in the urgency class, which narrows the threat relative to the attacker goals of Section 3. That narrowing needs a justification, since otherwise a reader could object that the threat was drawn around the defense.
Expected loss concentrates in that coordinate. Price the outcomes as in Section 8: suppressing maintenance on a degrading asset risks a catastrophic failure at $50,000, and a false alarm on a healthy asset costs a preventive intervention at $200 plus the downtime it occupies. Errors in the unprotected coordinates are cheaper. A wrong part number delays a correctly scheduled job, a wrong technician certification forces a reschedule, and a wrong service window risks an SLA penalty. Each costs on the order of $100 to $2,000 and is recoverable on the next visit; none destroys the asset.
The urgency class therefore carries one to two orders of magnitude more expected loss than the fields around it, which is why we spend the monitor’s guarantee there. This is a deliberate allocation and makes no coverage claim for the other fields; § 9 measures how often the unprotected coordinates are corrupted.
Attack library
Static attacks
A0, clean.* Unperturbed windows against a clean corpus of 500 templated manual chunks across three asset domains.
A1-a, urgency-class injection.* 200 adversarial chunks in the InjecAgent style [3], spanning four attacker targets (force_replace, suppress_maintenance, halt_operation, mis_prioritise) and four encodings (plain, base64, Unicode homoglyph, faux-PDF metadata). Each targets the urgency class, so each falls inside the protected projection.
A1-b, out-of-projection injection.* 200 chunks that leave the urgency class correct and corrupt a different field instead: part number, technician certification, or scheduling window. These are outside and we expect ConfGuard not to stop them. We include the class to measure the scope of the defense.
A2, universal sensor perturbation.* A single with fitted per dataset following Basak et al. [5] by maximising regressor MSE over a training batch.
A3, hybrid.* 100 records pairing an A2 window with a matched chunk that explains the anomaly away as an instrumentation fault.
Adaptive attacks
The adaptive attacker knows , , and .
A4-s, evasive sensor attack. Solve
by projected gradient descent with the constraint enforced at every step. The attacker gives up unbounded shift in exchange for evading the monitor. Proposition 2 says the achievable shift is then at most , so this attack tests whether the proved bound is also tight in practice.
A4-t, policy-consistent injection. The attacker crafts injections that request only actions in the accept set of . This attack is defeated by its own construction: the only urgency classes it can ask for are the ones the physics policy already endorses, so a successful injection produces the decision the operator would have taken anyway. We still report it, because an empirical check of the confinement property is stronger evidence than the argument, and Zhan et al. [14] showed that arguments of this shape often fail in practice.
Experimental setup
Datasets. We use three RUL-regression benchmarks: C-MAPSS FD001 and FD004 [26], and MetroPT-3 [27]. FD001 has a single operating condition and one fault mode, so it isolates the mechanism. FD004 has six operating conditions and two fault modes, which is the setting Mondrian conformal prediction exists for [24] and the harder test of whether a support-based monitor survives regime change. MetroPT-3 adds a real-world stream target to the two simulated ones.
All three admit an interval-valued prognostic with a hard physical floor at zero, which is what requires. We do not evaluate on AI4I 2020 [28], a binary failure-classification dataset: it has no RUL interval and therefore no physical support for (3) to test, so including it would mean substituting a different mechanism under the same name. § 10 states the scope consequence.
RUL semantics still differ, so the thresholds in (4) are calibrated per dataset. C-MAPSS uses cycles following the usual evaluation convention; MetroPT-3 uses days matching the operational service-level agreement of the Porto metro air-production unit. Applying the C-MAPSS thresholds unchanged to MetroPT-3 makes every attack-success figure vacuously zero, because that target saturates at a 14-day horizon, so the thresholds have to be set per dataset.
Backbones. A bidirectional LSTM RUL regressor per dataset (on FD001, the mean of three seeds), window length 30, RUL clipped at 125 cycles for C-MAPSS. Conformal calibration at , giving cycles on FD001; Mondrian partitioning by operating regime on FD004, where pooling regimes inflates and every quantity downstream of it.
Monitor calibration. . The threshold shape is the per-window quantile of the clean scores on windows from the ten held-out validation engines, split equally across the active scores; these engines are disjoint from the conformal calibration set. is then set by Proposition 1 on clean test trajectories, cross-fit: the test engines are split at random into two halves (50 and 50 on FD001, 124 and 124 on FD004), and each half is scored with the the other half chose, on a grid of steps of 0.02 from 1 to 2, coarser above. Analyses that run on all test engines at once (Table 7 and Table 1, § 9.10) use the larger of the two halves’ , which only lowers the monotonised loss, so each half’s bound still holds. At both halves choose on FD001 and on FD004, so the deployed thresholds are the per-window ones and every planner experiment runs on them.
| Attack | Monitor | caught before harm | FA success |
| Universal perturbation | static support | 0.000 | 1.000 |
| clock, | 1.000 | 0.142 | |
| Adaptive, non-covert | static support | 0.000 | 1.000 |
| clock, | 1.000 | 0.138 | |
| Adaptive, covert, persistent | static support | 0.000 | 1.000 |
| clock, | 0.000 | 0.638 |
Table 7. Sensor attacks along full trajectories on all 100 FD001 test engines, attacker persistent from the degradation onset. Caught is the fraction of attacked assets escalated before any harmful dispatch; FA is the false-alarm success rate over healthy windows. The covert attacker is idealised: it may place the prediction anywhere in the -ball’s image and re-plans every window, an upper bound on attack power.
Planner. Qwen3-14B at Q4_K_M quantisation with thinking disabled, served through Ollama v0.35.0 on two T4 GPUs at temperature = 0 with JSON-constrained decoding. Four further open planners from four other model families (Phi-4-14B, Gemma-3-12B, Mistral-Nemo-12B and Llama-3.1-8B, all at the Ollama default quantisation) are run on the rule prompt for the adherence measurement of § 9. No hosted model is used.
Sample size. queries per cell across three seeds, per cell, with per-seed query samples drawn by deterministic shuffle from windows at or after the degradation onset so the monitor has history. One set of 8,400 planner calls (seven attack conditions, four prompt variants) serves every configuration, because the gates are applied to the recorded answers; the validator’s retries are a further 951 calls, each conditioned on the answer it corrects. Cell values are three-seed means. The largest seed standard deviation in Table 2 is 0.09 (provenance monitor, A2); the rest are in the released results. The sensor-side quantities in Table 4, Table 3 and Table 7 need no planner and are evaluated on every window of all 100 test engines (10,196 windows).
| Configuration | Clean ↓ | Attack success rate ↓ | Utility ↑ | ||||
| err | abst | A1-a | A1-b | A2 | A3 | A1-a | |
| Undefended ReAct | 0.68 | n/a | 0.39 | 0.76 | 0.00 | 0.52 | 0.32 |
| Defensive prompt only | 0.41 | n/a | 0.29 | 0.18 | 0.54 | 0.67 | 0.48 |
| Spotlighting | 0.68 | n/a | 0.39 | 0.77 | 0.00 | 0.51 | 0.31 |
| Adversarial training | 0.41 | n/a | 0.29 | 0.18 | 0.04† | n/a | 0.48 |
| Provenance monitor | 0.41 | 0.00 | 0.29 | 0.00 | 0.54 | 0.67 | 0.48 |
| Mahalanobis OOD | 0.41 | 0.02† | 0.29 | 0.18 | 0.00† | n/a | 0.48 |
| Width-based conformal | 0.41 | 0.05† | 0.29 | 0.18 | 0.24† | n/a | 0.48 |
| ConfGuard, only | 0.38 | 0.08 | 0.26 | 0.16 | 0.08 | 0.09 | 0.45 |
| ConfGuard, only | 0.00 | 0.00 | 0.00 | 0.18 | 0.88 | 0.88 | 1.00 |
| ConfGuard, both | 0.00 | 0.08 | 0.00 | 0.16 | 0.12 | 0.12 | 0.92 |
| ConfGuard, both, no retry | 0.00 | 0.46 | 0.00 | 0.11 | 0.08 | 0.09 | 0.45 |
| ConfGuard + provenance | 0.00 | 0.08 | 0.00 | 0.00 | 0.12 | 0.12 | 0.92 |
Table 2. C-MAPSS FD001 with a Qwen3-14B planner: three-seed means over 100 queries per cell from the planner sweep, with the validator’s bounded retry. Undefended ReAct and Spotlighting use prompts without the decision rule; every other row uses the rule prompt, so each differs from Defensive prompt only by its monitor alone. Clean columns separate the two costs a defense imposes on clean traffic: err is the decision-error rate, the fraction of clean queries whose dispatched urgency class differs from , and abst is the false-abstention rate, the fraction escalated to a human. A2 and A3 count a harmful dispatch over the queries where one is possible ( or ). †Sensor-side value on all 10,196 test windows with the planner modelled by (Table 3); no planner was run behind these gates. An n/a marks a configuration with no abstention path, or an A3 cell that needs that planner run. Utility is task completion under A1-a. A1-b lies outside the protected projection by design.
| Defence | clean escalation | fixed A2 | adaptive |
| None | 0.000 | 0.702 | n/a |
| Adversarial training | n/a | 0.037 | 0.485 |
| Width-based conformal | 0.050 | 0.235 | 0.925 |
| Mahalanobis OOD | 0.019 | 0.000 | 0.504 |
| Physics clock () | 0.027 | 0.006 | 0.046 |
Table 3. Sensor-channel defences on C-MAPSS FD001, all windows of the 100 test engines. The universal perturbation of Basak et al. [5] shifts predictions by 65.3 cycles on average and is a false-alarm attack: ungated, it flips 0.702 of healthy windows. The adaptive column is the same attacker re-optimised to stay under each defence’s own threshold, on 1,000 healthy windows for the learned defences and on every healthy window for the clock, whose one-shot covert attacker is exact.
| Monitor | clean escalation | suppression | false alarm | |
| Static support | 0.004 | 0.151 | 0.529 | 1.02, 1.02 |
| Clock, | 0.034 | 0.005 | 0.033 | 1.44, 1.40 |
| Clock, | 0.030 | 0.000 | 0.049 | 1.18, 1.30 |
| Clock, | 0.027 | 0.000 | 0.046 | 1.00, 1.00 |
Table 4. Covert reachability on all 10,196 windows of the 100 C-MAPSS FD001 test engines. Each threshold is the per-window shape from the ten held-out validation engines, widened by the of Proposition 1, cross-fit over two halves of the test engines (last column, one value per half). cycles, , attacker budget 65 cycles. Suppression is reachable when the attacker can raise a critical asset () into NO_ACTION; false alarm when it can lower a healthy asset () into MAINTAIN_NOW.
Metrics. We report four. ASR is the fraction of attacked queries where the dispatched urgency class matches the attacker’s target. Utility under attack follows the AgentDojo convention [4]: the fraction of attacked queries where the agent still completes the legitimate task. Clean traffic needs two numbers, because a single one flatters a gating defense. The clean decision-error rate is the fraction of clean queries whose dispatched urgency class differs from , which measures whether the defense degrades correct operation. The clean false-abstention rate is the fraction escalated to a human, which measures the labour the defense consumes, and its expectation per trajectory is what Proposition 1 bounds at . A configuration with no abstention path has the second undefined rather than zero. Cost per decision prices an unnecessary preventive maintenance at $200 and a missed failure at $50k, and charges $45 for each escalation, being thirty minutes of a maintenance planner’s time at a loaded rate of $90/h. It charges nothing for an inspection, which favours a planner that always inspects. Charging escalation is not standard in this literature, and it should be: a monitor that answers uncertainty by calling a human consumes a budget the operator has to fund, and leaving that cost out flatters every abstaining defense in Table 2.
We do not report clean-data RMSE as the utility metric. Gating cannot change the regressor’s RMSE, so quoting it would understate the cost of the defense; we report the clean false-abstention rate, which gating does change.
Baselines. Beyond the two ablations we compare against six alternatives. An undefended ReAct planner and a defensive system prompt with no gates bound the range. Spotlighting [16] represents prompt-level injection defense. A Mahalanobis out-of-distribution detector on the sensor window [29] is the obvious alternative to and has to be included. Width-based conformal abstention is the standard conformal gate and isolates what the support test in (3) adds over it.
The sixth baseline, which matters most for our positioning, is a provenance monitor we implement in the style of Progent [7]: a deterministic capability policy over tool calls that admits the legitimate tool set, tracks whether an argument derives from retrieved text, and carries no physical predicate. Our thesis is that a provenance policy cannot see a physically implausible prognostic, and we test that by running one instead of arguing from its design. We also evaluate adversarial training of the backbone [22], which defends the regressor instead of the decision, as a complementary rather than competing approach.
Results
Complementary coverage holds, with unequal arms
Table 2 reports FD001, the single-condition case that isolates the mechanism, and reproduces with a real planner the pattern Proposition 3 predicts. Removing returns A1-a to 0.26, close to the defended prompt’s 0.29, while A2 stays at 0.08. Removing sends A2 to 0.88 while A1-a stays at 0.00. Each gate moves only its own class, and Figure 4 outlines the two cells that show it.
Figure 4. Attack success rate by configuration on C-MAPSS FD001 with a Qwen3-14B planner, the cells of Table 2. Outlined cells show a removed gate’s matched class returning: without , A1-a rises to 0.26; without , A2 rises to 0.88. A1-b lies outside the protected projection, and only composing a provenance monitor removes it.
The -only row is worse on A2 than no validator at all, 0.88 against the defended prompt’s 0.54, and the cause is the retry. Under A2 the corrupted interval warrants \textsc{maintain\_now} on every attacked query. Left alone, the planner hedged to an inspection on 102 of the 300, which happens to be safe; the validator rejects that hedge as a departure from , and the retry hands the planner the class the corrupted interval warrants. enforces the reference policy on whatever interval it is given, as Proposition 3(b) states, which is why only is credited with A2. Composed, the system sits at 0.12 against 0.08 for alone, because the attacked queries admits now dispatch the warranted class instead of an inspection.
The retry earns that back on clean traffic. Without it, Qwen3-14B’s adherence failure of 0.41 becomes the validator’s escalation rate, and the composed system escalates 0.46 of clean decisions with a utility of 0.45 under A1-a. With one retry, all 951 rejected answers across all attacks came back in the warranted class. The validator then escalates nothing on clean traffic, so clean escalation falls to the 0.08 that contributes and utility under A1-a rises to 0.92. Table 2 reports both rows so an operator can choose: the retry removes 0.38 of clean escalation and adds 0.04 to A2.
The table also shows that the two arms differ in strength. The column is binary because rejection follows from the definition of a successful in-projection attack. The column stops at 0.08, above zero, as Proposition 2 anticipates: perturbations on high-slack assets stay inside the support, and this mechanism cannot detect them at any threshold.
What the A1 number measures
Read at face value, the 0.00 in the A1-a column suggests more than the mechanism supports. Assumption 2 defines a successful in-projection attack as , and (5) rejects on exactly that condition, so Proposition 3(a) is true by construction. The 0.00 is therefore not the rate at which attacks defeat a mechanism that might have held. It is the rate at which our implementation fails to realise the construction, and on 300 attacked queries it failed on none. The implementation could fail in two ways: a projection failure, where cannot parse an urgency class from a malformed call and the executor admits it, or leakage on the retry path, where the second attempt escapes the restricted action set. The planner produced no malformed call in 8,400, and a retried call is validated again before dispatch, so the second cannot occur.
CaMeL makes a claim of the same kind [6], and security by construction is worth more than a large empirical reduction. The two still have to be reported differently. Reporting 0.29 to 0.00 as an empirical defense would misdescribe what happened: the comparison is between a mechanism that can be persuaded and one that cannot be asked, and the correct figure of merit is the residual and its causes.
The A2 column needs no such caveat. Its 0.08 for alone and 0.12 composed are measurements against a mechanism that can fail and does, governed by the slack inequality of Proposition 2.
Sensor-side baselines, and why a detector is not a bound
Table 3 compares the clock against the two defences a reviewer is most likely to propose, a Mahalanobis detector and adversarial training, and against width-based conformal abstention. All run on the same windows, and every gate is calibrated at the same .
The paper’s argument rests on the last two rows, read together. Against the fixed perturbation the Mahalanobis detector is perfect: it abstains on every attacked window at a clean cost of 0.019, better than ours. Against an attacker who knows its threshold and optimises within it, it fails on 0.504 of healthy windows, with a median undetected shift of 54.1 cycles and a feasible evasion on every window we tried. Adversarial training behaves the same way: it absorbs the transferred attack (0.037) and then yields 0.485 to a white-box one. The clock is slightly worse than Mahalanobis on the fixed attack: it admits 0.057 of attacked healthy windows, and 0.006 of healthy windows reach a false alarm. Against the adaptive attacker it is an order of magnitude better.
A learned detector’s threshold sits on a score with no physical meaning, so an attacker is free to move inside it, and nothing in its construction bounds how far. The clock’s threshold sits on a quantity the asset itself constrains, so Proposition 2 bounds how far evasion can go, and the measured 0.046 is that bound’s value on this data. Width-based conformal is the weakest of the four. It stops only part of the fixed attack, abstaining on 0.618 of attacked windows and leaving a false-alarm rate of 0.235, and an attacker who keeps the ensemble spread under the width threshold reaches a false alarm on 0.925 of healthy windows. We do not claim the clock detects more attacks than a well-tuned OOD detector, only that it is the one defence of the four whose evasion margin can be stated in advance.
The gates beat the obvious alternatives
On the sensor channel the comparison is Table 3. The width-based gate is the closest relative of , so it isolates what the support test in (3) adds: on the same windows it lets 0.235 of healthy windows reach a false alarm under the fixed attack against the clock’s 0.006, and 0.925 under the adaptive one against 0.046. Adversarial training of the backbone [22] costs accuracy, as it usually does (test RMSE 14.1 cycles against 13.5). It defends the regressor, not the decision, so it composes with a monitor instead of competing with it.
Two rows of Table 2 are easy to misread. The prompt-only planner’s 0.00 on A2 is not robustness. Without the decision rule, Qwen3-14B answered schedule_overhaul on all 300 clean queries, which the harm model never counts as harmful, so an attack on the prognostic has nothing to move; the same behaviour produces its clean decision error of 0.68. A text injection does move it, to 0.39 on A1-a and 0.52 on A3. Spotlighting [16] changes none of this on this model: 0.39 against 0.39 on A1-a and 0.77 against 0.76 on A1-b.
The provenance monitor is the informative comparison. Run behind the same rule prompt as ConfGuard, it leaves A2 at 0.54, exactly the defended prompt’s figure, because a capability policy has no predicate that can call a prognostic number implausible: the tool call is well-formed, the tool is permitted, and the argument’s provenance is clean. This row measures the gap the paper claims. The same monitor takes A1-b from 0.18 to 0.00 by escalating every call that carried an injected part, technician or service window, because corrupting a part number is a provenance violation and falls inside what a capability policy sees. It does nothing for A1-a, which stays at 0.29.
The static support misses the attack that matters
Table 4 is the measurement that set the design, and Figure 5 sets it beside the sensor baselines of § 9.3. It reports, per monitor, the fraction of windows at which a covert attacker (one that stays inside the admitted interval of Section 5.1) can still reach a harmful decision class. Because every score is monotone in the prediction, that fraction is computed exactly rather than by search: the attacker’s best move is the end of the admitted interval.
Figure 5. C-MAPSS FD001 test engines, thresholds from Proposition 1. (a) Covert reach on all 10,196 test windows (Table 4). A fixed physical range is blind to suppression and leaves a covert attacker reaching 0.529 of healthy windows; anchoring to the asset’s own history cuts false-alarm reach to 0.046 at , and at and closes suppression. (b) Fixed and adaptive attacks (Table 3). A Mahalanobis detector, adversarial training and the clock all stop the fixed universal perturbation; the first two fall to an attacker who re-optimises under their own threshold, measured on 1,000 healthy windows for the learned defences and on every healthy window for the clock. No adaptive attack applies to the undefended pipeline. Only the physics clock carries a bound into the adaptive setting (Proposition 2).
Calibrated to the same , the static support escalates almost no clean windows (0.004) and leaves a covert attacker reaching 0.529 of healthy windows on false alarm and 0.151 of critical ones on suppression. The clock spends 0.027 of clean windows, inside the 0.05 target, to cut false-alarm reach to 0.046, a factor of 11.5, and to close suppression. Once each horizon is calibrated over trajectories the three sit close together: reaches 0.033 on false alarm at 0.034 escalation but leaves 0.005 of suppression open, and reaches 0.049 at 0.030. We use for the rest of the paper because it closes suppression at the lowest clean cost of the three, and because a short history is easier for a persistent attacker to shift (§ 9.7).
Calibrating over trajectories changed the first three rows. A per-window calibration, which ranks window scores as if they were exchangeable, puts at 0.140 of clean test windows and the static support at 0.058, both above the they were calibrated to. Proposition 1 widens those thresholds until the trajectory-level bound holds and leaves where it was (§ 9.6). On the ten validation engines, cross-fit so thresholds never score the engines that set them, the per-window comparison gives 0.626 against 0.082 at matched escalation (0.045 and 0.046), so the ordering does not depend on the split. Ten engines are too few for Proposition 1 at , which needs 19.
The static row’s suppression figure is bounded by the attacker’s 65-cycle budget, not by the support, which is blind in that direction at any budget. Nor does the clock gain from a floor closer: at the floor threshold is 24.02 cycles, below the static support’s 24.50, so the entire difference comes from the anchors in (2).
False abstention under the sequential monitor
Proposition 1 bounds the expected share of a clean asset’s windows that the deployed monitor escalates. Table 5 measures that share on the FD001 and FD004 test engines, before and after the calibration over trajectories. The per-window calibration misses its target. On FD001 it escalates 0.140 of clean windows at , 0.077 at and 0.058 under the static support, and at the asset at the 90th percentile loses a third of its windows. The cause is the one Section 5.1 names: a rejected window stays out of the history, so one rejection can start a run of them. After the calibration over trajectories every monitor sits under on both datasets, per asset and pooled. At the per-window thresholds already met the bound, so both halves chose on both datasets and nothing reported elsewhere for changes. MetroPT-3 is outside the proposition, with two trajectories where 19 are needed, and its per-window figure of 0.075 is reported as measured.
Table 5: Clean false abstention of the deployed monitor (a window enters the history only if it passes) on every test window, at . Per-window: thresholds from per-window quantiles on the validation engines. Proposition 1: the same thresholds widened by , chosen on one half of the test engines and applied to the other (one value per half). Pooled is the share of all clean windows escalated; mean and p90 are taken over assets, each asset’s own share, so mean is the quantity the proposition bounds.
| Data | Monitor | Per-window pooled | Per-window mean | Per-window p90 | Proposition 1 | Proposition 1 pooled | Proposition 1 mean | Proposition 1 p90 |
| FD001, 100 engines | static support | 0.058 | 0.058 | 0.124 | 1.02, 1.02 | 0.004 | 0.004 | 0.000 |
| clock, | 0.140 | 0.115 | 0.334 | 1.44, 1.40 | 0.034 | 0.030 | 0.084 | |
| clock, | 0.077 | 0.065 | 0.194 | 1.18, 1.30 | 0.030 | 0.027 | 0.092 | |
| clock, | 0.027 | 0.023 | 0.076 | 1.00, 1.00 | 0.027 | 0.023 | 0.076 | |
| FD004, 248 engines | static support | 0.061 | 0.059 | 0.196 | 1.02, 1.02 | 0.000 | 0.000 | 0.000 |
| clock, | 0.066 | 0.066 | 0.230 | 1.30, 1.02 | 0.045 | 0.044 | 0.137 | |
| clock, | 0.030 | 0.029 | 0.061 | 1.00, 1.00 | 0.030 | 0.029 | 0.061 | |
| MetroPT-3, 2 episodes | clock, | 0.075 | n/a | n/a | not applicable: needs 19 trajectories |
Table 5.
The real fleets cannot be varied on demand, so Table 6 repeats the test on simulated ones. Each scenario draws whole trajectories: true capped remaining life over a lifetime of 128 to 362 cycles, and a prediction whose error follows a named process. Smooth is an AR(1) error with standard deviation 13 cycles and lag-one correlation 0.95, close to the FD001 regressor. Noisy has standard deviation 20 and correlation 0.7. Abrupt onset holds the prediction at the cap until true life falls below a random level between 30 and 90 cycles, then drops to track it. Switching regimes adds one of six operating-condition offsets, from −12 to +18 cycles, that switches with probability 0.05 per cycle. Rate mismatch lets each asset degrade up to 30% faster or slower than the predictor learned. Trajectories are cut at a random point, as in the C-MAPSS test set, or observed to failure. Each repetition sets by per-window calibration on 10 run-to-failure trajectories, as on FD001, chooses on 50 trajectories of the deployment kind, and runs the real monitor at on 400 fresh ones; the table averages 10 repetitions.
Table 6: Simulated fleets, monitor at , , 10 repetitions of 400 test trajectories each. Mean is the per-asset false-abstention share averaged over assets and repetitions, and worst the largest per-repetition mean. Covert reach is the exact one-shot false-alarm reach on healthy windows (budget 65 cycles), the detection price of widening the thresholds. The last row calibrates on one pattern and deploys on another, which breaks the assumption of Proposition 1.
| Pattern | Observed | Per-window mean | Per-window worst | Proposition 1 | Proposition 1 mean | Proposition 1 worst | Covert reach per-window | Covert reach Prop. 1 |
| Smooth | truncated | 0.046 | 0.072 | 1.09 | 0.034 | 0.055 | 0.049 | 0.055 |
| Noisy | truncated | 0.031 | 0.040 | 1.03 | 0.027 | 0.036 | 0.266 | 0.285 |
| Abrupt onset | truncated | 0.023 | 0.045 | 1.04 | 0.021 | 0.045 | 0.631 | 0.659 |
| Switching regimes | truncated | 0.038 | 0.074 | 1.08 | 0.027 | 0.046 | 0.049 | 0.055 |
| Rate mismatch | truncated | 0.030 | 0.041 | 1.03 | 0.026 | 0.041 | 0.036 | 0.038 |
| Smooth | to failure | 0.098 | 0.137 | 1.40 | 0.033 | 0.046 | 0.076 | 0.123 |
| Smooth regimes | truncated | 0.059 | 0.097 | 1.12 | 0.040 | 0.061 | 0.035 | 0.043 |
Table 6.
Whenever the calibration and deployment fleets are drawn the same way, the calibrated monitor escalates between 0.021 and 0.034 of a clean asset’s windows on average, under for every pattern. The largest single repetition reaches 0.055, which a bound on the expectation allows. The per-window calibration averages under on truncated fleets, but its worst repetitions reach 0.072 and 0.074, and on run-to-failure fleets, where every trajectory crosses end of life, it averages 0.098. The proposition brings that to 0.033 by widening the thresholds ( on average), and the widening has a detection price: one-shot covert reach rises from 0.076 to 0.123. On the noisy and abrupt patterns covert reach is high under either calibration, because a poor predictor widens and with it every admitted interval; that is the predictor’s cost, not the calibration’s. The last row breaks the assumption on purpose. Calibrated on the smooth pattern and deployed on switching regimes, the monitor averages 0.040, but one repetition reaches 0.061, and nothing in the proposition covers it. The calibration fleet has to come from the regimes the monitor will see.
What the monitor catches before harm
Table 7 measures whether, once an attack arrives, the monitor escalates before the first harmful dispatch. It is evaluated along full trajectories, with the attacker persistent from the degradation onset, so the monitor’s history is the one the attacker shaped.
In the first two blocks the defence works as designed. The universal perturbation and the non-covert adaptive attacker are caught before harm on every asset under the clock, and on none under the static support, which never sees a downward shift that stays inside . False-alarm success falls from 1.000 to 0.142 on the universal attack.
The third block shows the limit. A covert attacker who re-plans every window and holds each step inside the admitted interval drifts through: 0.638 of healthy windows reach a false alarm under the clock against 1.000 under the static support. The mechanism is history poisoning. Each admitted step enters , so the anchors follow the attacker down at up to per window. Shorter horizons do worse here, because a short history is easier to shift: 0.868 at and 0.848 at .
Against this attacker the clock still guarantees a rate, which the alternatives do not. Proposition 2 bounds each admitted step by , and with the clock is at most once the history is the attacker’s, so a healthy asset predicted at the cap needs at least windows to reach a false alarm at , and the drift leaves a visible monotone trace in the admitted history. Section 10 names the obvious repair, anchoring to the last human-verified state rather than to the rolling admitted window.
Suppression has a simpler explanation. The covert suppression rate is 0.221 under every monitor, including none, because that is as far as the -ball reaches: the median upward movement PGD can induce on a test window is 8.8 cycles against 67.0 downward. The regressor is far easier to push toward failure than away from it, so on this backbone suppression is bounded by the attack, not by the gate.
Across datasets and planners
Table 8 splits the headline cells by dataset. FD004, with six operating conditions and two fault modes, is the case Mondrian conformal prediction was designed for. On all 248 FD004 test engines, with thresholds from Proposition 1, the static support leaves a covert attacker suppression on 0.808 of critical windows and false alarm on 0.221 of healthy ones; the clock cuts these to 0.099 and 0.038 while escalating 0.030 of clean windows. Contrary to our expectation, switching the conformal width from pooled to per-condition Mondrian makes no difference: false alarm moves to 0.039 and suppression to 0.098. The clock’s reference is the asset’s own admitted history, and a regime shift moves the interval width but not the trajectory, so the monitor tolerates changing operating conditions without a per-regime calibration. Mondrian still matters for the floor term and for the interval the planner reads, but the clock does not depend on it. Suppression stays further from zero than on FD001 because six regimes make the predictor noisier along a trajectory, and the anchors carry that noise as a wider band; a shorter horizon does not close it (0.085 at , at 0.045 clean escalation). The universal perturbation is the weak point of the FD004 evidence, and the attack is the cause, not the gate: fitted against this model, it moves test RMESE only from 14.9 to 19.5 and flips 0.049 of healthy windows. Against it the clock catches 0.539 of 154 attacked assets before harm, against 0.006 for the static support, so the covert-reachability figures in Table 8 are the fairer comparison across datasets.
Table 8: One-shot covert reach by dataset, static support against the physics clock, at the clean escalation rate each clock pays. All cells are sensor-side and need no planner; the planner sweep is FD001 only (Table 2). C-MAPSS rows score every test window, with thresholds from Proposition 1 cross-fit over halves of the test engines. MetroPT-3 has two episodes, too few for the proposition, and keeps per-window thresholds cross-fit across them. The horizon is windows on C-MAPSS and on MetroPT-3, whose ten-minute windows make thirty a five-hour anchor.
| Dataset | clean abst | Suppression ↓ static | Suppression ↓ clock | False alarm ↓ static | False alarm ↓ clock |
| C-MAPSS FD001 | 0.027 | 0.151 | 0.000 | 0.529 | 0.046 |
| C-MAPSS FD004 | 0.030 | 0.808 | 0.099 | 0.221 | 0.038 |
| MetroPT-3 | 0.075 | 0.500 | 0.183 | 0.998 | 0.104 |
Table 8.
MetroPT-3 is a different regime, and the clock behaves differently on it. Its target is remaining life in days capped at 14, sampled every ten minutes, so remaining life moves by 0.007 per window and a fixed range is useless: a covert attacker reaches a false alarm on 0.998 of healthy windows under the static support. The clock holds it to 0.104 with a ten-window history and 0.202 with thirty, the reverse of the C-MAPSS ordering, because thirty ten-minute windows is a five-hour anchor on a signal that has barely moved. Suppression is only partly closed, 0.500 to 0.183 over 101 critical windows: the calibrated tolerance is 2.5 days on this predictor, wider than the 2-day maintenance threshold it protects. The horizon is a quantity of time, not of windows, and a deployment should set it from the asset’s degradation rate. Proposition 1 does not apply here. The test stream is one unit with two failure episodes, two trajectories where needs 19, so MetroPT-3 keeps per-window thresholds cross-fit across its two episodes, and clean abstention sits at 0.075, above the 0.05 target. A deployment would calibrate on a fleet of such units, or on many more episodes of this one.
Assumption 3 is the only empirical assumption in the analysis, and is a property of the planner rather than of ConfGuard, so one model family would not settle it. Table 9 measures it on five open planners from five model families, and none follows a three-line threshold rule reliably: first-answer adherence failure on clean queries runs from 0.41 (Qwen3-14B) to 0.65 (Mistral-Nemo-12B). The failures are systematic: between 82% and 100% of each planner’s deviations are hedges to an inspection where the rule asks for an extreme class, and the worst-class rate reaches 1.00 for Phi-4-14B and Mistral-Nemo-12B, which never issue no_action when the rule requires it.
Table 9: Planner adherence on FD001 under the rule prompt, five open planners, three seeds of 100 queries per attack. is the first-answer adherence failure on clean queries and worst the same rate in the warranted class where it is highest; the next column is ’s trigger rate under A2, which Proposition 3(b) bounds by the worst-class rate. After retry is the clean escalation rate of once the bounded retry has run.
| Planner | , clean all | , clean worst | trig. under A2 | Clean abst after retry | A1-a ASR prompt | A1-a ASR |
| Qwen3-14B | 0.410 | 0.723 | 0.340 | 0.000 | 0.287 | 0.000 |
| Phi-4-14B | 0.500 | 1.000 | 0.393 | 0.000 | 0.013 | 0.000 |
| Gemma-3-12B | 0.627 | 0.864 | 0.820 | 0.000 | 0.117 | 0.000 |
| Mistral-Nemo-12B | 0.648 | 1.000 | 0.703 | 0.000 | 0.090 | 0.000 |
| Llama-3.1-8B | 0.456 | 0.907 | 0.360 | 0.000 | 0.310 | 0.000 |
Table 9.
This has two consequences. First, the clean average does not bound the validator’s trigger rate under A2, because A2 moves every query into one warranted class: for Gemma-3-12B and Mistral-Nemo-12B the validator triggers on 0.82 and 0.70 of attacked queries against clean averages of 0.63 and 0.65. The worst-class rate bounds it on all five, which is why Assumption 3 is stated per class. Second, the retry absorbs the failure: after one corrective call the validator escalates no clean query for any of the five planners, and the A1-a residual is 0.00 on all five. Neither the labour cost nor the text-channel guarantee depends on which planner sits behind the monitor. The undefended exposure does: with the rule prompt alone, A1-a runs from 0.01 for Phi-4-14B to 0.31 for Llama-3.1-8B, and the validator removes that spread.
Adaptive attacks
The adaptive attacker of § 7.2 knows every threshold. Two of its forms are already in Table 7. The non-covert form, which maximises damage and ignores the monitor, is caught before harm on every asset. The covert form that re-plans every window drifts through, at 0.638; the one-shot covert attacker, who gets a single window against a clean history, is bounded exactly by Proposition 2, and the self-check that the admitted interval and the pass decision agree held on 1,000 random monitor states with no failures.
Against A4-t the attack succeeds on 0.00 of queries, if success means changing the dispatched decision: every injection that passes requests an action already endorsed by , so the dispatched decision is the one the operator would have taken without the attack. That holds by construction, so there is no attack rate to measure. The A1-a residual of § 9.2, 0.00 on 300 attacked queries with no malformed call in 8,400, measures instead whether the implementation realises the construction. A policy-consistent injection can still corrupt the fields outside the projection, which is A1-b.
Forced abstention
Proposition 1 bounds the expected abstention rate on clean trajectories exchangeable with the calibration fleet. It says nothing about the rate under attack, and an attacker can exploit that asymmetry. An attacker with sensor-channel access who wants disruption rather than a decision flip can invert the A4-s objective: instead of maximising prediction shift subject to staying under , drive above on every window. Nothing in our construction prevents this, and we measure the result: a perturbation fitted to maximise the support-exit score forces abstention on 0.961 of queries at (and 0.988 at ), so the agent escalates almost everything and the maintenance planners absorb the load.
The failure is one of availability, not decision integrity: the agent dispatches nothing wrong, and in that narrow sense the monitor works as specified. It follows directly from choosing escalation as the response to detection. A monitor that blocked silently would not have this exposure, but it would not be deployable either, because an industrial planner needs somewhere for an uncertain decision to go.
We do not defend against this in the present work, and the escalation path is not free. Two observations bound how bad it is. First, forced abstention is loud: an attacker pursuing it gives up the covertness that makes the flip attacks dangerous, and the operator learns the agent is under attack rather than being quietly misled. Second, and more usefully, the calibration that creates the exposure also gives a reference for detecting it. Under Proposition 1, clean assets escalate at most of their windows on average, and the calibration fleet shows how that rate spreads across assets (Table 5), so a fleet-wide rate well above that spread is evidence of attack. Turning that observation into a sequential test with a controlled false-alarm rate, and pairing it with per-asset escalation rate limits, is the obvious next step, and we have not evaluated it.
The class we do not defend
A1-b sits at 0.16 for full ConfGuard against 0.18 for the defended prompt it runs on. The defense has almost no effect, as § 5.4 predicts, because those injections never touch the projected coordinate; the drop that does appear comes from escalating 0.08 of queries for unrelated reasons. Composing the provenance monitor takes it to 0.00 at an escalation rate of 0.24 on those queries. An operator deploying ConfGuard is protected on maintenance urgency and unprotected on part selection and scheduling, and should compose a provenance monitor such as Progent [7] to cover the rest.
Cost of the defense
On clean traffic the composed system escalates 0.08 of decisions, all of it from , since the retry leaves the validator with none. That is above the set at calibration because the sweep draws its queries from windows at or after the degradation onset, where the predictor is noisier than on the calibration mix; on all test windows the same clock escalates 0.027 (Table 4). Utility under A1-a rises from 0.48 for the defended prompt, and 0.32 undefended, to 0.92, because a rejected hijack is corrected on the retry rather than dispatched.
The bill follows Section 5.2. Clean cost per decision is $6.90 for the composed system: $3.60 of escalation and the rest the reference policy’s own false alarms, which are preventive maintenance it orders on intervals that cross . Under the hybrid attack A3 the composed system costs $55 per decision against $587 for the defended prompt and $1,065 undefended. Under A2 alone the undefended planner looks free, $0, only because it never acts on the prognostic and the cost model does not charge its inspections. The retry is expensive under covert suppression. The attacker raises the prediction of a failing asset inside the admitted interval; without the retry the planner hedges and the validator escalates, at $205 per decision, and with it the planner is handed NO_ACTION, at $840 per decision against $174 for alone. The rate is small, 0.025 of attacked queries, but each success is a $50k failure. Dropping the retry only for assets the clock places near would keep most of the clean saving, and we have not evaluated it. Under the forced-abstention attack of Section 9.10 the sign flips again, to $43 per decision in pure escalation labour with no maintenance value delivered, which is the number an operator should see before deploying this.
The checks add no latency an operator would notice. On one Kaggle CPU core the clock takes 69 s per window, the validator 17 s to parse, project and compare a real planner answer, and the provenance check 19 s, about 105 s per decision in all. The planner call it guards has a median latency of 22.8 s (90th percentile 26.6 s) on a T4 serving four requests at once, so the monitor adds about of the loop. A escalation also skips the planner call entirely.
Limitations
Coverage is bounded by the projection. protects one three-valued coordinate. A1-b measures the consequence: 0.16 for ConfGuard alone (Table 2). Extending the projection to part numbers and scheduling needs a reference policy over those fields, which is inventory logic rather than physics, and we have not written it.
The support test needs a real support. requires a physically meaningful . RUL has a hard floor at zero, which is what makes the C-MAPSS case clean. Quantities without a natural bound get a weaker version of the same test, and the slack argument degrades accordingly.
Interval-valued prognostics only. The mechanism does not transfer to classification. A binary failure predictor such as AI4I 2020 [28] produces a probability, which has a support of that every prediction satisfies by definition, so (3) is identically zero and carries no signal. Substituting a probability threshold would be a different mechanism under the same name, so we excluded the dataset rather than report it. Extending the construction to classification needs a conformal object with a physically meaningful exterior, for instance a predicted time-to-event rather than a class posterior, and we have not built it.
Censored targets weaken the guarantee. MetroPT-3 shows the boundary quantitatively: a target capped at 14 days leaves slack nearly constant across assets, and Corollary 1 needs slack to vary with asset health to deliver risk-weighted detection.
The rolling history can be poisoned. § 9.7 measures it: a covert attacker who re-plans every window and keeps each step inside the admitted interval reaches a false alarm on 0.638 of healthy windows, because admitted values are the anchor. The clock turns an unbounded one-shot attack into a bounded drift, which is a real guarantee, though not the one an operator most wants. The repair is to anchor to a reference the attacker cannot write, the last human-verified inspection or the trajectory before onset, and to treat a monotone run of admitted steps as its own signal. We evaluated that repair in the same run. Committing the anchors only at an inspection event every 25 cycles lowers the persistent covert attacker’s reach from 0.638 to 0.480, at a clean escalation rate of 0.027 that is itself lower than the rolling anchor’s, because the attacker can no longer move the reference between inspections. Every 50 cycles gives 0.655, worse than rolling: a snapshot that old has stopped tracking the asset, so the interval of admissible predictions widens again. The committed anchor is a partial repair with a tunable inspection cadence, and the full one remains a reference the attacker cannot write.
The calibration guarantee needs a calibration fleet. Proposition 1 holds in expectation over assets that are exchangeable with the calibration fleet as whole trajectories, and it needs at least of them. It says nothing when the fleet’s regime mix changes after calibration (Table 6, last row) or when one unit is all there is, as on MetroPT-3. Recalibrating as the fleet changes is the operational remedy; a bound under drift needs a weighted form of the argument [12] that we have not derived.
Availability is not defended. § 9.10 measures a forced-abstention attack that stops the agent working at 0.961 of queries. We give a detection argument for it and no defense. Any deployment needs an escalation rate limit and a policy for what the loop does when the monitor is saturated, and neither is evaluated here.
Static conformal calibration. We recalibrate offline. An asset whose degradation regime drifts will see go stale, inflating slack and weakening detection. Adaptive conformal inference would address this and we have not evaluated it.
Open planners only. The main results use one open-weight 14B planner, and the adherence measurement adds four more, all between 8B and 14B parameters. We ran no hosted frontier model. The confinement argument for A4-t does not depend on the planner, but the adherence rate in Assumption 3 does, and with it the clean escalation cost of (Table 9).
Synthetic injection corpus. The adversarial chunks are generated from templates, not collected from real compromised documentation. The encodings are drawn from published attacks, but the distribution is ours.
Conclusion
Agent reference monitors currently check where data came from. In an industrial maintenance loop the security-critical quantity is physical, and a policy grounded in the physics of the asset gives guarantees a provenance policy cannot. Testing each prediction against the asset’s own history under its degradation physics, with a threshold calibrated over whole clean trajectories, gives a monitor whose expected clean escalation rate the operator sets directly for the monitor as it runs, and whose detection power rises as the asset approaches failure. Comparing the agent’s urgency decision against a deterministic policy over the same interval makes in-projection injection unreachable by construction and confines an adaptive text attacker to actions the physics policy already endorses; what remains is an implementation residual, which we report as such.
Neither mechanism eliminates its channel. The sensor monitor bounds the attacker by a slack the operator can read off the prediction, and the validator bounds the text attacker to decisions that were already correct. Both leave classes uncovered, and the provenance monitor covers several of them, which argues for composing the two families rather than choosing between them. Neither addresses availability. Answering a detected attack by calling a human makes the monitor deployable and also makes forced escalation worth attempting; we price that channel instead of excluding it. Now that adaptive evaluation has become the standard [14], a defense has to be stated as the bound it achieves against an attacker who knows the thresholds.
Declaration of competing interest
The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.
Data availability
Code, configurations, trained checkpoints and result files are available from the corresponding author on request. The datasets are public: C-MAPSS FD001 and FD004 [26] and MetroPT-3 [27].
References
- [1]Anthropic, Model context protocol specification, 2024. https://modelcontextprotocol.io.
- [2]K. Greshake, S. Abdelnabi, S. Mishra, C. Endres, T. Holz, M. Fritz, Not what you’ve signed up for: Compromising real-world LLM-integrated applications with indirect prompt injection, arXiv preprint arXiv:2302.12173 (2023).arxiv.org/abs/2302.12173
- [3]Q. Zhan, Z. Liang, Z. Ying, D. Kang, InjecAgent: Benchmarking indirect prompt injections in tool-integrated large language model agents, Findings of the Association for Computational Linguistics: ACL 2024 (2024). ArXiv:2403.02691.arxiv.org/abs/2403.02691
- [4]E. Debenedetti, J. Zhang, M. Balunović, L. Beurer-Kellner, M. Fischer, F. Tramèr, AgentDojo: A dynamic environment to evaluate prompt injection attacks and defenses for LLM agents, arXiv preprint arXiv:2406.13352 (2024).arxiv.org/abs/2406.13352
- [5]A. Basak, P. Rathore, S. H. Nistala, S. Srinivas, V. Runkana, Universal adversarial attack on deep learning based prognostics, arXiv preprint arXiv:2109.07142 (2021).arxiv.org/abs/2109.07142
- [6]E. Debenedetti, I. Shumailov, T. Fan, J. Hayes, N. Carlini, D. Fabian, C. Kern, C. Shi, A. Terzis, F. Tramèr, Defeating prompt injections by design, arXiv preprint arXiv:2503.18813 (2025).arxiv.org/abs/2503.18813
- [7]T. Shi, J. He, Z. Wang, H. Li, L. Wu, W. Guo, D. Song, Progent: Securing AI agents with privilege control, arXiv preprint arXiv:2504.11703 (2025).arxiv.org/abs/2504.11703
- [8]H. An, J. Zhang, T. Du, C. Zhou, Q. Li, T. Lin, S. Ji, IPIGuard: A novel tool dependency graph-based defense against indirect prompt injection in LLM agents, arXiv preprint arXiv:2508.15310 (2025).arxiv.org/abs/2508.15310
- [9]V. Vovk, A. Gammerman, G. Shafer, Algorithmic Learning in a Random World, Springer, 2005.
- [10]J. Lei, M. G’Sell, A. Rinaldo, R. J. Tibshirani, L. Wasserman, Distribution-free predictive inference for regression, Journal of the American Statistical Association 113 (2018) 1094–1111.arxiv.org/abs/1604.04173
- [11]A. Javanmardi, E. Hüllermeier, Conformal prediction intervals for remaining useful lifetime estimation, arXiv preprint arXiv:2212.14612 (2022).arxiv.org/abs/2212.14612
- [12]R. F. Barber, E. J. Candès, A. Ramdas, R. J. Tibshirani, Conformal prediction beyond exchangeability, The Annals of Statistics 51 (2023) 816–845. ArXiv:2022.13415.arxiv.org/abs/2202.13415
- [13]L. Jeary, T. Kuipers, M. Hosseini, N. Paoletti, Verifiably robust conformal prediction, in: Advances in Neural Information Processing Systems (NeurIPS), 2024. ArXiv:2405.18942.arxiv.org/abs/2405.18942
- [14]Q. Zhan, R. Fang, H. S. Panchal, D. Kang, Adaptive attacks break defenses against indirect prompt injection attacks on LLM agents, arXiv preprint arXiv:2503.00061 (2025).arxiv.org/abs/2503.00061
- [15]K. Zhu, X. Yang, J. Wang, W. Guo, W. Y. Wang, MELON: Provable defense against indirect prompt injection attacks in AI agents, Proceedings of the 42nd International Conference on Machine Learning (ICML) (2025). ArXiv:2502.05174.arxiv.org/abs/2502.05174
- [16]K. Hines, G. Lopez, M. Hall, F. Zarfati, Y. Zunger, E. Kiciman, Defending against indirect prompt injection attacks with spotlighting, arXiv preprint arXiv:2403.14720 (2024).arxiv.org/abs/2403.14720
- [17]Z. Xu, Y. Guo, J. H. Saleh, Accurate remaining useful life prediction with uncertainty quantification: a deep learning and nonstationary gaussian process approach, arXiv preprint arXiv:2109.12111 (2021).arxiv.org/abs/2109.12111
- [18]L. Thil, J. Read, R. Kaddah, G. F. Doquet, Uncertainty quantification as a complementary latent health indicator for remaining useful life prediction on turbofan engines, arXiv preprint arXiv:2507.06672 (2025).
- [19]F. Jiang, X. Hou, M. Xia, Spatio-temporal attention-based hidden physics-informed neural network for remaining useful life prediction, arXiv preprint arXiv:2405.12377 (2024).arxiv.org/abs/2405.12377
- [20]Y. Wang, S. Liu, S. Lv, G. Liu, Meta-learning and knowledge discovery based physics-informed neural network for remaining useful life prediction, arXiv preprint arXiv:2504.13797 (2025).arxiv.org/abs/2504.13797
- [21]J. Xiong, Q. Fink, J. Zhou, Y. Ma, Controlled physics-informed data generation for deep learning-based remaining useful life prediction under unseen operation conditions, arXiv preprint arXiv:2304.11702 (2023).DOI
- [22]A. Siddique, R. K. Kundu, G. R. Mode, K. A. Hoque, RobustPdM: Designing robust predictive maintenance against adversarial attacks, arXiv preprint arXiv:2301.10822 (2023).arxiv.org/abs/2301.10822
- [23]O. Gungor, T. Rosing, B. Aksanli, DODEM: DOuble DEfense Mechanism against adversarial attacks towards secure industrial internet of things analytics, arXiv preprint arXiv:2301.09740 (2023).arxiv.org/abs/2301.09740
- [24]V. Vovk, D. Lindsay, I. Nouretdinov, A. Gammerman, Mondrian confidence machine, Technical Report, Royal Holloway, University of London (2003).
- [25]A. N. Angelopoulos, S. Bates, A. Fisch, L. Lei, T. Schuster, Conformal risk control, in: The Twelfth International Conference on Learning Representations (ICLR), 2024. URL: https://openreview.net/forum?id=33XGfHLtZg.
- [26]A. Saxena, K. Goebel, D. Simon, N. Eklund, Damage propagation modeling for aircraft engine run-to-failure simulation, in: International Conference on Prognostics and Health Management (PHM), 2008, pp. 1–9.DOI
- [27]B. Veloso, R. P. Ribeiro, J. Gama, P. M. Pereira, The MetroPT dataset for predictive maintenance, Scientific Data 9 (2022) 764.DOI
- [28]S. Matzka, Explainable artificial intelligence for predictive maintenance applications, in: Third International Conference on Artificial Intelligence for Industries (AI4I), 2020, pp. 69–74.DOI
- [29]K. Lee, K. Lee, H. Lee, J. Shin, A simple unified framework for detecting out-of-distribution samples and adversarial attacks, in: Advances in Neural Information Processing Systems (NeurIPS), 2018. ArXiv:1807.03888.arxiv.org/abs/1807.03888




