Why General-Purpose AI Fails at Industrial Reliability

Your engineering team has tried it. Someone uploaded a pump manual to ChatGPT and asked it to generate an FMEA. The output looked reasonable. Failure modes, causes, effects, severity scores. For a moment, the question hung in the air: why do we need a specialized tool?

This article explains why. Not with marketing claims, but with the architectural reasons that separate a general-purpose language model from a system built for industrial reliability engineering.

The ChatGPT FMEA Test

Ask ChatGPT to generate an FMEA for a centrifugal pump. You will get something like this:

• Failure Mode: Seal leakage
• Cause: Wear and tear
• Effect: Fluid loss
• Severity: 6 | Occurrence: 4 | Detection: 5
• RPN: 120

It looks right. It is also useless for three reasons:

1. No source. Which manual page? Which failure history? Which asset? You cannot trace it and an auditor cannot verify it.
2. No context. “Wear and tear” is not a root cause. Your pump failures may be caused by dry running during process upsets, based on seven work orders in the last 24 months. ChatGPT does not know this because it does not have your data.
3. No memory. Correct the output today. Tomorrow, same prompt, same generic answer. The correction vanished.

Now ask Tacit AI the same question. The system draws on your pump manuals, your work order history, corrective actions from similar pumps across your fleet, and any prior FMEA your team has built. The output is specific, sourced, and traceable. And when your engineer corrects it, that correction becomes permanent knowledge.

Five Things General-Purpose AI Cannot Do

1. Remember your equipment

ChatGPT’s “memory” feature stores user preferences like name and communication style. It does not store your asset hierarchy, your failure mode library, your maintenance history, or your risk scoring rules. Every FMEA conversation starts from generic training data. Tacit AI maintains a persistent industrial knowledge base built from your actual documents and operational data.

2. Learn from corrections

When you tell ChatGPT “that failure mode is wrong for our application,” it apologizes and fixes it in that session. That correction does not persist. Next week, same mistake. In Tacit AI, every engineer correction feeds back into the knowledge base and propagates to every related asset. The academic literature calls this “inference-only fine-tuning”: the language model stays frozen, but the system around it gets smarter from execution feedback.

3. Coordinate across tasks

An FMEA is not one question. It requires data quality assessment, failure mode extraction from multiple document types, hierarchy construction, risk scoring, and action recommendation. ChatGPT handles these as separate, disconnected prompts. Tacit AI runs specialized agents for each stage, with shared memory connecting them. A failure mode extracted from a manual informs the risk score, which informs the recommended action, which draws on corrective actions from your work order history.

4. Trace its sources

ChatGPT produces text with no provenance. You cannot click a failure mode and see which manual page generated it. You cannot show an auditor the chain from source document to FMEA row to recommended action. Tacit AI links every row to the exact source paragraph, page, and document. Revision tracking shows what changed and why.

5. Connect to your systems

ChatGPT cannot reach into your SAP PM, Maximo, or EAM behind your firewall. It cannot ingest work orders continuously. It cannot update an FMEA when new failure data arrives. Tacit AI connects to your CMMS, EAM, and document management systems. FMEAs stay current as operational data changes.

The Science Behind the Gap

Recent research in AI systems design explains why this gap exists and why it is structural, not just a feature gap.

A paper on inference-only fine-tuning (Sabet & Singh, 2025) describes a paradigm where LLM behavior is adapted at inference time without altering the model’s weights. Instead of retraining the language model, the system augments it with memory modules, dynamic prompts, and external tools that evolve as it operates. The key insight: “the agent, comprising the LLM plus its system components, is what learns, not the LLM itself.”

Two methods illustrate this:

• Memento (Huang et al., 2025): attaches an external “case bank” of past execution trajectories to a frozen LLM. Each new task retrieves similar past cases to shape the plan. The system achieves state-of-the-art performance without any weight updates, simply by learning which past episodes to recall.
• ACE (Agentic Context Engineering) (Zhang et al., 2025): treats the system prompt as an evolving “playbook” that accumulates strategies from execution feedback. A generator solves tasks, a reflector critiques outcomes, and a curator integrates lessons. The context grows richer with reusable tactics and domain facts.

