AI Cannot Truly Understand Causality Yet, But We Can Make It Simulate Causal Reasoning

Rudina Seseri (Founder & Managing Partner, Glasswing Ventures) recently wrote an article about AI “confidently making mistakes”. She pointed out that the most dangerous thing about AI is not when it says “I don’t know,” but when it delivers a wrong answer with absolute certainty. In a factory, the cost of such confidence is a halted production line, scrapped materials, or a lost order. Her proposed solution is to “force models to reflect”—to make the model reflect on its own output.

But we believe that asking a model to reflect on itself is inherently unreliable. A model that can confidently make mistakes can also confidently reflect its way to a wrong conclusion. Reflection just spins one more loop inside the model’s internal state without introducing any external anchor. It does not know whether it is right or wrong; it is merely generating more text that looks plausible.

Over the past year, we have taken a different path inside CCT CRM. Instead of making the model reflect, we give it a causal architecture that forces it to operate according to causal logic. When the three layers are stacked together, the system behaves as if it "understands causality"—not because AI intelligence is evolving, but because the architecture is evolving. This is the AI Causal Model we are building.

Layer 1: Constraint Validation — Simulating Causal Reasoning with Mathematical Formulas

MES scenarios contain many hard constraint formulas: input quantity must equal output plus scrap, OEE must equal availability × performance × quality, and the sum of operation hours must equal total order hours. These are not things AI needs to reason about. They are physical laws. Violating them is simply wrong.

We inserted a constraint validation layer into the AI output pipeline. After AI calculates OEE, the system automatically substitutes the three sub-metrics back into the formula. If the equation does not hold, the AI output is intercepted before it ever reaches the user. The system feeds the failure information—deviation, violated formula—back to AI as new context and asks it to recalculate. Up to three retries.

This is not making AI reflect. It is using mathematical formulas to check AI’s answers. AI does not need to understand why OEE equals the product of these three metrics. It only needs to know: if the calculated numbers fail the formula, recalculate. This is the first form of a causal model: not because AI understands the causal chain, but because the causal chain has been encoded as mathematical rules that AI cannot bypass.

Layer 2: Experiential Learning — Turning Every Mistake into Causal Attribution

Constraint validation catches mathematical errors. But when the user says “that’s wrong,” the mistake has already happened, and it is usually not a math problem—it is the AI misunderstanding the context, using the wrong data, or ignoring critical information.

The core of this layer is not “remember the mistake,” but “remember the causal relationship.” The system does not record “this was wrong”; it records: under what scenario, what cause led to the error, and what the correct action is.

AI senses negative user sentiment—not through an emotion analysis model, but through the simplest signals: the user says “no,” “wrong,” or “that’s not what I meant,” or edits and saves an AI-generated email. When the system detects these signals, AI does not argue. It asks: “I noticed you may not be satisfied with my answer. Could you tell me exactly what was wrong? I’ll record it so I won’t make the same mistake next time.”

Every correction is recorded in a structured way. Fields include: triggering scenario, user input, AI’s wrong output, feedback summary, error category, root cause analysis. And most importantly—root cause source: whether the attribution was made by AI itself or explicitly pointed out by the user.

In subsequent conversations, the system automatically retrieves relevant experiences and injects them into the priority reading area. When answering similar questions, AI proactively begins: “I made mistake X when handling this type of issue before, so this time I performed check Y first.”

This is the second form of a causal model: not because AI understands why it made the mistake, but because every mistake is labeled with a causal tag, and next time AI must read the tag before acting.

Layer 3: Model Routing — Letting Causality Choose the Optimal Solution

For the same type of question, different large models make mistakes at different frequencies. This is not an abstract ranking of model capability; it is a quantifiable fact in specific business scenarios.

We rotate questions of the same semantic type across GPT, DeepSeek, GLM, and Doubao. After each response, the system automatically updates that model’s score for that scenario based on user feedback. User adoption, normal conversation ending, positive expression—positive. User correction, output modification, negative expression—negative.

Higher-scoring models receive greater call weight. The lowest-scoring model still retains a 5% exploration chance—because models update, and a model that performs poorly today may overtake in the next version. The system is not training a better model; it is choosing the model least likely to make mistakes.

This is the third form of a causal model: not because AI understands which model is better, but because the system has built a causal chain of “model selection → error rate” from feedback data and automatically converges toward lower error rates.

Three Layers Stacked: An Engineering System That Simulates Causality

Viewed individually, none of the three layers is true causal reasoning. Constraint validation is mathematical formulas, experiential learning is database retrieval, and model routing is statistical scoring.

But when stacked together, the system behaves as follows:

AI miscalculates a number → intercepted by the formula → recalculates → only returned after passing. Users never see output that violates physical laws.

AI misunderstands the context → user corrects → error is structured and labeled with causal tags → next time, the same scenario loads the experience first → AI proactively declares, “I made this mistake before, so I performed this check first.” The same error does not happen twice.

In the same scenario, different models make mistakes at different frequencies → feedback data automatically adjusts routing weights → models with lower error rates are called more often. The system automatically avoids error-prone models.

This is not AI intelligence evolving. This is architecture evolving.

Conclusion

Making AI truly understand causality—knowing that “doing A causes B, and not doing A means B will not happen”—is still impossible in the current technological environment. But making AI simulate causal reasoning is an engineering problem that can be solved today.

The method is not to train a better model, but to build around the model a set of constraints it cannot violate, a memory system it cannot forget, and a selection logic it cannot escape.

We have done it. Three founders, zero funding, four paying customers. Digital employees are not a vision on a PowerPoint slide—they are code, databases, and a three-layer closed loop that runs today.