betaFeedback

WorksComputer Science

Moving Generality from Model to Modeler: LLM Agents for PHM on a Deployment-Style Benchmark

Abstract

Coding agents built on large language models (LLMs) now help develop many models published as general solutions. Should generality instead reside in the agent that builds a model for each new task? We examine this question in prognostics and health management (PHM), where every model must work on unseen equipment. Our deployment-style benchmark, NextUnit-Bench, covers 24 public datasets split into 58 folds that hold out units or operating conditions; each agent has two hours to deliver an executable predictor, then run on the hidden units. First, frontier agents outperform AutoML, which reaches less than half the best agent's score, and faithful implementations of published methods on four datasets, of which only 6 of 30 beat the strongest agent's own design; published accuracies, where reproducible, rest on the papers' own conventions, and a single convention, capping the remaining life of test engines, can halve the reported error. Second, the agents' advantage is a design made on each machine's data; once made, a plain-text plan of a few hundred words carries most of the gap between two frontier agents, and given a weaker agent's plan, the strongest agent falls to that agent's level, often to identical predictions. Before touching the data, however, it matters little whose plan an agent carries out, and domain toolkits appear to help neither: what sets the strongest apart is how much it learns from the data. Third, such designs reach only implementers that can execute them: given the strongest agent's designs, a locally deployable open-weight model delivers half as often, even when they are lightened, and scores no higher than without them. Generality, we argue, is not disappearing but moving, from the model to the modeler.

Introduction

Coding agents built on large language models (LLMs) have quietly become part of how models are developed in science and engineering. Researchers and engineers use them to build models faster, and often better, and then publish the resulting, seemingly superior general models as papers. This practice raises two questions. The first is about credit: in such a development process, how much of the contribution comes from the human developer, and how much from the agent? The second is about generality: once the contribution is published as a general model or algorithm, how much of its performance survives on a task that is similar but not the same? Taken together, they point to a more radical question. If a state-of-the-art agent can already build, for each new task, a model as good as a human developer’s, and do so faster, should generality reside in the agent, the modeler, rather than in an ever-growing stream of narrow, task-specific models?

Prognostics and health management (PHM) is a natural place to put this question to the test, because every PHM model eventually meets a machine it has never seen: the next bearing, an engine that has not yet failed, an air-handling unit in another building. A general model earns its name only if it keeps working there. We therefore examine agents the way models are actually used. An agent receives a task and the data of a set of machines, builds a model on its own within two hours, and delivers an executable predictor, which we then run on machines it has never seen. On 24 public PHM datasets, we pit frontier and locally deployable agents against faithful implementations of published methods and against AutoML.

The first result surprised us: the agents win. Published methods, implemented faithfully, and AutoML pipelines both fall behind what a general-purpose agent builds for the equipment at hand; of 30 implementations of 20 published methods on four datasets, only 6 beat the strongest agent’s own design. If an agent can out-model the literature on equipment it has only just met, where does its advantage come from? Is it a better programmer, or does it make better decisions?

To find out, we write down the design an agent delivered as a plain-text plan of a few hundred words, with no code, and hand it to another agent to implement from scratch. The answer is striking. Given a weaker agent’s plan, the strongest agent becomes the weaker agent: its scores fall to the weaker agent’s level, often down to identical predictions, even though it writes every line of code itself. Given the strongest agent’s plan, the weaker agent moves toward it, dataset by dataset. The advantage is a design made for this particular machine, tried on its data down to the hyperparameters; a published method is such a design too, only chosen for other machines. Little of it lies in heavy machinery: stripped of neural networks, ensembles, and specialized packages, the strongest agent’s designs keep most of their value. Could the strongest agent have written those words without the data? Asked to plan each task from its description, its documentation, and the layout of its files, without seeing a single value, its plans were worth only about a point and a half more than the weaker agent’s to the same implementer, against 6 to 13 points for plans written on the data, and toolkits of domain knowledge appeared to Z. Chen is with Laboratoire Génie Industriel, CentraleSupélec, Université Paris-Saclay, Gif-sur-Yvette, France (e-mail: [email protected]).

(Corresponding author: Zhiguo Zeng.)

Z. Zeng and A. Barros are with the Chair on Risk and Resilience of Complex Systems, Laboratoire Génie Industriel, CentraleSupélec, Université Paris-Saclay, Gif-sur-Yvette, France (e-mail: [email protected]; [email protected]). help neither. What sets the strongest agent apart is not what it knows but how much it learns from the data in front of it.

These few hundred words, however, reach only those who can carry them out. Handed the strongest agent’s plans, a locally deployable open-weight model delivers a working predictor only half as often as on its own and ends up no better than with no plan at all; even lightened, the plans remain beyond it. Yet what it does deliver is no worse than what it builds on its own. What a local model lacks is not knowledge, but the capacity to act on it. And because the value is made on the data, which in many plants may not leave the site, what local deployment needs is a capable modeler beside the data, not more knowledge from outside.

These findings bear on a question that PHM has rarely asked. Transfer learning and domain adaptation are among the most popular topics in the field, and generalization receives a great deal of attention, yet we seldom ask what we really need it for. Is it to improve accuracy, or to save cost? The history of the field hints at an answer. PHM moved from signal processing to machine learning and then to deep learning, and each step promised to spare experienced engineers the work of hand-crafting features for every machine. Had there been countless such engineers, enough to tailor feature extraction to every machine, would this progression have happened at all?