This is exactly what Tacit AI does in the industrial domain. Your manuals and work orders form the case bank. Engineer corrections are the execution feedback. The 33-step pipeline is the multi-agent architecture. The knowledge base is the evolving playbook. The language model stays frozen. Everything around it compounds.

ChatGPT has none of this infrastructure. It is a raw language model. A powerful one, but a raw one.

Memory That Compounds

The most fundamental difference is memory architecture. The research literature identifies three types of memory that inference-only systems need:

• Working memory (the context window): what the model sees right now
• Episodic memory (recent cases): what happened in recent interactions
• Long-term knowledge base: the accumulated understanding of your domain

ChatGPT has working memory (its context window, currently up to 128K tokens). It has rudimentary episodic memory (the “memory” feature that stores user preferences). It has no long-term industrial knowledge base.

Tacit AI has all three layers. Working memory handles the current analysis. Episodic memory tracks the current deployment. The long-term knowledge base stores every manual processed, every failure mode extracted, every engineer correction made, across every site and every deployment. That is the compounding advantage: each deployment starts from a richer foundation than the last.

Feedback That Sticks

The research on Agentic Context Engineering identifies a critical problem with naive AI systems: “context collapse,” where important details are lost when the system rewrites or summarizes its own memory. The solution is incremental, structured updates rather than wholesale rewriting.

This maps directly to how Tacit AI handles engineer feedback. When your reliability engineer reviews a draft FMEA and corrects a failure mode, that correction is stored as a structured, traceable update. It does not replace the original context. It enriches it. The system knows both what the AI originally suggested and what the engineer determined was correct. That history informs future generations.

ChatGPT has no mechanism for this. Its “conversation memory” is a flat list of user preferences, not a structured correction history linked to specific assets and failure modes.

Agents That Coordinate

A key finding from the MongoDB technical analysis cited in the research: multi-agent systems “fail not due to communication protocols, but because they lack shared memory.” Without memory engineering, agents redundantly solve the same problems.

Tacit AI’s 33-step pipeline is a multi-agent system. Data quality agents score and clean your input. Extraction agents pull failure modes from manuals. Hierarchy agents build asset structures. Scoring agents assign risk rankings. Action agents recommend mitigations. Each agent accesses shared memory. A failure mode extracted in step 8 is available to the scoring agent in step 15 and the action agent in step 22.

You cannot replicate this by prompting ChatGPT 33 times. Each prompt is an isolated conversation with no shared state. The agents cannot coordinate because there is no memory layer connecting them.

The Security Question

Equipment manuals, work order histories, and failure data are proprietary. Uploading them to ChatGPT means sending them to OpenAI’s shared infrastructure. Even with enterprise agreements, you have limited control over data retention, processing, and potential use in model training.

Tacit AI deploys within your security perimeter. Your data stays on your infrastructure. No shared processing. No model training on your data. For industries with regulatory requirements around data handling (pharmaceutical, energy, defense), this is not a feature. It is a requirement.

When ChatGPT Is Fine

General-purpose AI is useful for reliability engineering in specific, bounded scenarios:

• Brainstorming potential failure modes for a new asset type where you have no historical data
• Summarizing a long technical document to extract key maintenance requirements
• Drafting initial templates or checklists that an engineer will then populate with real data
• Answering general questions about FMEA methodology or standards

For these tasks, ChatGPT is fast, cheap, and good enough. If you need a starting point and have an experienced engineer who can validate and enrich the output, a general-purpose model works.

When It Is Not Enough

ChatGPT is not enough when you need:

• FMEAs that reflect your actual failure history, not generic training data
• Traceability from every row to its source document for audit defense
• Corrections that persist and improve future output
• Integration with your CMMS/EAM for continuous updates
• Knowledge that compounds across sites and deployments
• Output that meets IEC 60812, AIAG-VDA, or SAE J1739 structure
• Security that keeps proprietary data within your perimeter

If your reliability program requires any of these, you need a system, not a chatbot.

See the full side-by-side comparison or book a working session to see Tacit AI run on your data.