What is causal AI?

Nearly every analytics tool and machine-learning model works by finding things that happen together. That is powerful for prediction: if two signals always move in step, one is a good forecast of the other. But moving together says nothing about why. A model can be highly accurate and still be wrong about what would happen if you intervened, because it has learned a coincidence rather than a mechanism.

Most analytics tools and machine-learning models estimate associations: statistical dependence between variables observed together. That supports prediction, since a variable that reliably moves with another forecasts it. It does not identify what happens under an intervention. A model fit to observational data can be accurate on that data and still wrong when the system is changed, because it may have learned a spurious association rather than a mechanism.

Take an agent at peak hour. Queue time and timeouts rise and fall together. A pattern finder will happily report that one predicts the other. Yet clearing the queue by itself would not stop the timeouts. Both are driven by a third factor, the rush of runs, which fills the queue and trips the timeouts. Statisticians call this a confounder, and it is a common way a correlation misleads.

Take an agent at peak hour. Queue time and timeouts are positively associated, so either predicts the other. Intervening on queue time alone, for example by draining the queue, would not be expected to change the timeout rate, because both are driven by a common cause: the volume of concurrent runs. Peak load fills the queue and trips the timeouts. That common cause is a confounder, and an unadjusted association between the two is confounded by it. Confounding is a common source of spurious association.

Causal AI represents a system as a causal graph: boxes for the things you can measure, and arrows for direct influence from one to another. The arrows carry the meaning a correlation lacks. They say which variable changes when you push on another, in which direction, and by how much. Once a graph exists, many questions that were guesswork become calculations, under stated assumptions.

A causal model represents the system as a causal graph: a directed acyclic graph whose nodes are measurable variables and whose edges are direct causal influence. A structural causal model adds one equation per variable, defining it from its direct causes and an independent noise term. The edges carry what an association lacks: which variable changes under an intervention on another, in which direction and by how much. Given the graph and its assumptions, many interventional questions can be computed from data that would otherwise only support guesses.

That lets causal AI answer three kinds of question, often called the ladder of causation. The first rung is association: what tends to happen together? The second is intervention: what happens if we change this on purpose? The third is the counterfactual: given what actually happened, what would have happened if one thing had been different? Ordinary machine learning mostly stays on the first rung. Explaining a specific failure, and preventing the next one, needs the other two.

Causal AI can answer three kinds of query, Pearl's ladder of causation. Association: what is observed together, P(Y | X). Intervention: what happens if X is set to a value, P(Y | do(X = x)). A counterfactual: for a specific event that occurred, what Y would have been had X been different, with that event's background conditions held fixed. Each rung needs stronger assumptions than the one below. Standard machine learning mostly operates on the first. Explaining a specific failure and preventing the next one need the second and third.

The graph is built in two steps. Causal discovery algorithms search the data for the structure that best explains it, using the fact that causes and effects can leave distinctive statistical fingerprints. Domain knowledge then fixes what data alone cannot settle, such as the direction of time. After that, estimation methods measure how strong each arrow is, and refutation tests try to break the result, for example by adding a fake cause and checking that the answer does not change.

The graph is built in two steps. Causal discovery algorithms search the data for the structure that best explains it, using conditional independence patterns and, in some methods, asymmetries between cause and effect that leave statistical traces. Domain knowledge then constrains what the data cannot settle, such as temporal ordering, which fixes edge direction. Estimation methods then quantify the strength of each edge, and refutation tests try to break the result, for example by adding a placebo cause and checking that the estimated effect does not change.

None of this is certain, and an honest causal system says so. Conclusions hold only if the graph is right, and a factor that is never measured cannot be accounted for. Good causal tooling therefore grades its own confidence, shows the assumptions it made, and separates a well-supported cause from a plausible one. That transparency is part of the value: a causal claim can be checked and challenged, a black-box score cannot.

Conclusions are conditional on the graph and its assumptions, chiefly that the graph is correct and that no relevant variable is unmeasured. A variable that is never measured cannot be adjusted for. A causal system should therefore report its confidence, state the assumptions it made, and distinguish a well-supported causal claim from a plausible one. A claim stated this way can be checked and challenged. A black-box score cannot.

AI agents make chains of decisions: they call tools, read the answers, retry, and act. When something goes wrong, the visible failure is usually the last link. Picture a checkout agent that reports a wrong order status. Logs show the bad answer. The cause may be three steps earlier: a payment service slowed down, a request timed out, a retry returned partial data, and the agent filled the gap on its own. Fixing the prompt treats the symptom; fixing the timeout removes the cause.

An agent makes a chain of decisions: tool calls, reads of their results, retries and actions. In a failure, the visible error is usually the last link. Picture a checkout agent that reports a wrong order status. The logs show the incorrect answer. The cause may sit earlier in the chain: a payment service slowed, a request timed out, a retry returned partial data, and the agent filled the gap on its own. Changing the prompt addresses the symptom; fixing the timeout addresses the cause.

Auga applies causal AI to exactly this. Agents already describe what they do through OpenTelemetry, the industry standard for tracing. Auga turns those traces into measurable variables, learns the causal graph between them, and ranks the likely causes of a behavior by how much they matter. The aim is not a dashboard of everything that happened, but an explanation of why it happened and what to change first.

Auga applies causal AI to this case. It takes OpenTelemetry traces, which agents already emit, turns them into measurable variables, learns the causal graph between them, and ranks the likely causes of a behavior by how much they matter. The aim is an explanation of why a behavior occurred and what to change first, rather than a dashboard of everything that happened.

The same graph can answer forward-looking questions. What happens to answer quality if we switch to a cheaper model? Which setting would have prevented last week's incident? In regulated industries, where you cannot experiment on real customers, these what-if questions can be explored on a model of the system built from its own data, within the limits of what that model captures, instead of by taking the risk in production.

The same graph can be queried for forward-looking questions. How does answer quality change if the model is replaced with a cheaper one? Which setting would have prevented last week's incident? The first is an interventional query and the second a counterfactual. In regulated industries, where experimenting on real customers is not an option, such queries can be explored on a model of the system built from its own data, within the limits of what that model captures, instead of by taking the risk in production. Whether a given query can be answered from observational data alone depends on identifiability and on the assumptions above.

Finally, explanations are becoming an obligation. The EU AI Act requires traceability and human oversight for high-risk AI systems, and internal risk and audit functions increasingly ask the same of every agent in production. A causal explanation, with the evidence and the confidence behind it, is the kind of answer that holds up when someone asks: why did the system decide this? Auga supports this work. It does not by itself make a system compliant.

Explanation is becoming an obligation. The EU AI Act requires traceability and human oversight for high-risk AI systems, and internal risk and audit functions increasingly ask the same of every agent in production. A causal explanation that comes with its evidence and its confidence is the kind of record that supports an answer to the question: why did the system decide this? Auga supports this work. It does not by itself make a system compliant.