Why We Don’t Use Large Language Models for Machine Prediction
LLMs are powerful. They’re also the wrong tool for industrial predictive AI. Here’s what we use instead – and why it matters.
The Landscape
Everyone Is Talking About LLMs. We’re Using Something Better for This Problem.
Large Language Models – GPT, Claude, Gemini, and their relatives – are extraordinary at generating text, answering questions, summarizing documents, and reasoning across broad domains. They’re genuinely transformative for a wide class of problems.
Predicting machine failure from sensor time-series data is not one of those problems.
At Tor Hydra, we use LRCN: Long-term Recurrent Convolutional Networks – a hybrid deep learning architecture specifically designed for sequential, temporal data. It is better suited to industrial machine learning in nearly every dimension that matters for edge deployment.
Understanding the Tools
LLMs – What They’re Built For
Large Language Models are trained on vast text corpora. They operate by predicting the next token in a sequence – a powerful mechanism for language, reasoning, and knowledge retrieval.
What they do well:
- Natural language understanding and generation
- Broad knowledge retrieval and summarization
- Pattern recognition across unstructured text
- Flexible generalization across diverse tasks
What they are not designed to do:
- Process continuous, high-frequency numeric sensor streams
- Run efficiently on constrained edge hardware
- Learn the precise temporal dynamics of a specific machine
- Produce calibrated, interpretable predictions for narrow physical phenomena
Deploying an LLM for predictive maintenance is like using a dictionary to diagnose a structural crack. The tool is sophisticated – it’s just built for a different job.
LRCN – What It Is and Why It Works
LRCN: Designed for Time, Pattern, and Sequence
Long-term Recurrent Convolutional Networks combine two proven neural network architectures:
Convolutional layers (CNN component)
Extract spatial and local features from raw sensor input – identifying patterns in signal shape, frequency bands, and amplitude profiles that are characteristic of specific mechanical behaviors.
Recurrent layers (LSTM/RNN component)
Track how those patterns evolve over time – capturing the sequential dependencies and temporal drift that precede failure events. A compressor doesn’t fail in an instant; it degrades across hours, days, or weeks. LRCN is built to see that progression.
The combination produces models that:
- Understand what the sensor signal looks like at each moment
- Understand how that signal is changing over time
- Generate predictions that reflect both current state and trajectory
Head-to-Head Comparison
LRCN vs. LLM for Industrial Predictive AI
| Criterion | LRCN | LLM |
|---|---|---|
| Input type | Numeric time-series sensor data | Text / tokens |
| Temporal modeling | Native – built for sequences | Limited – not primary design |
| Edge deployment | Efficient – runs on low-power hardware | Resource-intensive – requires significant compute |
| Model size | Compact, domain-specific | Hundreds of millions to billions of parameters |
| Latency | Millisecond inference on-device | High – typically requires server or cloud |
| Specificity | Trained on your machine’s behavior | Generalist – no equipment-specific knowledge |
| Interpretability | Scores, probabilities, condition indicators | Outputs vary – less suited to control systems |
| Cloud dependency | None required | Typically significant |
| Calibration for physical systems | Purpose-built | Not optimized |
The Cost of Using the Wrong Tool
Using an LLM for Sensor Prediction Means Accepting Tradeoffs You Don’t Have To
- Compute overhead – LLMs require far more processing power than edge hardware typically offers. Running one on a gateway device means compromises on speed, battery, or cost.
- No machine-specific baseline – A general-purpose model has no understanding of what normal looks like for your specific pump, motor, or gearbox. LRCN learns that baseline explicitly.
- Data mismatch – LLMs are not natively designed to ingest structured, high-frequency numeric streams. Adapting them to do so adds complexity without improving accuracy.
- Opacity in physical contexts – When an LLM flags an anomaly, it’s harder to trace that prediction back to specific sensor channels and mechanical behavior. In industrial settings, explainability matters.
Our Position
We’re Not Anti-LLM. We’re Pro-Right-Tool.
Tor Hydra may use LLMs in appropriate supporting roles – processing maintenance logs, generating technician-facing summaries, or assisting with natural language configuration. These are valid applications.
But the core predictive engine – the model watching your sensor data in real time and deciding whether your equipment is trending toward failure – is LRCN-based. Because that’s the architecture that performs.
We made this choice deliberately. We’ll keep making it until something better exists for this specific problem.
Want to Go Deeper on the Architecture?
We’re happy to walk through the technical details with your engineering team – model structure, training methodology, inference pipeline, and how we evaluate model performance on your specific equipment class.