That is a central research problem for learning industrial systems. A machine is not a static object. Its behavior changes constantly — sometimes obviously, sometimes only slightly. Tools are changed. Materials differ. Jobs change. Components age. Parameters are adjusted. Maintenance alters mechanical states. Even two seemingly identical production cycles can produce different signals under different conditions.
If a learning system recognized yesterday that certain behavior was normal, a much harder question follows: Can it still rely on that tomorrow?
Remembering is not the same as understanding.
Technically, almost anything can be stored today: temperatures, pressures, axis positions, motor currents, states, runtimes, alarms, part information, process values, time series, events. A large data history is therefore not yet a memory. Real machine memory would need to know not only what happened, but under which conditions it happened — and how reliable the resulting insight actually is.
A machine runs the same job for several hours. A stable pattern forms across cycle time, power draw, temperature, and other signals. A learning system recognizes: under these conditions, this behavior occurs regularly. Weeks later, a very similar pattern appears. A simple system might conclude: I know this. This is normal.
But much may have changed in between — a different tool, a different material batch, maintenance, adjusted parameters. The signal values look alike. The context may not. That is where data storage diverges from actual machine understanding.
Machines do not have only one normal state.
In many classic monitoring systems, normality is thought of comparatively statically: a measurement, a target range, an alarm. That works well for many industrial questions. For a learning system, this model is not enough.
A motor may behave differently during acceleration than during constant motion. A machine in setup may have different power levels than in stable production. A tool change may shift several signals at once without any fault. The question shifts from “Is this value normal?” to “Is this behavior normal under current conditions?” Normality becomes context-dependent — and once normality is context-dependent, memory must be too.
An observation is not yet experience.
An unusual interplay of several signals in a single cycle — should the system remember it? Maybe. Should it use that observation later as reliable knowledge? Not necessarily yet. A single event may come from noise, a special case, or a short disturbance. If the same pattern repeats in many comparable situations, its meaning changes. Observation can slowly become experience.
How much evidence does a memory need before it becomes relevant? There is no universal number. Ten repetitions may be enough in a highly stable process. A hundred may still mean little in a highly variable one. What matters is not only count — it is quality. Are situations truly comparable? Does the pattern appear independently? Are there counterexamples? Only then does reliable experience emerge.
Knowledge must tolerate contradiction.
What happens when new observations no longer fit existing knowledge? A learning system must not defend its past at all costs. At the same time, treating every deviation as immediate refutation would be wrong — machine operation includes exceptions. The system must distinguish exception (prior knowledge still holds, this case deviates) from change (the machine now behaves fundamentally differently). That requires not only memory — it requires the ability to question one’s own memory.
Perhaps an intelligent machine must also forget.
Industrial machines change: parts are replaced, mechanics wear, tools change, maintenance resets states. Experience from two years ago may still hold — or be fully obsolete. If a system treated every insight with equal weight forever, its past could eventually become a problem. Forgetting is not a defect — it can be a necessary part of learning. Not as deletion, but as declining relevance for current evaluation while history remains available.
Experience is not truth.
A learning system observes correlations — that does not prove causation. Rising temperature and longer cycle time appearing together is valuable experience, but not yet causal proof. Machine memory should therefore store not only what was learned, but what that learning was based on. Traceability becomes part of memory.
How might such machine memory work in principle? Likely as a combination of several principles — the following describes the conceptual solution space, not Copass’s concrete internal implementation.
1. Context similarity: A stored experience does not become relevant only because current signal values look similar. Operating state, process phase, job, material, tool, and configuration must be comparable. The question shifts from “Have I seen this signal before?” to “Have I seen this behavior under comparable conditions before?”
2. Evidence over single observation: Trust grows through repeated confirmation — but quality matters more than quantity. A hundred nearly identical cycles in one job provide different evidence than the same pattern across many different production days.
3. Trust as a continuous quantity: Memories are not simply valid or invalid. Graduated trust — depending on context similarity, evidence, recency, and contradiction — describes how relevant a past experience appears for the current situation.
4. Treat contradiction explicitly: New evidence must be able to contradict existing experience. An assumption can be confirmed, lose trust, or be replaced by a better behavioral model.
5. Temporal relevance: Age alone does not make experience false — but very old observations may be less informative for the current state. A controlled recency effect weights current, confirmed experience higher without erasing the past.
6. Preserve provenance: When a system trusts an experience, it should remain traceable which observations led to it, under which conditions, how often it was confirmed, and what contradictions existed. That is a prerequisite for explainability on the shop floor.
What does this mean for Copass?
Copass can now assign completed insights permanently to a specific machine. That provides an important foundation: experience does not have to disappear when observation ends. The next step is deliberately harder. Not every stored insight should automatically influence current machine understanding.
We are investigating under which conditions past experience stays relevant — and when a system should trust it less: When does repeated observation become reliable experience? How similar must current context be to a past situation? How does contradicting evidence change existing knowledge? And when should a machine begin to trust its own memory less?
The goal is not to store as much as possible. The goal is machine memory that grows with the asset, can correct itself, and does not confuse its own past with truth. The decisive step is therefore not: Copass remembers. It is: Copass should learn when its memory counts.