Why General-Purpose AI Isn’t a Reliability System

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 3 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 7 work orders in the last 24 months. ChatGPT does not know this because it does not have your data.
3. No record. Correct the output today. The correction may live in that chat, but it never reaches the other FMEAs that share the same failure mode.

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.

5 Things a Draft Doesn’t Give You

1. Remember your equipment

ChatGPT now remembers conversations and projects. It does not keep a governed, versioned record of your asset hierarchy, your failure mode library, your failure history and your risk scoring rules. Each new FMEA starts from whatever the chat happens to recall. 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 fixes it, and may remember the fix in that chat. The fix never reaches the other FMEAs and assets that share the failure mode, and nobody can audit it. 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. A chat assistant can run these steps when you set them up. It doesn’t keep a standing pipeline with shared memory that runs every time new evidence arrives. 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 can cite the file behind an answer. It doesn’t keep row-level provenance. You cannot click a failure mode in last quarter’s FMEA and see which manual page produced it, or 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

Connectors can now read systems like SAP PM and Maximo. Reading isn’t maintaining. Nothing matches each new failure report to the FMEA rows it affects and proposes the update for an engineer to approve. 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.”

2 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 3 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). It has episodic memory (saved memories and chat history). It has no governed, long-term industrial knowledge base.

Tacit AI has all 3 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 one of your sites. That is the compounding advantage: each new FMEA 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 can build agents on a general model. What you can’t skip is the governed memory between them: the record that the failure mode found in step 8 is the one scored in step 15 and acted on in step 22, kept across runs and reviewed by engineers.

The Security Question

Equipment manuals, failure histories and FMEAs are proprietary. Enterprise AI plans don’t train on your data, so training is no longer the question. Where the record lives is. In a chat product, your FMEA program lives in the vendor’s app and its chat history.

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 your sites
• 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.