LLM agents are beginning to make that counterfactual real. Systems built on LLMs and agents keep getting cheaper, while their accuracy and capability keep growing, so much so that we can imagine an agent writing custom models and algorithms for every individual physical asset. Do we then still need generalization in the traditional sense? Our results suggest that generality is not disappearing but moving: from a model expected to work everywhere to a modeler that builds the right model for each machine. We make this case through four contributions:

  1. NextUnit-Bench, an open deployment-style benchmark (https://github.com/JialingRichard/nextunit-bench) that evaluates agents the way models are used: built on one set of machines, delivered as a program, and run on machines never seen;

  1. evidence that, on this benchmark, frontier agents outperform AutoML averaged over 24 datasets, that the strongest of them outperforms faithful implementations of published methods on average on three of four datasets, though the best of those methods beat it on two, and that published accuracies depend on the papers’ evaluation conventions;

  1. plan transplant and plans written without the data, which show that the agents’ advantage is a design made on each machine’s data, once made, fits in a plain-text plan of a few hundred words and travels between agents able to execute it; that before touching the data, it matters little whose plan an agent carries out; and that neither heavy machinery nor domain toolkits are its source;

  1. a diagnosis of locally deployable agents, which struggle to execute such designs even when they are lightened, yet build them no worse when they do: capability buys the probability of completing a design, not its quality.

Related Work

LLM Agents for Machine-Learning Engineering

LLM agents that build machine-learning pipelines tend and are now measured on benchmarks drawn from Kaggle competitions, such as MLE-bench [1], and built on scaffolds that search over candidate code, such as AIDE [2]. MLE-Dojo [3] provides interactive environments for training such agents, TimeSeriesGym [4] extends the setting to time-series tasks, and recent work finds that, with a strong model, a minimal single-session coding agent does as well as elaborate scaffolds [5], which is why we use plain command-line agents. These benchmarks score predictions on fixed splits of competition-style data. None of them asks whether a delivered pipeline keeps working on physical units it has never seen, the question on which PHM stands or falls.

LLMs and Agents in PHM

In PHM, LLMs have so far been evaluated mostly as assistants rather than as modelers. PHM-Bench [6] scores large models on domain knowledge, algorithm generation, and task optimization across PHM tasks; PHMForge [7] and AssetOpsBench [8] have agents call tools that wrap published algorithms or orchestrate agents for asset operations; agents have been asked to diagnose a simulated appliance step by step from its sensors [9]; LLMs placed above existing diagnostic tools fail to exploit them consistently [10]; and a multi-agent framework fuses bearing-domain knowledge into an LLM’s reasoning and selects feature pipelines by signal characteristics, without updating model weights [11]. A recent review discusses foundation models for PHM [12]. In all of these, the models themselves are built by humans or provided as tools. In ours, the agent builds the model from scratch, delivers it, and is judged by how it runs on equipment it has never seen.

Reproduction and Evaluation Conventions in PHM

Evaluation conventions are known to shape reported results in PHM. On CWRU, segments cut from the same recordings end up in both training and test sets, which inflates accuracy [13], and remaining-useful-life results on C-MAPSS [14] are customarily reported against capped labels. Agents have recently been used to reproduce under-specified methods in machine health intelligence [15]. We go one step further and let the same agent implement each published method twice, once under the paper’s own protocol and once under deployment, which separates the effect of the convention from that of the implementation.

A Deployment-Style Benchmark

Our benchmark, NextUnit-Bench (NextUnit for short), asks one question of every method: given the data of some machines, does what you deliver work on machines you have never seen?

Tasks and Folds

The benchmark comprises 24 public datasets (Table 1) in four families: condition classification, remaining useful life (RUL), degradation and health estimation, and anomaly detection or failure prediction. The assets range from bearings, gearboxes, and milling cutters to battery cells, turbofan engines, wind turbines, oil wells, and trucks. Every dataset is split by physical unit, such as a bearing, a cell, a cutter, an engine, or a well, so that no test unit is seen during development; where a dataset has no independent units, as for CWRU, SEU, and the UCI hydraulic rig, whole operating conditions are held out instead, and official splits are kept where they exist. This yields 58 folds.

Protocol

An agent works as an engineer would on a new assignment. It receives a task description, which states the inputs, the target, the history that may be used at prediction time, the metric, and whatever physical information is available, but not the name of the dataset. It also receives the development units with their labels, a shell, and a Python environment. It then has two hours of wall-clock time, its own reasoning included, and may use the internet as an engineer would, but not to obtain evaluation data, labels, or existing answers. During development it may submit its predictor to the evaluator for a check that it runs, which reports errors such as an empty output but nothing about the hidden units. At the end it must deliver an executable predictor with a single entry point. Once the deliverable is sealed, an evaluator runs it offline on each hidden unit in a fresh process Figure 1, either in streaming mode, where each prediction may use only the records received so far, or in batch mode. The agent never sees the hidden labels or the scoring code, and nothing it reports about itself is taken on trust. A deliverable that does not run counts as a failure.

Figure 1. Deployment-style evaluation. The agent sees the task description and the development units, works for two hours in a sandbox, and delivers a sealed, executable predictor. The evaluator runs it offline on each hidden unit; the hidden units, their labels, the scoring code, and the score itself remain invisible to the agent.

Scoring

Errors on different datasets are not comparable, so every fold is scored against a fixed baseline: the average loss of a random forest on generic time- and frequency-domain features and of a small one-dimensional convolutional network on the raw inputs, neither tuned to the task. With EE the loss of a method and BB that of the baseline (one minus the metric for accuracy, balanced accuracy, ROC-AUC, and average precision), the score is

S=100max⁡(0,1−E/B),(1)S = 100\max(0, 1-E/B), \tag*{(1)}

the share of the baseline’s error that the method removes: S=50S = 50 means the error has been halved, and a failure scores zero. SS is best read comparatively: on a few folds the fixed baseline does worse than predicting a constant, which itself scores 3.9. Scores are averaged over the folds of a dataset and then over the 24 datasets with equal weight. Because SS does not register how much worse than the baseline a method can be, we also report how often a method fails or delivers a predictor worse than the baseline. On N-CMAPSS, the evaluator first omitted an input file that the task promised; all delivered predictors were rerun through the same public interface once it was fixed.

Agents and References

We evaluate four frontier agents, models too large to run on a plant’s own hardware, GPT-6 Astra, Kimi K3, DeepSeek V4.1-Flash, and GPT-6 Luna, each run through the Codex command-line agent at its highest reasoning setting, and two open-weight models small enough for local hardware, Qwen3.6-35B-A3B and Gemma 4, run through OpenCode. All runs took place in September and October 2026, through Codex 0.156.1 and OpenCode 1.19.0 (Appendix B); on average, a run of the strongest agent took 32 minutes of active time and about 2.8 million tokens. As references we use the fixed baseline, two AutoML systems with and without automatic feature extraction, and faithful implementations of published methods.

Two independent audits checked the pipeline, one tracing each result from the paper back to the code and the other following the data from the raw files to the scores. Both reproduced the main scores to within 0.01 and the baseline scores to within a relative 2×10−62 \times10^{-6}, confirmed that development and hidden units do not overlap, and found no leak that changes a conclusion; the shortcuts they found are reported in Section VII-C.

Agents Versus Published Methods and AutoML

On this benchmark, the agents come out ahead of every reference we tried.

Ranking and Stability

The four frontier agents remove between a third and nearly half of the baseline’s error: SS ranges from 30.8 for Luna to 43.0 for Astra (Fig. 2). The ranking is stable. Complete re-runs under identical conditions change no agent’s average by more than 1.2 points and leave the order unchanged, and re-runs of five of the plan conditions of Section V move none by more than 2.2. The order also survives the obvious objections to our score (Table II): it is the same without the three datasets whose collection or preparation left a shortcut (Section VII-C) and on the 21 datasets with independent units, and when scores may fall below zero, only Astra and Kimi swap places, within each other’s noise. Nor does it hinge on the fixed baseline: under eleven other choices, from either of its two models alone to the

DatasetAssetTaskUnitsFoldsModeMetric
Condition classification
Paderborn [16]Rolling bearing4-class condition323BatchAccuracy
CWRU [17]Rolling bearing4-class fault40a40^{a}4BatchAccuracy
SEU [18]Gearbox5-class fault10a10^{a}2BatchAccuracy
UCI hydraulic [19]Hydraulic rigValve condition3a3^{a}3BatchBalanced accuracy
Tennessee Eastman [20]Chemical processb^{b}Fault class21001BatchAccuracy
Petrobras 3W [21]Oil wellEvent class403BatchBalanced accuracy
AHU [22]Air-handling unitFault detection63BatchBalanced accuracy
SCANIA Component X [23]TruckTime-to-repair class40c40^{c}1BatchBalanced accuracy
Remaining useful life
XJTU-SY [24]Rolling bearingRUL153StreamMAE
PRONOSTIA [25]Rolling bearingRUL171BatchMAE
IMS [26]Rolling bearingRUL43StreamMAE
C-MAPSS FD004 [14]Turbofan engineb^{b}RUL4971BatchRMSE
N-CMAPSS DS02 [27]Turbofan engineb^{b}RUL91StreamRMSE
PHM Europe 2020 [28]FilterRUL323StreamMAE
MATR [29]Li-ion cellCycle life1241One-shotMAE
Degradation and health estimation
MATWI [30]Milling cutterTool wear173BatchMAE
PHM 2010 [31]Milling cutterFlank wear33StreamMAE
NASA randomized battery [32]Li-ion cellCapacity283StreamMAE
NASA battery [33]Li-ion cellCapacity333StreamMAE
CALCE [34]Li-ion cellCapacity123StreamMAE
NASA CFRP [35]Composite couponStiffness33StreamMAE
Anomaly detection and failure prediction
MIMII DUE [36]Machine soundAnomaly detection451BatchROC-AUC
CARE to Compare [37]Wind turbineAnomaly screening363BatchROC-AUC
Backblaze [38]Hard disk7-day failure warning6d6^{d}3StreamAverage precision

Table 1. The 24 datasets of the benchmark, grouped by task family.

a^{a}Records or operating conditions; the dataset has no independent units. b^{b}Simulated. c^{c}Batches of distinct vehicles. d^{d}Pools of drives.

strongest AutoML pipeline, the four frontier agents keep their order in all but one, and the main comparisons of this paper keep their sign (Appendix D). Individual datasets are much noisier: two runs of the same agent can differ by more than 30 points on a single dataset, a point we return to in Section VI. Nor is the strongest agent infallible; nearly one run in ten delivers a predictor worse than the baseline.

Memory of public datasets does not explain the ranking either, although the agents do recognize them: asked to name the dataset from the task documentation alone, Astra identified 22 of the 24, and Luna and DeepSeek 18 each. What recognition offers, however, is the literature, and the literature is not what wins: faithful implementations of published methods lose to the agents’ own designs (Section IV-B). We class a dataset as well known if it is a standard benchmark with many published results; the other eight, classed after the runs, are less known (Appendix B). Against AutoML with generic features, the strongest agent gains about as much on the five less-known datasets whose collection or preparation left no shortcut (CFRP, MATWI, the NASA randomized battery, PHM Europe 2020, and SCANIA) as on the well-known ones (24 and 23 points), and the other frontier agents keep a lead there too, mostly a smaller one. The two agents whose reasoning we can read named the source dataset in about two of three runs, yet those runs did not score detectably higher, relative to the other agents on the same fold, than runs that did not name it.

Published Accuracies Do Not Travel

A natural reference for an agent is the literature itself. We selected 20 papers on four benchmark datasets, C-MAPSS, N-CMAPSS, Paderborn, and Tennessee Eastman, by a fixed rule: on each dataset, the most cited method papers since 2019 that name it and train on labeled data, plus the most cited since 2024, with three N-CMAPSS papers taken from a recent reproduction collection [15]; Appendix E lists them. Eighteen of the 20 are IEEE journal papers, because copies from other publishers could not be retrieved automatically, and three of the five Paderborn papers come from one research group. The strongest agent read each paper and implemented its method faithfully on our folds, within the same two hours, using the paper’s own results only to understand the method. An independent LLM judge, Claude Opus 5.5, rated all 30 implementations as faithful. Yet only 6 of the 30 implementations, from 6 of the 20 papers, beat the agent’s own design for the same fold. On average, the published methods fall short on C-MAPSS, N-CMAPSS, and Paderborn and draw level on Tennessee Eastman; the best of them, however, beat the agent’s design on Tennessee Eastman and N-CMAPSS (Appendix E).

AgentSS (24)SS, floor −100SS, without shortcut setsSS, 21 unit setsFail (%)Worse (%)
Astra43.0 (1) [32.4, 53.8]33.8 (2) [15.5, 50.0]40.4 (1) [29.4, 52.0]37.9 (1) [28.3, 46.8]0.08.6
Kimi39.7 (2) [29.2, 51.0]37.7 (1) [26.6, 49.5]38.4 (2) [26.6, 50.7]34.7 (2) [25.1, 44.1]1.78.6
DeepSeek36.1 (3) [25.7, 46.9]30.9 (3) [18.7, 43.5]34.7 (3) [24.2, 46.0]31.0 (3) [22.6, 39.7]0.010.3
Luna30.8 (4) [19.4, 43.1]17.5 (4) [−2.3, 35.7]29.2 (4) [17.5, 41.9]24.4 (4) [15.0, 34.7]1.720.7
Qwen3.614.3 [5.9, 24.8]0.8 [−13.5, 15.8]14.4 [5.4, 25.7]8.3 [3.6, 13.6]29.327.6
Gemma 416.5 [9.2, 25.4]0.0 [−15.6, 14.6]16.7 [9.3, 25.5]12.4 [7.1, 18.1]3.432.8

Table II. Agent scores under alternative choices: over all 24 datasets; with scores allowed down to −100; without the three datasets whose collection or preparation left a shortcut (AHU, Petrobras 3W, and CARE; Section VII-C); on the 21 datasets with independent units; and the shares of runs that failed or delivered a predictor worse than the baseline, over the 58 runs of each agent’s main experiment. In the floor column, failures still score zero. Ranks of the frontier agents in parentheses; 95% intervals from a bootstrap over datasets.

Were the implementations simply poor? Under the papers’ own protocols, and with four hours instead of two, the same agent reproduces the reported numbers in eight of fourteen attempts: six of eight on C-MAPSS (four methods on two subsets), one of two on Tennessee Eastman, the single attempt on N-CMAPSS, and none of three on Paderborn. A single, ordinary convention can make the difference. C-MAPSS papers, like our benchmark, score each test engine at its last observed cycle, but they cap its remaining life at 125 cycles before computing the error. Under that convention, three of the four implementations on our engines come close to the published errors, at 13.7 to 18.7 cycles; implemented for the true remaining life, as deployment requires, the same four methods err by 31 to 37 cycles on the very same engines (Figure 3). The gap is not only early-life error: on engines within 125 cycles of failure, where capping changes nothing, the implementations still err by 25 to 34 cycles. On Paderborn the gap is starker. Holding out one whole bearing per class, as we read the papers’ descriptions, methods reported at 99.7–99.9% accuracy reach 58–67%, and every one of them mistakes the held-out inner-race bearing for an outer-race fault; we could not obtain the authors’ own splits to check this reading. Published accuracy tells us how well a method fits a protocol; it does not tell us how well it fits the next machine.

Figure 3. Faithful implementations of published methods, under the papers’ own protocols and under ours. (a) C-MAPSS FD004, with DA-TCN [39], DSFormer [40], a two-stream Bi-LSTM [41], and MSBLS [42]: implemented under the papers’ protocol, which caps the remaining life of test engines at 125 cycles, three of the four come close to their published errors; implemented and scored on the true remaining life, as deployment requires, the same methods err about twice as much. For DA-TCN the two protocols give nearly the same error, so its two markers are drawn slightly apart. The fifth C-MAPSS method of Appendix E, a dual-task LSTM, was not reproduced under the papers’ protocol and is omitted. (b) Paderborn, with three fusion networks [43], {citep}[44], {citep}[45]`: with one bearing per class held out, as the papers describe, the implementations reach none of the reported accuracies.

AutoML and Foundation Models Are Not Enough

A second objection is that any automated search would do as well. It does not. Given the same inputs as the fixed baseline and a two-hour search target, AutoGluon and FLAML reach SS of 11.6 and 13.5, closer to the local open-weight agents than to any frontier one. Their inputs, the baseline’s own, subsample long recordings and cap the number of training rows, and a failed fit scores zero, as it does for the agents; scoring a failed fit as a constant prediction instead raises both by one to two points. A bank of generic signal features lifts both to 18.7, and tsfresh features [46] lift FLAML to 28 on seven signal datasets, where Astra scores 57 on the same folds. AutoML also tends to overrun: nearly every AutoGluon fit took longer than two hours. Overruns were allowed and scored; only a fit stopped by the cluster’s job limit counted as a failure. Generic features close the gap where the problem is easy, taking CWRU from 0 to above 90, but not where it is hard: on the hydraulic rig, the IMS bearings, Paderborn, and SEU, AutoML stays below 15 while Astra scores between 21 and 100. What the agents add is not search but judgment about the machine at hand.

Nor does a general model. Time-series foundation models are the closest PHM has to the general models of language and vision. We fine-tuned two whose published pretraining corpora contain none of our datasets, MOMENT [47] and Chronos2 [48], on every fold, with the same downsampled inputs as AutoML and one fixed pipeline, the way a general model is meant to be used; tuning them to each dataset might lift them, but that is a modeler’s work. They reach SS of 12.5 and 11.2, level with AutoML without features and far below every frontier agent (Figure 2). They do well on some bearing datasets, CWRU and XJTU-SY among them, and score below 2 on ten or more others, including C-MAPSS and Tennessee Eastman. The agents seem to agree: a foundation-model library was installed in their environment, yet no agent in any of our runs imported one, although they did use pretrained audio and vision backbones. The next section asks where the agents’ judgment lives.

Figure 2. Score SS over the 24 datasets, with 95% intervals from a bootstrap over datasets. Frontier agents remove a third to nearly half of the baseline’s error; local open-weight agents, AutoML, even with generic features, and time-series foundation models (TSFM) fine-tuned on each fold remain below 20. AutoML was not run on MIMII DUE and scores zero there; the fixed random forest is one of the two models that make up the baseline.

Where the Agent's Advantage Lives: Fit, Not Size

Section IV leaves a question open. When an agent’s design beats published models on a machine it has just met, is the agent a better programmer, or did it make better choices for that machine? We answer by transplanting designs from one agent to another, by having agents design without the data, and by stripping designs of heavy machinery.

Design

After a run, the method an agent delivered on a fold is written up as a plan by a separate session of GPT-6 Astra, which reads the delivered code and the commands of the development run under fixed rules but never the data. A plan has seven short sections, from task framing and features to model, validation, and inference, and stays within 900 Chinese characters, about 500 English words. It contains no code and no number fitted to the data, but it states every choice the agent made, down to the hyperparameters it selected by trial on the fold’s development data. A plan is, in effect, a model specification without its weights: much like the method section of a paper, except that it was written for one machine (Appendix A). A second agent receives the plan, read-only, together with the usual task and is asked to implement it, deviating only where it conflicts with the task; it is not told whose plan it is. We cross the strongest and the weakest of the four frontier agents, GPT-6 Astra and GPT-6 Luna, in both directions, so that plans move across the widest gap; these two carry the later experiments. As a larger and a smaller model from the same developer, the two likely share much of their training and style and differ mainly in capability, which isolates capability for the comparison; Section VI hands the same plans to a local model. Plan runs use the OpenCode harness, and their controls are runs without a plan in the same harness, which score within 1.2 points of the main runs through Codex (44.2 against 43.0 for Astra, 31.0 against 30.8 for Luna).

Fit Travels, Good and Bad

Given Astra’s plans, Luna moves toward Astra (Figure 4). On average its score rises from 31.0 to 36.8, closing nearly half of its gap to Astra, and the pattern across datasets is unmistakable: on the 18 datasets where Astra was the better modeler, Luna gains 12.2 points; on the 6 where Astra was worse, Luna loses 13.3, following Astra down.

Figure 4. Fit travels, good and bad. Each point is a dataset: how much better the plan’s author scored than an independent run of the implementer (horizontal), against how much the implementer’s score moved, relative to its own run, when it followed the plan (vertical). Both transplants move toward the plan’s author, upward or downward. Slopes are fitted through the origin (Luna following Astra, 0.58; Astra following Luna, 0.82) with 90% bootstrap intervals; noise in the independent runs biases them toward zero. Hollow markers show the AHU dataset, whose time shortcut travels with the plans.

The reverse transplant is starker. Given Luna’s plans, Astra falls from 44.2 to 31.5, about half a point from Luna’s own score; it drops on 17 of 24 datasets, by as much as 44 points, and where Luna had been the better modeler, Astra rises with it. On 16 of the 44 folds where the two agents’ scores are not both at the floor or the ceiling, Astra’s predictions are identical to Luna’s, and on 3 more nearly so, although it wrote every line of its code anew, shares only 1–3% of its lines with Luna’s code, and could not see Luna’s run. It also finished in a median of 12 minutes, against 42 for its own runs in the same harness. Run a second time, each transplant scored within a point of the first (37.8 and 31.5).

What is striking is not that a specification can be reimplemented, but how little it takes. A plain-text plan of a few hundred words, written for one machine, carries most of the gap between two frontier agents, and once the design is fixed, a stronger implementer adds almost nothing to it, while a weaker one realizes much of it. A published method is such a specification too; these plans differ only in having been chosen on the machine they are applied to. Following a plan does not by itself cost an implementer anything: following its own plans, even lightened, Astra scored 42.6 against 44.2 without a plan (§ 5-D). Astra fell with Luna’s plans because of what they said; and the half of the gap that Luna left open with Astra’s plans lies in carrying them out, not in what the plans lost (Section VI).

In parentheses, a second run of the same condition; unless stated otherwise, the text uses the first run.

Close Before the Data

Could the strongest agent have written those few hundred words without the data? We asked each frontier agent to write a plan for every fold from the task description, the machine’s documentation, and a card listing the layout of the data (its files, fields, shapes, and sampling rates) but not a single value. A fresh session wrote each plan under the same template, with no tools and no access to files; both agents then carried out every plan on the data, under the same instructions as before.

Before touching the data, it hardly mattered whose plan an agent carried out (Table III). Holding the implementer fixed, Astra scored 29.5 with its own plans written without the data and 28.0 with Luna’s, and Luna 27.6 with Astra’s and 26.0 with its own: about 1.5 points either way. Second runs give 1.4 for Astra and, against a rerun of Luna’s own plans, 3.8 for Luna. Plans written on the data were another matter: to the same implementer, Astra’s were worth 5.8 points more than Luna’s when Luna carried them out and 12.7 points more when Astra did. Designing before seeing the data cost Astra 14.7 points and Luna 5.0; given the same data, the stronger agent made far more of it. Given to Luna as advice rather than as instructions, Astra’s plans changed little. A plan written on the data pins the model down: following Luna’s original plans, Astra reproduced Luna’s predictions on 16 of 44 folds. A plan written without the data leaves more to its implementer: two agents carrying out the same such plan made identical predictions on only 2 to 5 of 41 to 44 folds, although their scores differed by just 2 points.

Plan byData seenLunaAstra
Astrayes36.8 (37.8)44.2a^{a}
Lunayes31.0a^{a}31.5 (31.5)
Astrano27.629.5 (30.0)
Lunano26.0 (23.8)28.0 (28.6)

Table III. Score by who wrote the plan, whether its writer had seen the data, and who carried it out (SS over 24 datasets).

Knowledge carried the plans furthest where the field knows the machine. On the 16 best-known datasets, the plans written without the data came within 8 to 12 points of Astra’s own designs; on the eight less-known ones, they fell 27 to 30 points short (15 to 23 without the shortcut sets; Section VII-C). Knowledge without the data, at about 28, search without judgment, at 12 to 19 for AutoML, and judgment applied to the data, at about 44 for the strongest agent, are three different things. What sets the strongest agent apart is not what it knows but how much it learns from the data in front of it.

Size Is Not the Source

We then asked Astra to lighten its own plans under written rules: keep the task framing, features, validation, and selected hyperparameters; replace packages that are not preinstalled with scikit-learn; merge ensembles into a single model; drop neural networks; and keep each training run under ten minutes on four CPUs. Following these lightened plans, Astra scored 42.6, against 44.2 without any plan. Only 6 of its 58 original designs had used a neural network at all; most combined several models, and where a design leaned on such machinery, lightening it cost some points. But most of the value survived. What carries the score is the fit of a design to its machine, not the size of its model.

Only the Design Moves the Score

If the advantage lies in fit, capability added from outside should not move it, and it does not. Over the project, we gave the frontier agents seven toolkits, tried in fifteen agent–toolkit combinations (Appendix C), each on the datasets it applies to: a public predictive-maintenance skill from Amazon Web Services [49], an open-source predictive-maintenance server with diagnostic workflows [50], tsfresh, the anomaly-detection library PyOD [51], NASA’s prognostics packages ProgPy [52], and feature components and validation tools of our own. No toolkit helped every agent it was given. On average, they changed the score by −0.7 points, and the only clear change was a loss: Astra lost tsfresh features in three of four runs and scored 4.8 points lower (Figure 5a). Two of the toolkits never made it into a final model at all. Against all of this, the plan transplants stand apart: a few hundred words moved the same agents by +5.8 and −12.7 points. Designing without the data moved Astra most of all, by −14.7 points, and Luna by −5.0 (§ 5-C).

Figure 5. What moves the score. (a) Seven toolkits, tried in fifteen agent–toolkit combinations, leave the frontier agents’ scores where they were; swapping the plan moves them by as much as 12.7 points, up or down (circles), and carrying out a plan written without the data costs the strongest agent 14.7 (squares). (b) For local open-weight agents, nothing closes the 18-point gap to the weakest frontier agent (dashed), and two runs of the same configuration differ by 7.5 points; the shaded band spans four standard runs of Qwen3.6. Changes are measured against the agent’s own run without the intervention in (a) and against the mean of the four standard runs in (b). Intervals are 95% from a paired bootstrap over datasets and do not include run-to-run variation.

Only to Implementers That Can Execute Them

Models small enough to run inside a plant are where PHM agents would be most useful, and they are far behind. Qwen3.6, running on a single workstation, scores 14.3 in its main run, against 30.8 for the weakest frontier agent and on a par with AutoML (Figure 2); it fails on 17 of 58 runs, almost always by running out of time. Gemma 4 fails differently: it delivers on 56 of 58 runs, but what it delivers is weak, and its score of 16.5 is barely higher.

Plans Make Them Deliver Less

Handing them the strongest agent’s design does not help. Given Astra’s plans, Qwen3.6 delivers a working predictor on only 32% of runs, against 57% without a plan (Figure 6a), and its score falls from 12.6, the mean of its four runs without a plan, to 9.3; two in three of its runs end in a timeout, lost in code, dependencies, and repair loops. Luna’s simpler plans hurt far less: Qwen delivers on 53% of runs and scores 14.7 (Figure 6a). What matters is the load of a plan, not its author. We index load by five features of the author’s own implementation: the number of models, external dependencies, the use of a neural network, compute-heavy time, and lines of code. On light and middle plans, Qwen delivers as often on Astra’s as on Luna’s, and on light plans at least as often as with no plan at all; but Astra’s plans pile up in the heaviest third, 64 of 116 against 12 of Luna’s, and there Qwen delivers on only one run in five. Nor does lightening rescue it. Given the lightened plans of § 5-D, which it read in almost every run, Qwen still delivered on only 31% of runs and scored 9.6. The trouble is not hardware either: the drop persists on folds whose source run used no GPU.

Figure 6. Plans reach only implementers that can execute them. (a) Share of Qwen3.6’s runs that deliver a working predictor within the two hours, without a plan (two runs) and with Luna’s or Astra’s plans (two runs each; thick bars). Thin bars split each plan source by third of plan load, cut over the plans of both sources; the dashed line marks delivery without a plan, and whiskers are 95% Wilson intervals. (b) Each square is one Qwen run on one fold, 116 per plan source. An implementer lands a plan when it delivers and reaches the plan author’s own result; a run that does not deliver does not land. Dark squares mark folds where the frontier implementer (Luna for Astra’s plans, Astra for Luna’s) landed the plan, light squares folds where it did not, and orange marks Qwen’s landings: 21 of its 23 fall on dark squares. Hollow squares are not compared, because both implementers scored 100, both scored 0, or the plan’s author scored 0, so landing carries no information.

Capability Buys the Probability of Completion, Not Its Quality

Yet what Qwen does deliver is no worse than what it builds on its own: on folds where it delivers both with and without Astra’s plans, its scores differ by about one point, and the lightened and original plans give the same quality. What separates it from the frontier agents is whether it completes a design, that is, delivers a working implementation within the two hours, not how well. Success is also nested: Qwen lands a plan, delivering it and reaching its author’s result, almost only on folds where a frontier implementer lands it too (Figure 6b). Capability, in other words, buys the probability of completing a design, not the quality of what is completed.

Nothing Else Closes the Gap

Nothing we tried closed the gap of about 18 points between Qwen3.6’s standard runs and the weakest frontier agent (Figure 5b). Higher-precision weights, from 4-bit to 8-bit to full 16-bit, moved the score a few points in directions that did not repeat. Giving the agent a GPU changed little, because it barely used one. Doubling the time to four hours cut failures from 23 to 12 of 58 runs, against a run made at the same time, but left the score where it was. A workflow skill that guides the agent step by step helped by 6.4 points in one run and not at all in its repeat. That repeat is the most instructive number in this section: the same configuration, run twice, differed by 7.5 points, more than any lever we pulled. Comparisons of single runs of local agents, ours included, should be read with this in mind.

Reading its failures shows what is missing. Of 100 failed runs we read in full, half were slow but making progress: a single training or feature command consumed most of the budget, or the agent tuned methods before securing a version that worked. A third were stuck in loops, nearly all on the same complaint from the evaluator, an empty output, because the agent never worked out how its predictor would be called. Repetitive text caused none, and 45% of the runs that timed out never once submitted a deliverable for checking. What a local model lacks, then, is not knowledge of what to build: handed the best design, even one stripped to standard tools, it delivers less. It lacks the engineering judgment to build that design within the time it has: estimating what a step will cost, securing a working version first, and learning the interface it must serve. These findings hold at our fixed budget of two hours, which sets where the threshold lies.

This is also why local modelers are worth improving even if they never match frontier ones. In plants whose data may not leave the site, engineers already work the way our plans written without the data were made: they bring knowledge in from outside and apply it inside. On its own, such knowledge was worth no more than what a weaker frontier agent achieved with the data, and given as advice rather than as instructions, it changed little (§ 5-C). The rest of the value is made on the data, and only a modeler beside the data can make it. A local model need not match a frontier one to be worth having; what it needs is not more knowledge but the capacity to act on the data in front of it.

Discussion

What Counts as a Contribution in the Agent Era

The worry that researchers overfit their designs to the nominal test sets of benchmarks is decades old [53], [54], [55]. In the agent era it becomes acute. Picture a researcher who wants better numbers on a few datasets. With an agent at hand, trying one more popular module, and then another, costs minutes rather than weeks; sooner or later some combination improves the results on the researcher’s own test split, and yet another XXX-Net is published as a general model. Such a model is overfitted, not to its training data but to a protocol, and every one of them makes it harder for the field to see which ideas carry over to the next machine. Our results show how thin the line can be: a single, ordinary convention, capping the remaining life of test engines, can separate published C-MAPSS errors from errors roughly twice as large on the very same engines (Section IV-B).

To treat an agent as a researcher is to make research itself the object of study. An agent can be run again, denied the data, handed another agent’s plan, or given a toolkit, and every choice it makes leaves a trace; no such experiment can be run on the researchers whose methods fill our journals. What the agents did, we therefore read as a magnified picture of the field. They recognized the famous datasets and knew their literature, yet the published methods did not travel; they fitted whatever they were given, the way the data were collected included; and their own validation could confirm only what their data allowed them to see. These are not the agents’ failings alone. They are the field’s, made visible and measurable.

Agents have greatly multiplied what a researcher can do. Yet researchers, like the agents themselves, have little sense of how good the things they make really are. This is not a personal failing but a structural one: a researcher’s own split, like an agent’s own validation, can only confirm what its data allow it to see. It is also why benchmarks exist; they supply the self-knowledge that neither researchers nor agents possess on their own.

In PHM, the problem is compounded by a scarcity of data that is easy to overlook. Industrial data appears abundant, yet the physical units behind it are few. CWRU, still among the most widely used datasets, records artificially seeded damage on a handful of bearings, and its leaderboards passed 99% long ago [13]. Unlike images or text, which humans perceive on a common scale, a PHM signal means nothing without its sampling rate, its sensor, and its machine; two waveforms of the same shape can mean entirely different things. Each dataset therefore covers a narrow distribution, and no single dataset can tell how a model will fare in the field. This is also one reason why the apparent ocean of industrial data has not yet yielded a foundation model that does for PHM what large language models did for text. What the field needs is a common benchmark that spans many distributions: shared, so that differences in evaluation no longer masquerade as differences in methods, and diverse, so that generality is actually put to the test. Such a benchmark can test the generality of a model or, as in this paper, of a modeler.

What if the domain knowledge built into frontier models already rivals, or exceeds, that of most human experts? We did not set out to measure this, but our results point that way. Before touching the data, the strongest and a weaker frontier agent designed within a few points of each other (§ 5-C), as if both stood on nearly the same plateau of domain knowledge; domain toolkits and skills written by people added nothing to either on average (Figure 5a); and the agents recognized most datasets from their documentation alone. Much current work measures the PHM knowledge of general models or adds to it [6], [11]. For frontier models, that knowledge may already be in place, and further skills may no longer help. The plateau has an edge, however: knowledge carried furthest on well-known machines and much less far on unfamiliar ones. What is scarce is not knowledge but what the strongest agent did better than the rest, learning from the data of one machine, and the means to tell whether what it learned was right.

Our results echo Sutton’s bitter lesson [56]: in the long run, methods that leverage computation beat methods built on human knowledge. Knowledge written in by people did not move the agents. Toolkits left their scores where they were, published methods lost to their designs, and plans written from knowledge alone, without the data, scored about 28. What set the strongest agent apart was what it found in the data. AutoML is no exception to the lesson: it searches, but over a menu that people wrote. At the level of the model, the opposite lesson holds. The no-free-lunch theorems state that, averaged over all problems, no optimizer beats another, so any advantage comes from matching the structure of a problem [57], and designs fitted to each machine did beat the general ones. The agent is a general method whose products are specialized ones. Moving generality from the model to the modeler lets both lessons hold at once.

For researchers, this changes what is worth contributing. When an agent can produce a new “what”, a new architecture or a new model, in an afternoon, the contributions that move a field forward are the “why” and the “how”: why a method works on one machine and fails on the next, and how to tell the difference before it is deployed. A gain on one’s own split entertains its author; an explanation that holds on the next machine moves the field. Building a model for each machine is not the same as overfitting it: overfitting tunes a model to the very data on which it is judged, whereas the designs here were chosen on development units and judged on units no one had seen.

Capability as Strength, Design as Stress

Our observations fit a lens familiar to reliability engineers. In stress–strength interference, a component fails when the stress it meets exceeds its strength [58]; in item response theory, a person answers an item correctly when ability exceeds difficulty [59]. Read an implementer’s capability θ\theta as strength and the demand cc of a design as stress, and the score the implementer can expect from that design becomes

Sˉ=Φ(θ−cσ)Q,(2)\bar{S} = \Phi\left(\frac{\theta-c}{\sigma}\right)Q, \tag*{(2)}

the chance that the design is completed, with Φ\Phi the standard normal distribution function and σ\sigma the spread of both, times QQ, what the completed design is worth. In this light, three of our findings fall into place. Capability enters only the first factor: it buys the chance of completing a design, while the worth of a completed design belongs to the design. Completions are nested, because a design that stops a strong implementer stops a weaker one too. Re-runs show the shape of Φ\Phi directly: following Luna’s plans, far within its strength, Astra landed or missed the same folds in both runs on 56 of 58; following Astra’s heavier plans, near its strength, Luna did so on only 47, and 11 folds switched between runs. Far from the threshold the outcome is settled; near it, it is close to a coin toss. And lightening a design helps only if it lowers the stress that matters: stripping heavy machinery left most of the design’s demand in place, and the local model failed as before. Our plans written without the data point to a second kind of strength. What a designer brought before touching the data separated the frontier agents far less; what it learned from the data separated them most, and that strength enters QQ, the worth of a design, not the chance of completing it. The lens also has a term we have not measured. An agent chooses its design from an estimate of its own strength, θ^=θ+δ\hat{\theta} = \theta+ \delta; when δ\delta is large, it picks designs it cannot complete, or fails to recognize the best of those it can. That δ\delta is the self-knowledge discussed above, and measuring it is our next step.

Fitting the Machine, or the Dataset

One dataset revealed something the score alone could not. In the AHU dataset, faults were introduced in all air-handling units on the same schedule, so the timestamp alone predicts the fault. Most frontier agents found this regularity and used it, and it travelled from one agent to another inside their plans. Using it is not cheating: the task allowed it, and no general model could have known it. It is customization at full strength. But the regularity belongs to how the data were collected, not to the machine. Held-out units cannot expose it, because they share the schedule; a real building would expose it on the first day. When we ran the sealed predictors again with each unit’s clock shifted by a random offset, scores of up to 86 fell to about 18 or less, and the gap between frontier and local agents on this dataset all but vanished. Nor must the shortcut be sought: plans written without the data that added the hour of the day and the day of the week, as building engineers routinely do, scored up to 37 on this dataset, against at most 16 for plans without them. Two less-known datasets carried subtler traces of how they were made. In Petrobras 3W, our benchmark requested predictions only for the labeled rows of each instance, so where the first request falls within an instance, together with the instance’s length, identifies one class; in CARE, the length of the observed window separates anomalies within a wind farm. Astra’s designs turned both into features. Agents, like researchers, find and use whatever traces the making of a dataset leaves behind, and these traces belong to the benchmark, not to the machines. Without the three datasets, the same implementer gains about 2.5 points from Astra’s plans written without the data and 6.1 to 11.6 points from its plans written on the data, against 1.5 and 5.8 to 12.7 with them; on the less-known datasets, plans written without the data fall 15 to 23 points short of Astra’s own designs rather than 27 to 30. No ranking or comparison changes direction.

Generality forces a model to rely on what holds everywhere; locality lets a modeler use whatever holds where it works. That freedom is the point of customization, but a correlation can hold here because of the machine’s environment, as when a building’s schedule drives its load, or because of how the data were made, as with the shared fault schedule above. A customized model fits whatever it is given, the machine and the making of its data alike, and only knowledge from outside the data can tell the two apart. We keep these datasets in the benchmark as hidden indicators of that limit: a high score on them, earned through such traces, signals a fit to how the data were made that a held-out test cannot see.

Our own documentation held one shortcut too. For Paderborn, a table of each bearing’s operating history, keyed by the identifiers used at deployment, revealed which bearings were healthy; one of 81 delivered predictors used it, without gain, and removing Paderborn changes none of our comparisons.

Limitations

Our evidence has limits. Most configurations were run once; aggregate results are stable across complete re-runs, but single datasets are not, so per-dataset contrasts should be read as descriptive, and our intervals reflect variation across datasets, not across runs. The datasets are public and may have been seen during pretraining: the agents were not told which dataset they faced, but they recognize most of them from the task documentation, and the reasoning of two of them cannot be inspected, so memorization cannot be ruled out entirely. That the published methods were implemented faithfully rests on a single LLM judge. Agents could also use the internet during development, as a practitioner would: public documentation, papers, code, and pretrained models were allowed, while obtaining evaluation data, labels, or existing answers was forbidden but not technically blocked. Scanning the commands and web-tool calls of every development run reported here, we found one violation: Kimi looked up the duration of a hidden IMS test and hard-coded a wrong value, which lowered its score on that fold. A few searches for the benchmark’s own interface and error messages returned nothing; all other network use installed packages, downloaded generic pretrained weights, or consulted documentation, code, and public descriptions of the datasets, and none retrieved evaluation data or labels. The scan sees only addresses written in commands or printed in their outputs. The agents ran in their usual harnesses, Codex for the frontier agents’ main runs and OpenCode for the local agents and the plan runs, so what we compare are agents as deployed, not bare models. The local models in the main experiment ran on CPUs only, although runs with GPUs changed little. Finally, our plans are specifications written after the agent’s own trial and error, within 900 characters; they transfer a design chosen on the data. The plans were written in Chinese, which all implementers handle, and all transplanted plans, Luna’s included, were written up from the delivered code by a session of Astra; if anything, this should favor Astra as an implementer, yet given Luna’s plans, Astra fell to Luna’s level. The plans written without the data were run days to weeks after the runs they are compared with, and Luna wrote each of its plans in about a minute and a half where Astra took about ten; if anything, this should favor Astra’s plans, yet Astra’s plans led by only 3.5 to 6.2 points. Whether plans travel as well between frontier models from different developers we have not tested, and the closeness of the two agents before touching the data may partly reflect their shared origin. Above all, our setting assumes labeled data from other units of the same kind of machine. When a new type of machine arrives with no labels at all, the cold start that motivates much of transfer learning, there is nothing to fit, and whether a modeler can still help there remains open; our plans written without the data show only what knowledge contributes before any data is seen, more on well-known machines and less on unfamiliar ones.

Future Work

Three directions follow. The first is planning without data for local implementers. With frontier implementers, a plan written without the data was worth about what a weaker agent achieves on its own; whether such a plan helps a local model on site, in the setting that motivates it, is open, and so is how far newer local models or longer budgets move the threshold that stops them. The second is reuse across tasks: whether the decisions written for one machine help on another, which would turn a modeler’s experience into something like a foundation and offer a route toward the cold start. The third is self-knowledge: whether an agent can tell a good plan from a bad one, or its best attempt from the rest, without a benchmark to tell it. A laboratory test rig whose data have never been published would offer a lockbox test for all three.

Conclusion

We asked whether, in the age of agents, generality should reside in the model or in the modeler. Evaluated the way models are deployed, general-purpose agents outperformed AutoML averaged over 24 PHM datasets and, for the strongest of them, faithful implementations of published methods on average on three of four datasets. Their advantage lay less in the size of their models than in fit: decisions made on each machine’s data that fit in a plain-text plan of a few hundred words, decisions that travel to any implementer able to carry them out, but not yet to the models that fit on local hardware. Before touching the data, it mattered little whose plan an agent carried out; what set the strongest apart was how much it learned from the data in front of it. PHM, we believe, is moving from publishing models to producing decisions. The evolution of its methods has not reached an end; it has turned a corner. Its next step returns to building a model for every machine, only now the builder is a general modeler. One route to generality, in other words, is not to build a general model, but an agent that adapts methods to each setting. In studying agents as researchers, we found ourselves studying research itself.

An Example Plan

Plans were written in Chinese, within 900 characters; we translate one here. It describes the method Astra delivered on the second fold of PHM 2010, where the task is to track the flank wear of a milling cutter cut by cut. The plan states every decision and every hyperparameter Astra selected, but no fitted coefficient: the implementer must write the code and fit the models itself. Given this plan, Luna reproduced Astra’s score exactly, and Qwen3.6 came within a tenth of a point in the second of its two runs; in its first run, it delivered a predictor worse than the baseline.

Task framing. Stream-wise regression per cutter; each cut is one sample; predict the flank wear averaged over the three flutes after the cut, in μm\mu\mathrm{m}; the history uses only cuts already received.

Data and preprocessing. Use the three vibration axes only. Take 20%–80% of the current record (bounds floored, keeping at least one point); subsample with step [points/20000], minimum 1. Read in single precision, compute in double; set non-finite values to zero, clip to ±106\pm10^{6}, and subtract each axis’s mean. Raise an error on empty signals.

Features. (1) Difference amplitude: population standard deviation of (X−Z)/2(X-Z)/\sqrt{2}. (2) Projection amplitude: project onto the unit directions (1,−1,0)/2(1,-1,0)/\sqrt{2} and (1,1,−2)/6(1,1,-2)/\sqrt{6} and take the square root of the smallest eigenvalue of the two-dimensional population covariance. (3) Minor-axis amplitude: square root of the smallest eigenvalue of the unbiased three-axis covariance (zero for a single point); negatives are set to zero before the square root. Each model takes two inputs: the amplitude raised to an inner power, accumulated over the cutter’s cuts and raised to an outer power; and a run-in term 1−exp⁡(−cut/scale)1-\exp(-\mathrm{cut}/\mathrm{scale)}.

Model and hyperparameters. A weighted average of five ridge regressions with intercept, configured as (amplitude; inner power, outer power, run-in scale, regularization base, weight): difference; 3, 1/4, 10, 3, 1/4. Difference; 2.5, 1/3, 10, 3, 1/4. Projection; 2.5, 1/3, 10, 3, 1/4. Minor axis; 2, 1/8, 5, 1, 1/8.

Training and validation. Sort by cutter and cut and join the development labels. Hold out whole cutters for validation, infer in causal order, and compare configurations and blends by the cutter-averaged MAE. In each fold, compute the input mean and standard deviation on the training part only; the regularization strength is the base times the number of training samples divided by 315. Finally, refit on all development samples and fold the standardization into the coefficients and intercept.

Inference and output. When cuts are skipped, fill the missing accumulation with the mean inner-power amplitude of the neighboring endpoints already seen; do not backfill on the first call. Reuse the output for a repeated cut; reset when cut numbers do not increase, and across cutters. Non-finite predictions fall back to the previous value, and on the first call to the mean first-cut label of the development data. Clip to [0, 1000] and take the maximum with the previous prediction. Output finite predictions in the original order and identifiers.

Compute. Feature extraction for training uses four processes; inference uses one CPU and no GPU, with reading cost linear in record length and a constant history state; about 1 s to start and 0.1 s per cut, with peak memory of 256 MB.

Models and Dataset Classes

tbl:V lists the models we evaluated; the providers’ model snapshots were not recorded. Classed as less known, after the runs, were AIHU, CARE, CFPR, MATWI, the NASA randomized battery, PHM Europe 2020, SCANIA, and Petrobras 3W; the other 16 datasets are standard benchmarks with many published results.

DatasetMethodYearSS (method)SS (Astra’s design)Beat
C-MAPSS (FD004)Dual-task LSTM [60]201921.00/1
C-MAPSS (FD004)DA-TCN [39]202123.40/1
C-MAPSS (FD004)Two-stream Bi-LSTM [41]202221.444.70/1
C-MAPSS (FD004)DSFormer [40]20249.40/1
C-MAPSS (FD004)MSBLS [42]20249.30/1
N-CMAPSSCART-Net [61]202543.21/1
N-CMAPSSFailure prediction + RUL (LSTM) [62]20239.30/1
N-CMAPSSCondition-indicator pipeline [63]202327.638.10/1
N-CMAPSSMR-LSTM [64]202448.31/1
N-CMAPSSCDSG (graph NN) [65]202330.60/1
PaderbornThree-stage fusion [43]202132.6{sup}†1/3
PaderbornLiteFormer [66]202421.00/3
PaderbornMABFN [45]202334.360.40/3
PaderbornCAFormer [67]20253.60/3
PaderbornMSHFFN [44]202543.10/3
Tennessee EastmanEnhanced RF (static/dynamic nodes) [68]20200.00/1
Tennessee EastmanSKLFDA [69]202013.70/1
Tennessee EastmanMRCNN-LSTM fusion [70]202346.130.11/1
Tennessee EastmanMRCC-Transformer [71]202547.51/1
Tennessee EastmanGNN, trainable adjacency [72]202444.61/1

Table IV. The 20 published methods that the strongest agent (GPT-6 Astra) implemented from the paper, with the score SS of each method and of Astra’s own design on the same fold(s), from a run without a plan made at the same time as the implementations rather than the main run of Figure 2. Method SS is the score of the faithful implementation; for Paderborn it is the mean over the three folds, and Astra’s own design is also averaged over them. Bold: the implementation beat Astra’s design on its fold; †: on at least one of the three Paderborn folds. The last column counts the implementations (paper × fold) that beat Astra’s design; ties do not count. Selection: on each dataset, the IEEE and MDPI papers since 2019 whose title or abstract names the dataset (OpenAlex, 17 October 2026), ranked by citations; after screening for method papers with supervised training on labelled data (no reviews, domain adaptation, few-shot, hardware, and so on, and no paper whose PDF could not be obtained automatically, which excluded MDPI copies), the three most cited, plus the two most cited since 2024. For N-CMAPSS, three papers come from a recent reproduction collection [15] (two of them in non-IEEE venues) and two from the same rule. Years are publication years of the issue. Scores are single runs; C-MAPSS, N-CMAPSS and Tennessee Eastman have one fold each.

ModelAccessHarness, runs
GPT-6 AstraAPICodex 0.156.1{sup}a, Sep–Oct 2026
GPT-6 LunaAPICodex 0.156.1{sup}a, Sep–Oct 2026
Kimi K3APICodex 0.156.1, Sep 2026
DeepSeek V4.1-FlashAPICodex 0.156.1, Sep 2026
Qwen3-6.35B-A3B4-bit (IQ4_XS)OpenCode 1.19.0, Oct 2026
Gemma 4 26B-A4B4-bit (IQ4_XS)OpenCode 1.19.0, Oct 2026

Table V. Models evaluated. Open-weight models were served with llama.cpp.

Appendix C: Toolkit Trials

Table VI lists the fifteen agent–toolkit combinations of Section V-E. Each was run on the datasets the toolkit applies to and compared with the same agent, in the same harness, without the toolkit.

Appendix D: Alternative Fixed Baselines

Every fold is scored against a fixed baseline, the average loss of a random forest and a small one-dimensional CNN, and on a few folds the CNN is weak, which raises every score. We therefore rescored the predictors every method derived against other baselines, changing only the denominator: either of the two models alone; the better of the two baseline models on each fold, chosen with hindsight; and the strongest AutoML pipeline, AutoGluon with the feature bank. A method is not scored against itself. Figure 7 and Table VII report SS over the 23 datasets that every method covers; AutoML was not run on MIMII. A stricter baseline lowers every score, but the methods move together, and the four frontier agents keep their order under all five baselines. Seven further baselines, AutoGluon without

Score over 23 datasets under five fixed baselines

Figure 7. Score SS over 23 datasets of every method under five choices of the fixed baseline. Stricter baselines lower every score, but the methods move together; the four frontier agents stay on top, in the same order. A method is not scored against itself.

ToolkitAgentDatasets (folds)ΔS\Delta S
AWS predictive-maintenance skill tfsresh featuresLuna24 (58)−2.4 [−8.7, +3.5]
Predictive-maintenance serverLuna9 (25)−1.0 [−9.7, +8.8]
PyODLuna4 (10)+2.2 [−5.5, +12.1]
ProgPyLuna15 (35)−0.9 [−4.9, +3.2]
Own feature componentsLuna24 (58)+1.7 [−3.3, +7.4]
Own components and validation toolsLuna24 (58)−0.7 [−5.7, +3.9]
AWS predictive-maintenance skill{sup}aLuna24 (57)−0.8 [−3.8, +2.3]
AWS predictive-maintenance skill tfsresh featuresAstra24 (58)−3.2 [−7.0, +0.2]
Predictive-maintenance serverAstra24 (58)−4.8 [−9.2, −0.6]
Predictive-maintenance serverAstra9 (25)+3.1 [−1.0, +8.3]
PyODAstra4 (10)−2.3 [−5.9, +4.2]
ProgPyAstra15 (35)+1.2 [−4.2, +7.8]
Own feature componentsKimi24 (58)−2.8 [−7.3, +2.0]
AWS predictive-maintenance skill{sup}bLuna24 (58)−0.8 [−5.5, +4.0]
Mean of the fifteen−0.7

Table VI. The fifteen toolkit trials behind Figure 5a: seven toolkits, each given to one or more frontier agents, through Codex from the start of the run unless marked. Control: the agent’s own runs without the toolkit in the same harness (for Codex, the mean of two runs). ΔS\Delta S is the paired change over the datasets covered, with 95% intervals from a bootstrap over datasets.

features, FLAML with and without features, the two foundation models, a constant prediction, and Qwen3.6, give the same order in every case but the last: Qwen3.6 fails on enough folds to leave 37 to score, and on those Kimi edges past Astra, 42.1 to 40.6. Under all twelve, the main comparisons of this paper keep their sign.

MethodOriginal (RF+CNN)/2Random forestBetter of the two 1D CNNBetter of the twoAutoGluon + features
Astra43.6 (1)42.3 (1)42.2 (1)37.0 (1)37.1 (1)
Kimi41.5 (2)40.8 (2)39.9 (2)34.2 (2)32.8 (2)
DeepSeek36.9 (3)35.9 (3)36.3 (3)30.8 (3)29.8 (3)
Luna32.1 (4)30.3 (4)31.5 (4)25.1 (4)27.2 (4)
Qwen3.614.713.715.912.013.1
Gemma 416.917.515.511.113.6
AutoGluon12.113.711.46.45.4
FLAML14.114.712.67.17.6
AutoGluon + features19.519.816.210.5—
FLAML + features19.519.218.311.511.2
MOMENT-1-base13.013.213.48.18.0
Chronos-211.712.711.07.57.9
Constant prediction4.14.14.92.03.4

Table 7. Score SS over 23 datasets under five fixed baselines. Ranks of the frontier agents among the twelve methods in parentheses; —: the method is itself the baseline. A constant prediction (the median or majority of the development labels) is a zero-information reference; over all 24 datasets it scores 3.9.

Published Methods Implemented

Table IV lists the 20 papers whose methods the strongest agent implemented, with the score of each implementation and of the agent’s own design on the same folds.

Acknowledgment

Part of the computations in this work, mainly the runs of local open-weight models, time-series foundation models, and AutoML, were performed using computational resources from the “Mésocentre” computing center of Université Paris-Saclay, CentraleSupélec and École Normale Supérieure Paris-Saclay supported by CNRS and Région Île-de-France (https://mesocentre.universite-paris-saclay.fr/).

This paper practices what it argues. The ideas, the study design, the structure of the paper, its key arguments and formulations, and the interpretation of results are the authors’ own. Under their direction, AI assistants (OpenAI GPT and Anthropic Claude models) implemented the benchmark infrastructure and analysis scripts, prepared figures, and helped turn the authors’ outline into English prose and polish it. The assistants reviewed each other’s code, and separate sessions audited the pipeline independently; none took part in the evaluated runs. The authors checked all reported numbers against the run records and take full responsibility for the content.

References

References

  1. [1]J. S. Chan et al., “MLE-bench: Evaluating machine learning agents on machine learning engineering,” in Proc. Int. Conf. Learning Representations (ICLR), 2025.arxiv.org/abs/2410.07095
  2. [2]Z. Jiang et al., “AIDE: AI-driven exploration in the space of code,” arXiv:2502.13138, 2025.arxiv.org/abs/2502.13138
  3. [3]R. Qian, Y. Zhuang, Y. Li, V. K. Ding, Sagar, R. Zhang, C. Li, I. S.-H. Wong, S. Yang, P. Liang, C. Zhang, and B. Dai, “MLE-Dojo: Interactive environments for empowering LLM agents in machine learning engineering,” arXiv:2505.07782, 2025.
  4. [4]Y. Cai, X. Li, M. Goswami, M. Wiliński, G. Welter, and A. Dubrawski, “TimeSeriesGym: A scalable benchmark for (time series) machine learning engineering agents,” arXiv:2505.13291, 2025.arxiv.org/abs/2505.13291
  5. [5]K. Brilliantov, A. Hernández-Cano, and E. Abbé, “How much of a harness does a strong agent need for autonomous ML engineering?” arXiv:2609.40303, 2026.arxiv.org/abs/2609.40303
  6. [6]P. Yang, L. Tao, Z. Huang, H. Liu et al., “PHM-Bench: A domain-specific benchmarking framework for systematic evaluation of large models in prognostics and health management,” arXiv:2508.02490, 2025.arxiv.org/abs/2508.02490
  7. [7]Y. Li, T. Feng, Y. Chen, C.-Y. Tsai, Y. Sun, A. Das, K. El Mahraoui, S. Lin, and D. Patel, “PHMForge: Evaluating LLM agents on industrial prognostics through MCP-native, algorithm-grounded tools,” arXiv:2604.01532, 2026.arxiv.org/abs/2604.01532
  8. [8]D. Patel, S. Lin, J. Rayfield, N. Zhou et al., “AssetOpsBench: A real-world evaluation benchmark for AI-driven task automation in industrial asset management,” in Proc. 32nd ACM SIGKDD Conf. Knowledge Discovery and Data Mining (KDD 2026), Vol. 2, 2026, pp. 9649–9660.DOI
  9. [9]L. H. McCabe, S. Lukens, and H. H. Huang, “Can LLM agents efficiently identify appliance faults? insights from diagnosing a simulated appliance,” arXiv:2610.19291, 2026.arxiv.org/abs/2610.19291
  10. [10]D. Kim, “When LLMs sit above diagnostic tools: Unrealized complementarity in industrial fault diagnosis,” arXiv:2610.05031, 2026.arxiv.org/abs/2610.05031
  11. [11]G. Hao, T. Han, J. Pang, and W. Wang, “DI-AGENT: A domain-knowledge informed large language model framework for unified bearing health management,” Reliability Engineering & System Safety, vol. 277, 2026.DOI
  12. [12]T. Han, X. Wang, H. Meng, and E. Zio, “Prognostics and Health Management in the Era of Foundation Models: Emerging Paradigms and Future Directions,” IEEE Transactions on Industrial Informatics, pp. 1–14, 2026.DOI
  13. [13]J. Hendricks, P. Dumond, and D. A. Knox, “Towards better benchmarking using the CWRU bearing fault dataset,” Mechanical Systems and Signal Processing, vol. 169, 2022.
  14. [14]A. Saxena, K. Goebel, D. Simon, and N. Eklund, “Damage propagation modeling for aircraft engine run-to-failure simulation,” in Proc. Int. Conf. Prognostics and Health Management (PHM), 2008, pp. 1–9.
  15. [15]R. Theiler, L. Comito, D. Leko, L. Von Krannichfeldt, L. Telyatnikov, and O. Fink, “From paper to benchmark: Agentic, framework-based reproduction of under-specified methods in machine health intelligence,” arXiv:2605.28371, 2026.arxiv.org/abs/2605.28371
  16. [16]C. Lessmeier, J. K. Kimotho, D. Zimmer, and W. Sextro, “Condition monitoring of bearing damage in electromechanical drive systems by using motor current signals of electric motors: A benchmark data set for data-driven classification,” in Proc. European Conf. Prognostics and Health Management Society (PHME), vol. 3, no. 1, 2016.
  17. [17]W. A. Smith and R. B. Randall, “Rolling element bearing diagnostics using the Case Western Reserve University data: A benchmark study,” Mechanical Systems and Signal Processing, vol. 64–65, pp. 100–131, 2015.DOI
  18. [18]S. Shao, S. McAleer, R. Yan, and P. Baldi, “Highly accurate machine fault diagnosis using deep transfer learning,” IEEE Transactions on Industrial Informatics, vol. 15, no. 4, pp. 2446–2455, 2019, SEU gearbox data: github.com/cathysiyu/Mechanical-datasets.
  19. [19]N. Helwig, E. Pignanelli, and A. Schütze, “Condition monitoring of a complex hydraulic system using multivariate statistics,” in Proc. IEEE Int. Instrumentation and Measurement Technology Conf. (I2MTC), 2015, pp. 210–215, UCI ML Repository, dataset 447.
  20. [20]C. A. Rieth, B. D. Amsel, R. Tran, and M. B. Cook, “Additional Tennessee Eastman process simulation data for anomaly detection evaluation,” Harvard Dataverse, V1, 2017.
  21. [21]R. E. Vaz Vargas et al., “3W Dataset 2.0.0: a realistic and public dataset with rare undesirable real events in oil wells,” Scientific Data, vol. 13, no. 1, 2026.DOI
  22. [22]O. Nehasil, L. Dobiášová, V. Mazanec, and J. Široký, “Versatile AHU fault detection – Design, field validation and practical application,” Energy and Buildings, vol. 237, 2021.
  23. [23]Z. Kharzian, T. Lindgren, S. Magnússon, O. Steinert, and O. Andersson Reyna, “SCANIA Component X dataset: a real-world multivariate time series dataset for predictive maintenance,” Scientific Data, vol. 12, no. 1, 2025.
  24. [24]B. Wang, Y. Lei, N. Li, and N. Li, “A Hybrid Prognostics Approach for Estimating Remaining Useful Life of Rolling Element Bearings,” IEEE Transactions on Reliability, vol. 69, no. 1, pp. 401–412, 2020.
  25. [25]P. Nectoux, R. Gouriveau, K. Medjaher, E. Ramasso, B. Chebel-Morello, N. Zerhouni, and C. Varnier, “PRONOSTIA: An experimental platform for bearings accelerated degradation tests,” in Proc. IEEE Int. Conf. Prognostics and Health Management (PHM’12), Denver, CO, USA, 2012, pp. 1–8, HAL hal-00719503.
  26. [26]H. Qiu, J. Lee, L. Lin, and G. Yu, “Wavelet filter-based weak signature detection method and its application on rolling element bearing prognostics,” Journal of Sound and Vibration, vol. 289, no. 4–5, pp. 1066–1090, 2006.
  27. [27]M. Arias Chao, C. Kulkarni, K. Goebel, and O. Fink, “Aircraft Engine Run-to-Failure Dataset under Real Flight Conditions for Prognostics and Diagnostics,” Data, vol. 6, no. 1, p. 5, 2021.
  28. [28]PHM Society, “PHM Europe 2020 data challenge: Remaining useful life prediction for an experimental filtration system,” http://phmeurope.org/2020/data-challenge-2020, 2020.
  29. [29]Q. A. Severson, P. M. Attia, N. Jin, N. Perkins, B. Jiang, Z. Yang, M. H. Chen, M. Aykol, P. K. Herring, D. Fraggedakis, M. Z. Bazant, S. J. Harris, W. C. Chueh, and R. D. Braatz, “Data-driven prediction of battery cycle life before capacity degradation,” Nature Energy, vol. 4, no. 5, pp. 383–391, 2019.
  30. [30]L. De Pauw, T. Jacobs, and T. Goedemé, “MATWI: A Multimodal Automatic Tool Wear Inspection Dataset and Baseline Algorithms,” in Computer Vision Systems (ICVS 2023), Lecture Notes in Computer Science, 2023, pp. 255–269.
  31. [31]PHM Society, “2010 PHM Society conference data challenge,” https://phmsociety.org/phm_competition/2010-phm-society-conference-data-challenge/, 2010.
  32. [32]B. Bole, C. S. Kulkarni, and M. Daigle, “Adaptation of an electrochemistry-based Li-Ion battery model to account for deterioration observed under randomized use,” in Annual Conf. Prognostics and Health Management Society, vol. 6, no. 1, 2014, dataset: B. Bole, C. Kulkarni, M. Daigle, “Randomized Battery Usage Data Set”, NASA Prognostics Data Repository.
  33. [33]B. Saha and K. Goebel, “Battery data set,” NASA Prognostics Data Repository, NASA Ames Research Center, Moffett Field, CA, 2007.
  34. [34]W. He, N. Williard, M. Osterman, and M. Pecht, “Prognostics of lithium-ion batteries based on Dempster–Shafer theory and the Bayesian Monte Carlo method,” Journal of Power Sources, vol. 196, no. 23, pp. 10 314–10 321, 2011, CALCE battery data: https://calce.umd.edu/data.
  35. [35]A. Saxena, K. Goebel, C. Larrosa, and F.-K. Chang, “CFRP composites data set,” NASA Prognostics Data Repository, NASA Ames Research Center, Moffett Field, CA, 2008.
  36. [36]R. Tanabe, H. Purohit, K. Dohi, T. Endo, Y. Nikaido, T. Nakamura, and Y. Kawaguchi, “MIMII Due: Sound Dataset for Malfunctioning Industrial Machine Investigation and Inspection with Domain Shifts Due to Changes in Operational and Environmental Conditions,” in 2021 IEEE Workshop on Applications of Signal Processing to Audio and Acoustics (WASPAA), 2021, pp. 21–25.
  37. [37]C. Gück, C. M. A. Roelofs, and S. Faultlich, “CARE to Compare: A Real-World Benchmark Dataset for Early Fault Detection in Wind Turbine Data,” Data, vol. 9, no. 12, p. 138, 2024.
  38. [38]Backblaze, “Backblaze hard drive test data,” https://www.backblaze.com/cloud-storage/resources/hard-drive-test-data, file data_Q4_2024.zip, 2024.
  39. [39]Y. Song, S. Gao, Y. Li, L. Jia, Q. Li, and F. Pang, “Distributed Attention-Based Temporal Convolutional Network for Remaining Useful Life Prediction,” IEEE Internet of Things Journal, vol. 8, no. 12, pp. 9594–9602, 2021.
  40. [40]J. Li, K. Wang, X. Hou, D. Lan, Y. Wu, H. Wang, L. Liu, and S. Mumtaz, “A Dual-Scale Transformer-Based Remaining Useful Life Prediction Model in Industrial Internet of Things,” IEEE Internet of Things Journal, vol. 11, no. 16, pp. 26 656–26 667, 2024.
  41. [41]R. Jin, Z. Chen, K. Wu, M. Wu, X. Li, and R. Yan, “Bi-LSTM-Based Two-Stream Network for Machine Remaining Useful Life Prediction,” IEEE Transactions on Instrumentation and Measurement, vol. 71, pp. 1–10, 2022.
  42. [42]T. Xu, G. Han, H. Zhu, C. Lin, and J. Peng, “Multiscale BLS-Based Lightweight Prediction Model for Remaining Useful Life of Aero-Engine,” IEEE Transactions on Reliability, vol. 73, no. 4, pp. 1757–1767, 2024.
  43. [43]D. Wang, Y. Li, L. Jia, Y. Song, and Y. Liu, “Novel Three-Stage Feature Fusion Method of Multimodal Data for Bearing Fault Diagnosis,” IEEE Transactions on Instrumentation and Measurement, vol. 70, pp. 1–10, 2021.
  44. [44]D. Wang, Y. Zhang, H. Zhang, Y. Zhuang, S. Gao, and Y. Li, “Bearing Fault Diagnosis Method Based on Multisensor Hybrid Feature Fusion,” IEEE Transactions on Instrumentation and Measurement, vol. 74, pp. 1–11, 2025.
  45. [45]D. Wang, Y. Li, L. Jia, Y. Song, and T. Wen, “Attention-Based Bilinear Feature Fusion Method for Bearing Fault Diagnosis,” IEEE/ASME Transactions on Mechatronics, vol. 28, no. 3, pp. 1695–1705, 2023.
  46. [46]M. Christ, N. Braun, J. Neuffer, and A. W. Kempa-Liehr, “Time series feature extraction on basis of scalable hypothesis tests (tsfresh – A Python package),” Neurocomputing, vol. 307, pp. 72–77, 2018.
  47. [47]M. Goswami, K. Szafer, A. Choudhry, Y. Cai, S. Li, and A. Dubrawski, “MOMENT: A family of open time-series foundation models,” in Proceedings of the 41st International Conference on Machine Learning (ICML), 2024.
  48. [48]A. F. Ansari et al., “Chronos-2: From univariate to universal forecasting,” arXiv:2510.15821, 2025.arxiv.org/abs/2510.15821
  49. [49]Amazon Web Services, “sample-predictive-maintenance-skill,” https://github.com/aws-samples/sample-predictive-maintenance-skill, commit 98f499d, accessed 2026.
  50. [50]L. G. Di Maggio, “predictive-maintenance-mcp,” https://github.com/LGDiMaggio/predictive-maintenance-mcp, accessed 2026.DOI
  51. [51]Y. Zhao, Z. Nasrullah, and Z. Li, “PyOD: A Python toolbox for scalable outlier detection,” Journal of Machine Learning Research, vol. 20, no. 96, pp. 1–7, 2019.
  52. [52]NASA, “ProgPy,” https://github.com/nasa/progpy, version 1.8, accessed 2026.
  53. [53]C. Dwork, V. Feldman, M. Hardt, T. Pitassi, O. Reingold, and A. Roth, “The reusable holdout: Preserving validity in adaptive data analysis,” Science, vol. 349, no. 6248, pp. 636–638, 2015.
  54. [54]B. Recht, R. Roelofs, L. Schmidt, and V. Shankar, “Do ImageNet classifiers generalize to ImageNet?” in Proc. Int. Conf. Machine Learning (ICML), 2019, arXiv:1902.10811.arxiv.org/abs/1902.10811
  55. [55]Z. C. Lipton and J. Steinhardt, “Troubling trends in machine learning scholarship,” arXiv:1807.03341; also ACM Queue 17(1), 2019, 2018.arxiv.org/abs/1807.03341
  56. [56]R. S. Sutton, “The bitter lesson,” http://www.incompleteideas.net/IncIdeas/BitterLesson.html, Mar. 2019.
  57. [57]D. H. Wolpert and W. G. Macready, “No free lunch theorems for optimization,” IEEE Transactions on Evolutionary Computation, vol. 1, no. 1, pp. 67–82, 1997.DOI
  58. [58]P. D. T. O’Connor and A. Kleyner, Practical Reliability Engineering, 5th ed. Chichester, UK: Wiley, 2012.
  59. [59]G. Rasch, Probabilistic Models for Some Intelligence and Attainment Tests. Copenhagen: Danish Institute for Educational Research, 1960.
  60. [60]H. Miao, B. Li, C. Sun, and J. Liu, “Joint Learning of Degradation Assessment and RUL Prediction for Aeroengines via Dual-Task Deep LSTM Networks,” IEEE Transactions on Industrial Informatics, vol. 15, no. 9, pp. 5023–5032, 2019.DOI
  61. [61]Y. Zhang, M. Du, and Q. Miao, “CART-Net: A Causal Adaptive Residual Time Network for Remaining Useful Life Prediction of Aeroengines Under Varying Operating Conditions,” IEEE Internet of Things Journal, vol. 12, no. 23, pp. 50291–50303, 2025.DOI
  62. [62]J. Cohen, X. Huan, and J. Ni, “Fault Prognosis of Turbofan Engines,” International Journal of Prognostics and Health Management, vol. 14, no. 2, 2023.DOI
  63. [63]R. Graves, P. Pankaj, V. J. Kuruvilla, R. Johnson, and M. Inoue, “Data-Driven Prognostics and Diagnostics of Industrial Machinery — A Turbofan Engine Case Study,” in Proceedings of the PHM Society Asia-Pacific Conference, vol. 4, no. 1, 2023.DOI
  64. [64]T. Xu, G. Han, H. Zhu, T. Taleb, and J. Peng, “Multi-Resolution LSTM-Based Prediction Model for Remaining Useful Life of Aero-Engine,” IEEE Transactions on Vehicular Technology, vol. 73, no. 2, pp. 1931–1941, 2024.DOI
  65. [65]H. Wang, Z. Zhang, X. Li, X. Deng, and W. Jiang, “Comprehensive Dynamic Structure Graph Neural Network for Aero-Engine Remaining Useful Life Prediction,” IEEE Transactions on Instrumentation and Measurement, vol. 72, pp. 1–16, 2023.DOI
  66. [66]W. Sun, R. Yan, R. Jin, J. Xu, Y. Yang, and Z. Chen, “LiteFormer: A Lightweight and Efficient Transformer for Rotating Machine Fault Diagnosis,” IEEE Transactions on Reliability, vol. 73, no. 2, pp. 1258–1269, 2024.DOI
  67. [67]J. Tang, Q. Zhou, and K. Yin, “A Complex Attention Transformer for Bearing Fault Diagnosis Based on Motor Current Signals,” IEEE Transactions on Instrumentation and Measurement, vol. 74, pp. 1–11, 2025.DOI
  68. [68]Z. Chai and C. Zhao, “Enhanced Random Forest With Concurrent Analysis of Static and Dynamic Nodes for Industrial Fault Classification,” IEEE Transactions on Industrial Informatics, vol. 16, no. 1, pp. 54–66, 2020.DOI
  69. [69]K. Zhong, M. Han, T. Qiu, and B. Han, “Fault Diagnosis of Complex Processes Using Sparse Kernel Local Fisher Discriminant Analysis,” IEEE Transactions on Neural Networks and Learning Systems, vol. 31, no. 5, pp. 1581–1591, 2020.DOI
  70. [70]K. Liu, N. Lu, F. Wu, R. Zhang, and F. Gao, “Model Fusion and Multiscale Feature Learning for Fault Diagnosis of Industrial Processes,” IEEE Transactions on Cybernetics, vol. 53, no. 10, pp. 6465–6478, 2023.DOI
  71. [71]Y. Chen and R. Zhang, “Deep Multiscale Convolutional Model With Multihead Self-Attention for Industrial Process Fault Diagnosis,” IEEE Transactions on Systems, Man, and Cybernetics: Systems, vol. 55, no. 4, pp. 2503–2512, 2025.DOI
  72. [72]A. Kovalenko, V. Pozdnyakov, and I. Makarov, “Graph Neural Networks With Trainable Adjacency Matrices for Fault Diagnosis on Multivariate Sensor Data,” IEEE Access, vol. 12, pp. 152860–152872, 2024.arxiv.org/abs/2210.11164

Paper details

vlnc:W_kqu48d65
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 8

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

OpenAI GPT, Anthropic Claude models

View statement
Looking for related papers…
Contents