1 Introduction↩︎

Modern science and engineering increasingly demand for causal models [1] that move beyond purely statistical correlation to predict the outcomes of manipulations on the system (interventions) and reasoning about hypothetical scenarios (counterfactuals). Performing such inferences often requires a causal graph representing the network of cause-and-effect relationships, however the true causal graph is rarely known. Existing approaches [2]–[4] commonly attempt to learn this graph from data by relying on causal discovery methods. However, causal discovery from observational data is fundamentally limited by the assumptions required for causal identifiability [3], [5], [6]. Violations of these assumptions can result in multiple causal graphs being statistically undistinguishable, which leads to non-identifiable causal relationships and limits accurate causal discovery. These limitations can be overcome by integrating prior knowledge [7]. Domain experts can manually incorporate their knowledge by imposing edge constraints, but this has limited utility in high-dimensional settings [8]. In particular, unstructured text is a rich source of prior knowledge that is dense of causal information, while being massively available in the web, documents, and more. Recent works using Large Language Models (LLMs) show a promising outlook for automating the extraction of causal information [9]–[11], offering a great tool for the construction of large causal graphs [12], [13]. Furthermore, a Human-in-the-Loop (HITL) approach enables domain experts to guide the LLM reasoning process and obtain accurate solutions without requiring tedious manual specification.

In this paper we introduce CausalSTeward (CaST), a multi-agent causal copilot that discovers large causal graphs by combining human interaction, retrieval augmented generation (RAG), and data-driven methods. Our approach is human-first, and CaST has the duty of assisting the human in building a causal model while automating the collection of prior knowledge. CaST adopts a Divide-and-Conquer approach where agents iteratively partition the variable set based on their likelihood of being causally connected until the right level of granularity is reached. Successively, CaST estimates a local causal graph for each partition based on prior knowledge (retrieved from HITL and RAG), and observational data. Finally, the local causal graphs are merged together, obtaining the global causal graph.

We apply CaST to a diverse set of challenging datasets in the domains of manufacturing, neuropathic pain and the CausalChambers benchmark [14]. Our experiments evaluate CaST with LLMs of varying capabilities and compare against a set of seven other LLM- and data-driven baselines. Our ablations, which disable the RAG and human-in-the-loop components, demonstrate that only the joint use of both components leads to the strong performance of CaST.

Contribution: In this paper we present CaST, a Human-in-the-Loop (HITL) framework for joint collaborative causal discovery integrating tabular data, LLM prior knowledge and RAG search, together with human-feedback back domain specific questions. To the best of our knowledge, we are first to present an interactive multi-agentic framework with a Divide-and-Conquer paradigm that has the ability to discover causal graphs in high-dimensional causal settings.

2 Preliminaries and Related Work↩︎

Notation: We denote sets with bold \(\boldsymbol{V}\) and variables in lowercase \(v_i\). Causal Models: Within the framework of Pearlian causality [1], the most common class of causal models are Structural Causal Models, which we define as a 4-tuple \(\mathcal{M} \coloneq (\boldsymbol{U}, \boldsymbol{V}, P_{\boldsymbol{U}}, \mathcal{F})\) where \(\boldsymbol{U}\) is the set of exogenous variables, \(\boldsymbol{V}\) is the set of endogenous variables, \(P_\boldsymbol{U}\) is the probability density function of the exogenous variables \(\boldsymbol{U}\), and \(\mathcal{F} = \{f_1, f_2, \dots, f_n\}\) is the set of Structural Equations, where each element is a mapping such that \(f_i : u_i \cup Pa_i \rightarrow \boldsymbol{V}_i\), with \(u_i \subseteq \boldsymbol{U}\) and \(v_i \subseteq \boldsymbol{V}\). Every endogenous variable \(v_i \in \boldsymbol{V}\) is coupled to a structural equation that determines its values, i.e.  \(v_i = f_i (u_i, Pa_i)\).

Structural equations induce a set of dependencies between endogenous variables. Those dependencies can be organized in a directed acyclic graph (DAG) \({\mathcal{G}}(\boldsymbol{V},\boldsymbol{E})\), where \(\boldsymbol{V}\) are nodes and \(\boldsymbol{E}\subseteq \boldsymbol{V} \times \boldsymbol{V}\) are directed edges. We say that \(v_i\) is a parent of \(v_j\) if and only if \((v_i,v_j)\in \boldsymbol{E}\), and denote as \(Pa_i\) the parents of \(v_i\). In most cases, the true causal graph is unknown, and the task of extracting a causal graph is called causal discovery. When all variables are observable, we say there is causal sufficiency. Otherwise, if hidden variables are present, we have causal insufficiency. In causally insufficient scenarios it might not be possible to establish the direction of causation, and we can use a Maximal Ancestral Graph (MAG) [15] to account for those ambiguities by using undirected edges. Before defining a MAG, we first recall what is an inducing path. Given a subset \(\boldsymbol{L}\subset \boldsymbol{V}\), we say that a path is inducing relative to \(\boldsymbol{L}\) if every vertex not in \(\boldsymbol{L}\) is a collider on the path (apart from its endpoints), and every collider is an ancestor of at least one of the endpoints.

A MAG can be obtained by marginalizing hidden variables in a DAG [16]. The resulting MAG describes a group of causal models preserving ancestral and independence relations between observable variables.

An additional challenge is causal identifiability: When specific assumptions on the structural mechanisms are not fulfilled [3], [17], multiple causal graphs become statistically undistinguishable, unless prior knowledge [18] or interventional data [19], [20] is available. When only observational data is available, it is often not possible to identify a unique causal graph [21]. In that case, we are limited to a set of plausible causal models called the Markov Equivalence Class (MEC), which is an equivalence class containing all causal graphs sharing the same set of conditional independencies. Consequently, causal discovery on causally insufficient scenarios using observational data often results in an equivalence class of MAGs [4], [22], which can be graphically represented with a Partially Ancestral Graph (PAG), that we define below.

Classic algorithms yielding a PAG in causally insufficient scenarios are the Fast-Causal-Inference (FCI) [4] and the Iterative Causal Discovery (ICD) [22] algorithms. Both algorithms are constraint-based methods which iteratively remove edges when a conditioning set is found. That is, we can remove \(u \rightarrow v\) when a conditioning set \(\boldsymbol{Z}\) making them independent exists (\(\exists \boldsymbol{Z} : u \mathpalette{\independenT}{\perp}v | \boldsymbol{Z}\) with \(u\),\(v\), and \(\boldsymbol{Z}\) disjoint). Inconveniently, the number of possible conditioning sets grows exponentially with the number of variables, and many constraint-based methods present severe scaling limitations [23]. A valid approach for tackling high-dimensional data is to split variables into groups to be analyzed separately [24]. A mathematically rigorous way of grouping variables is the one of Causal Partitionings, defined in [25] and reported below.

The intuition behind causal partitionings is that variables are grouped in partitions reflecting how they are causally connected: If two variables are within the same partition, then they are causal neighbors. Importantly, a partition in a Causal partitioning can be further causally partitioned. Nested causal partitions can be arranged in a (causal) partition tree. In the ideal case, a causal partitioning can be computed exactly [25]. In practice, computing a causal partitioning is intractable, which forces heuristic estimates as in [25].

Divide-and-Conquer: The Divide-and-Conquer paradigm [26] relies on recursively splitting problems into smaller sub-problems, and successively merging their solutions. Algorithms in this class are typically executed in 3 separate phases: 1) Divide phase, during which the problem is iteratively partitioned in sub-problems until they are easy enough to be solved, 2) a Conquer step during which each sub-problem is individually solved, 3) a Combine step where the solutions of the sub-problems are merged following the order of sub-division in reverse. The power of this class of algorithms is that, upon satisfying a set of mathematical properties, we have guarantees on the accuracy of the solution, and sometimes even on its optimality. Recently, Divide-and-Conquer strategies have been applied to prompting [27].

Related work↩︎

LLMs for Causality: Formal causal reasoning of LLMs has been investigated in several studies [28]–[31]. While generally being able to perform simple causal reasoning tasks, studies generally find shortcomings, such as memorization and lack of generalization, in the causal reasoning capabilities of LLM. Further, [32] and [10] explore to which extent LLMs can be taught causal reasoning, and show their capacity of extracting causal information from text. For practical applications, LLMs have been applied for causal discovery and in the design of randomized-control trials [12], [29], [33]–[36]. However, challenges persist in high-dimensional settings due to finite context windows and long edge-lists representing causal relationships, which motivates our divide-and-conquer approach.

High-dimensional causality: Real world data can exhibit high dimensionality and non-identifiable causal relationships, making most causal models computationally prohibitive and inaccurate [37]. Consequently, researchers explored gradient-based methods [38], [39], cluster-DAGs [40], divide-and-conquer approaches [24], [41], and new variants of classic methods [42], [43]. Further, Human-in-the-Loop systems are studied in [44], [45] and [46].

3 CausalSteward: A multi-agentic causal copilot for causal discovery↩︎

In this section we describe the architecture and core principles of CaST, which are further highlighted in Fig.1. First, we present the core components of CaST. Next, we dive into our Explain-Divide-Conquer-Combine approach. Lastly, we describe how CaST retrieves causal information.

Human-in-the-Loop Causal Discovery: CaST is a framework for interactive causal discovery. It assists the experts in building a causal graph through a Human-in-the-Loop system, while automating the retrieval of prior knowledge from external sources. Our approach enables a more natural interaction, overcoming the limitations of manual methods. For example, instead of tediously enumerating edge constraints, which is unfeasible with high-dimensional data, humans can specify patterns of causal relationship or provide only partial causal information. Moreover, CaST is responsible for translating human-provided information into the language of causality, and also for complementing the human when it is uncertain.

Causal Discovery through Divide-and-Conquer: One of the main challenges in causal discovery is dealing with high-dimensional data [47]. CaST tackles high-dimensional causality with a divide-and-conquer approach, where variables are recursively assigned to smaller and more manageable partitions. To do so, CaST employs LLM agents to decompose the variables into separate smaller and causally-coherent clusters of variables. The clustering of variables is dynamic and iterative: clusters can be subdivided multiple times until the right level of granularity is reached. In 3.2 we define the criterion that allows CaST to adapt to the complexity of the task. Following, each sub-problem consists of estimating a local causal graph for each partition of variables. The core intuition is that LLMs perform better on smaller and more targeted tasks [48]. In practice, variables within each group should be single-themed and refer to a single causal phenomenon. This facilitates the agents during the conquer step, as they can reflect more in detail and perform more targeted RAG (or human) queries to retrieve the necessary causal information. As we will show in the Sec.5, variable partitioning makes the individual sub-tasks more intuitive for the agents. In practice, CaST is executed in four phases: Explain, Divide, Conquer, and Combine. These phases are carried out by a set of specialized agents, each one responsible for a specific task in the causal discovery process. First, during the (1) Explain phase, CaST gathers all necessary information before starting any discovery process, then the (2) Divide phase repeatedly partitions the variable set \(\boldsymbol{V}\). Afterwards, the (3) Conquer phase produces a local causal graph for every partition. Finally, the (4) Combine phase merges all the local causal graphs. In Fig.2 we provide a graphic depiction of CaST. We highlight that all our agents can be provided with RAG tools and human interaction to dynamically retrieve all the necessary causal information.

3.1 Explain Phase↩︎

Prior to the divide-conquer-combine phases, CaST implements an explanation step where an Explainer agent \(\mathcal{E}\) gathers information about the task and complements the information provided by the user. By doing so, it decreases the ambiguity about the meaning of each variable. First, the available meta-data (variable labels and dataset description) is provided to the agent. Next, \(\mathcal{E}\) outputs an expanded description with details on every single variable. We denote this new information as \(I\) and write this step as \[I = \mathcal{E}(\textcolor{reviewer1}{\text{X}_{labels}}, \boldsymbol{p}_{explain}),\] where \(\text{X}_{labels}\) are the variable labels, and \(\boldsymbol{p}_{explain}\) is a prompt containing the directions for the agent plus a task description provided by the user.

3.2 Divide Phase↩︎

The Divide phase recursively partitions the variable set \(\boldsymbol{V}\) with the aim of grouping causally related and semantically similar variables together. This step is carried out by two agents: the Divide-hypothesis agent \(\mathcal{D}_{hyp}\) and the Divide-critic agent \(\mathcal{D}_{critic}\). Both agents leverage the information gathered by the explainer agent to estimate a causal partitioning of \(\boldsymbol{V}\). Mathematically, given a partition \(\boldsymbol{P}_i\subseteq \boldsymbol{V}\) and a divide prompt \(\boldsymbol{p}_{div.hyp.}\), the Divide-hypothesis agent \(\mathcal{D}_{hyp}\) first proposes a possible partitioning, \[\{\boldsymbol{P}_{i,1}, \dots, \boldsymbol{P}_{i,N} \} = \mathcal{D}_{hyp}(\boldsymbol{P}_i, \boldsymbol{p}_{div. hyp.}),\] where \(\boldsymbol{P}_{i,k}\) denotes the k-th partition of \(\boldsymbol{P}_i\), such that \(\bigcup_k \boldsymbol{P}_{i,k} = \boldsymbol{P}_i\). Different partitions can overlap, i.e.  \(\boldsymbol{P}_{i, k} \cap \boldsymbol{P}_{i, l}\) might be non-empty for some \(k\) and \(l\). Following, a second Divide-critic agent is tasked to review (using the prompt \(\boldsymbol{p}_{div.critic}\)) the partitioning and apply corrections if necessary, \[\{\tilde{\boldsymbol{P}}_{i,1}, \dots, \tilde{\boldsymbol{P}}_{i,N} \} = \mathcal{D}_{critic}(\{\boldsymbol{P}_{i,1}, \dots, \boldsymbol{P}_{i,K} \}, \boldsymbol{p}_{div. critic}).\] The causal partitioning process continues recursively until \(\mathcal{D}_{hyp}\) stops partitioning further and concludes that the right level of granularity for causal discovery has been reached. In detail, \(\mathcal{D}_{hyp}\) and \(\mathcal{D}_{critic}\) are queried again on every partition with more than a number \(k\) of variables, and they have to decide whether to partition further or not. This iterative causal partitioning of the general task in simpler sub-tasks can be arranged into a partition tree, where each node describes a partition and its children are sub-partitions (Fig 2).

3.3 Conquer Phase↩︎

The conquer phase performs LLM-aided causal discovery. Once the divide phase estimates a causal partitioning, a conquer step derives a local causal graph for the variables within each partition that is a leaf in the causal partition tree. First, CaST employs two LLM agents to formulate a causal hypothesis in form of a graph. Next, a data-driven discovery step utilizes the causal hypothesis as a constraint to improve causal discovery.

1) Hypothesis Generation: After being provided with a description of the dataset, a hypothesis agent \(\mathcal{H}\) formulates an initial causal hypothesis \(\mathcal{C}_{hyp}\) for the variables within the partition. Given a partition \(\boldsymbol{P}_i\), we have \[{\mathcal{G}}^{hyp}_i = \mathcal{C}_{hyp}(\boldsymbol{P}_i, \boldsymbol{p}_{hyp}).\] 2) Critic Evaluation: A critic agent \(\mathcal{C}\) evaluates the causal hypothesis \({\mathcal{G}}^{hyp}\) and refines it based on its internal prior and available external information. Additionally, the agent is prompted to focus on being right at the interventional and at the counterfactual level. \[\label{eq:conquer95critic} {\mathcal{G}}^{critic}_i = \mathcal{C}_{critic}({\mathcal{G}}^{hyp}_i, \boldsymbol{p}_{critic})\tag{1}\] 3) Data-Driven Discovery: A causal discovery algorithm is used to insert additional edges to \({\mathcal{G}}^{critic}_i\). In practice, we use the edges in \({\mathcal{G}}^{critic}_i\) to bootstrap a constraint-based causal discovery algorithm \(\mathcal{F}\). Mathematically, \[\label{eq:conquer95refinement951} \tilde{{\mathcal{G}}}^{critic}_i = \mathcal{F}(\mathtt{D}_i, {\mathcal{G}}^{critic}_i),\tag{2}\] where \(\mathtt{D}_i\) is a subset of the input dataset corresponding to the variables in \(\boldsymbol{P}_i\), and \(\tilde{{\mathcal{G}}}^{critic}_i\) is the causal graph discovered by \(\mathcal{F}\). This discovery process complements the prior information provided by LLMs. In real scenarios, causal relationships can be non-identifiable, and prior constraints improve identifiability and overall performance [18]. In turn, the discovery process may find valid relationships that the LLM failed to extract from knowledge sources.

3.4 Combine Phase↩︎

The Combine phase merges the local causal graphs generated during the Conquer phase into a single global causal graph. Since edges within a partition are already estimated, the combine phase is responsible for merging those graphs. As written in Sec.4, if the Divide phase yielded a correct causal partitioning, performing the union of all local causal graphs is sufficient to obtain a consistent global causal graph. However, a practical challenge persists: if the causal partitioning operation during the divide phase is not accurate, the local causal graphs might not overlap, leading to disconnected components. Therefore, when merging two or more subgraphs, it is important to assess for edges between nodes in one group and another. For this phase, we adopt a procedure similar to the conquer step. This time, a merge-hypothesis agent \(\mathcal{M}_{hyp}\) is given a description of the groups, and is queried to generate a causal hypothesis for the missing edges that connect the local causal graphs, which we call merging causal hypothesis. Similarly to before, once a first merging causal hypothesis is obtained, a merge-critic agent \(\mathcal{M}_{critic}\) has the task to refine it. Given M local subgraphs, we have \[\begin{align} {\mathcal{G}}_{comb}^{hyp} &= \mathcal{M}_{hyp}({\mathcal{G}}_1, \dots, {\mathcal{G}}_M, \boldsymbol{p}_{comb}),\\ {\mathcal{G}}_{comb}^{critic} &= \mathcal{M}_{critic}({\mathcal{G}}_{comb}^{hyp}, \boldsymbol{p}_{comb}), \end{align}\] where \({\mathcal{G}}_{comb}^{hyp}\) and \({\mathcal{G}}_{comb}^{critic}\) are graphs with nodes \(\boldsymbol{V}_{comb} = \bigcup_{i = 1}^M \boldsymbol{V}_i\). The combine operation is iterated by following the order of subdivision in reverse. In other words, we follow the structure of the partition tree from its leaves to the root.

3.5 Retrieval of external knowledge↩︎

An ideal human-in-the-loop copilot can efficiently acquire information by balancing RAG for general knowledge and targeted queries to the human for context-specific information. Therefore, every agent in CaST can gather external knowledge either via retrieval-augmented generation (RAG) or via human interaction. For the Human-in-the-loop, all the agents have the capacity to query a human for additional information. The interaction is made on-demand, and takes the form of a tool-call. Similarly, we also provide to our agents the capacity to dynamically summon an Agentic RAG system on demand. Our RAG system can perform a web search and retrieve relevant information from the internet. We describe the system in detail in appendix 10 and present an exemplary application of CaST on the ASIA dataset [49] in Fig. 3.

4 Theoretical Analysis↩︎

We first study the ideal case. Next we analyze a general scenario. Throughout our analysis, we will always assume Causal Faithfulness.

Assuming that \(\mathcal{D}_{hyp}\) and \(\mathcal{D}_{critic}\) derive a partitioning that is causal by Def.3, we can prove that CaST can reach asymptotically the correct MEC.

In our case, since FCI is consistent in the large-sample limit, Th.1 implies that CaST inherits said asymptotic consistency. In general applications, however, Divide agents might not yield a correct causal partitioning and the conquer agents might have inaccuracies. Therefore, we provide a general analysis on how the total SHD is influenced by each component in non-ideal scenarios.

We observe above how the performance of CaST is linked to the accuracy of \(\mathcal{D}_{hyp}\)&\(\mathcal{D}_{critic}\) to derive a correct causal partitioning. Still, merge agents \(\mathcal{M}_{hyp}\)&\(\mathcal{M}_{critic}\) provide a safety-net that recover edges lost during the partitioning operation. Further, the performance of CaST is tied to the capacity of LLMs to provide the correct edge constraints to the causal discovery algorithm \(\mathcal{F}\) during the conquer phase. Therefore, it is crucial for CaST to access clear and reliable sources of information, which is why our agents leverage RAG and HITL, as described in Sec.3.5. We remark that the human-in-the-loop influences all agents performance. All our proofs are in appendix 8.

5 Experiments↩︎

We benchmark on the CausalMan dataset [37] and on the Neuropathic-Pain dataset [50]. We evaluate \(F_1\), precision, and Structural Hamming Distance (SHD). We repeat experiments with 5 different seeds, and compute mean and standard deviation for every metric. We also count the number of tool calls to RAG and HITL. HITL experiments on CausalMan have been carried on with the support of real domain experts in manufacturing. Extended tables in 12.

Large-Language Models: We test three different LLMs: GPT 4o-mini [51], o3-mini [52], and Qwen3-14B [53]. Prompt templates are in appendix 14. Graphs are encoded in form of node- and edge-lists [54]. No fine-tuning is performed. Ablations: We analyze the contribution of human interaction by testing three variants of CaST. One with both HITL and RAG active (HITL+RAG), and two with only either HITL or RAG enabled. CaST(RAG) features no human interaction, and is thus completely automatic. We additionally ablate with respect to the Divide&Conquer approach, with respect to the Critic mechanism. In appendix 9 we also include an ablation with respect to the partitioning hyperparameter \(k\).

Baselines: We compare with XGES [42], GranDAG [55], [43], FCI [4], BOSS [43]. We include also LLM-based approaches as CausalCopilot [44], LLM-BFS [33], and LLM-Pairwise [29].

6 Empirical Analysis↩︎

We focus our analysis on the performance, scalability and capacity to use prior knowledge from RAG and HITL. Therefore, we assess CaST with the following research questions: (Q1) Can CaST tackle causal discovery?; and (Q2) Can CaST scale?; and (Q3) Do computational requirements scale tractably with the size of the graph?; and finally (Q4) How beneficial are RAG and HITL to CaST?

6.1 Results on manufacturing and Neuropathic Pain data↩︎

Setup: We test on 2 variants of the CausalMan benchmark [37]: CausalMan Small (53 nodes, 108 edges), and CausalMan Medium (186 nodes, 553 edges), which exhibit causal insufficiency, mixed data-types, and diversified causal mechanisms. We also test on the Neuropathic-Pain dataset (222 nodes, 770 edges), which is causally sufficient with binary variables. All those benchmarks have an expressive variable naming where valuable information can be extracted with LLMs. Further, they have repeated causal sub-structures. More details in appendix 13.

Results: See Table 1 (extended in appendix 9). CaST considerably improves over purely data-driven baselines, outperforming for precision and F1. Improvements for SHD are not as significant, and GranDAG is close. Overall, results answer (Q1) positively, with margin for improvement in terms of recall, which signals that CaST tends to discover sparse graphs. Regarding scalability, the \(F_1\) decrease in performance from CausalMan Small to Medium is only sub-linear (by a factor of \(\approx 2\)) for CaST, whereas most data-driven baselines (XGES, GranDAG, CausalCopilot) degrade by several times. BOSS exhibits stronger robustness, but absolute metrics are still inferior with respect to CaST. Overall, results indicate that CaST scales robustly while keeping good performance, affirming (Q2). We also attribute this to the redundancy in CausalMan Medium: It contains many repeated patterns in variable naming/metadata, which are easy for LLMs to detect. The (HITL+RAG) variant provides a good trade-off between automation and control, which becomes more evident when using models with good instruction-following capabilities. Although they are prompted to make use of tools and balance HITL with RAG, we see how o3-mini struggles to follow those directions. For Qwen3-14B, instead, we see a significant improvement when the Human is inserted into the system, supporting (Q4) if the right LLMs are used. We notice that the closest baselines are the LLM-based. For LLM-BFS we observe a perfect precision, which is counterbalanced by low recall and high SHD, signaling a very conservative approach in inserting causal edges. On the computational side, most classic methods (e.g.  FCI) are intractable in high-dimensional settings. Our divide-and-conquer approach maintains a sub-quadratic growth from CausalMan Small to Medium both in token usage and runtime. Runtime indeed stays under 2 hours for all LLMs (Sec.9.3). Therefore, we confirm (Q3). LLM-based baselines are limited in large-scale settings: LLM-pairwise requires \(\mathcal{O}(D^2)\) queries (with \(D=\text{number of variables}\)), which makes it applicable on CausalMan Small, but unfeasible on other benchmarks. LLM-BFS has similar scaling behavior, and is also stopped by the limited context window.

Ablation for Divide&Conquer In Fig.4, we ablate with respect to the divide&Conquer mechanism. By disabling the Divide phase, we encounter two major limitations: 1) The agents \(\mathcal{C}_{hyp}\) and \(\mathcal{C}_{critic}\) must now estimate a causal graph for the whole variable set \(\boldsymbol{V}\), which leads to context overflows and slower inference, and 2) FCI is also required to estimate a causal graph for \(\boldsymbol{V}\) as well, which is computationally prohibitive. To carry on the ablation, therefore, we deactivated also FCI, resulting in a Conquer phase solely based on LLMs. Still, without Divide&Conquer, experiments on CausalMan Medium and Neuropathic were not feasible, similarly to LLM-BFS and LLM-Pairwise. On CausalMan Small, the Divide&Conquer approach is still beneficial for SHD and precision.

Ablation for Critic Agents By removing \(\mathcal{D}_{critic}\), \(\mathcal{C}_{critic}\), and \(\mathcal{M}_{critic}\), we see in Table 4 that precision and SHD drop consistently on all datasets. Hypothesis agents \(\mathcal{D}_{hyp}\), \(\mathcal{C}_{hyp}\), or \(\mathcal{M}_{hyp}\) alone tend to generate denser graphs with higher recall (coverage), but lower precision. We deduce that critic agents enable the control of false positives (better \(FPR_{\mathcal{C}}\)), acting as a filter that improves factuality.

Ablation for Causal Discovery Algorithm During the Conquer Phase, \(\mathcal{C}_{critic}\) outputs a set of edges that are used as constraints to a causal discovery algorithm. To validate our approach, we ablated with respect to the Causal Discovery algorithm, and now we test also the gradient-based DAGMA [56]. We additionally test both DAGMA and FCI with and without edge constraints. For DAGMA, those constraints are inserted post-training. Metrics are evaluated for each individual partition, and averaged across all partitions and across all runs. Results in Table 5 show that both algorithms improve upon using the agents’ constraints.

6.2 Real-World Case-Studies↩︎

Finally, we apply CaST (with GPT-5) to the CausalChambers benchmarks [14], and focus on the light-tunnel device. Results are in 5. We obtained a True-Positive-Ratio of 0.89 and a False-Positive-Ratio of 0.04, showing that CaST can valuably support experts during causal discovery. During execution, it performed multiple HITL queries, focused (at explain-phase) on clarifying some cryptic naming of variables, and later (during conquer-phase) on gathering details on the physical system.

Interestingly, the resulting graph this time is denser than the ground truth, and the conquer agents often provide coherent arguments for those additional links. This leads to higher SHD (76), which occurs because the model proposes additional causal sub-structures related to the electronics of the device, whose are absent in the ground truth graph. Those edges might either be unmodeled effects of the system, or overly detailed hypotheses (i.e.  negligible causal relationships), which in both cases highlight CaST’s capacity to retrieve potential relevant domain mechanisms that expert can then evaluate afterwards. Additional case study on the Earthquake dataset is reported in Appendix 9.

7 Conclusions↩︎

CaST is an AI copilot and to our knowledge it is the first one combining a Human-In-The-Loop approach, a multi-agent architecture, and the Divide-and-Conquer paradigm for causal discovery. In our experiments we demonstrated considerable performance improvements over existing data-driven methods and empirically showed how CaST can integrate human feedback into causal discovery.

Limitations and future Work: The performance of CaST is limited by the availability and quality of prior information. Additionally, CaST could integrate retrieval-augmented generation (RAG) from more varied sources of prior knowledge, which could further enhance its capabilities. Indeed, CaST can be extended to use a wider set of tools and different LLM agents. Finally, this work could be extended beyond causal graphs, aiming towards more general causal reasoning tasks.

Appendix for “CausalSteward: An Agentic Divide-Conquer-Combine Copilot for Causal Discovery”↩︎

8 Theory↩︎

We first provide a theory describing the ideal case, i.e.  what happens when we have perfect agents which can derive a causal partitioning satisfying Def.3 without any error, while also having a perfect conquer phase. Next, we provide a generalization, where we provide error bounds and also an expression for the final SHD in terms of the performance of each agent.

8.1 Ideal Case of Perfect Causal Partitioning↩︎

We start from the assumption that the conquer phase is consistent in the infinite data limit.

Assumption 1 is valid for algorithms such as FCI, and is still valid if edge constraints provided by the LLMs are correct. When consistency of the conquer phase is assumed, then consistency of the overall method follows, as we prove in the next theorem.

8.1.0.1 Can \(\boldsymbol{C}_1\), \(\boldsymbol{C}_2\), and \(\boldsymbol{C}_{1-2}\) overlap?

\(\boldsymbol{C}_1\) and \(\boldsymbol{C}_2\) can overlap in those cases where both variables and their conditioning set are contained in the intersection \(\boldsymbol{P}_1 \cap \boldsymbol{P}_2\), i.e., \(u \perp v | \boldsymbol{Z}\) with \(u, v, \boldsymbol{Z}\in \boldsymbol{P}_1, \boldsymbol{P}_2\).

8.2 Error-Bounds for approximations of Causal Partitionings↩︎

Given the Divide&Conquer approach, CaST can be analysed in 2 parts: Inter-Partition level, and Intra-Partition level. The former is associated with edges between nodes in separate partitions, and the latters with edges within a partition, that belong to the individual sub-graphs.

8.2.0.1 Inter-Partition Analysis

To analyze how errors are generated during the partitioning operation, we define the Causal-Cut as \[E_{cut} = |\{ (u,v) \in \boldsymbol{E} | \exists \boldsymbol{P}_i, \boldsymbol{P}_j \in \boldsymbol{P} \text{ with }i\neq j\text{ such that }u \in \boldsymbol{P}_i \text{ and }v \in \boldsymbol{P}_j \}|\] where \(E_{cut}\) is the number of causal edges "severed" by the partitioning operation, i.e.  the size the cut. The causal cut measures the number of edges bridging partitions that are lost during the partitioning operation. We remark that \(E_{cut}\) is computed between a partitioning and a causal graph, therefore it ignores eventual merging heuristics.

Still, our analysis must include the effect of Merge agents \(\mathcal{M}_{hyp}\) and \(\mathcal{M}_{critic}\), which are responsible for inserting additional edges between partitions. Those results in added edges which might increase the number of true positives, but also the number of false positives in case of bad guesses. We define with \(H_{correct}\) the number of true positives (TP) guessed by the heuristic, and with \(H_{incorrect}\) the sum of false negatives (FN) and false positives (FP) guessed by the merge agents. In the following, we assume \(E_{cut}, H_{correct}\), \(H_{incorrect}\) to be random variables that count such quantities.

Our first result characterizes the partitioning operation itself, which models the number of false positives in the learned graph.

The intuition behind Th.4 is that the partitioning operation, besides constraining the search for a causal graph, also induces a number of false negatives, which are recovered by the merge heuristic. It is also trivial that \(FP_{inter}\) can only be identical to \(H_{incorrect}\) since the partitioning operation is not adding any other edge. From empirical experiments, typically LLMs excel in precision while having limited recall, implying that the term \(H_{incorrect}\) tends to be small and often negligible.

We can extend it to a concentration lemma by applying Höeffding’s inequality, which we recall below.

By applying the above-mentioned inequality, we have the following theorem.

Further, in real-world and large-scale settings where no ground-truth is available, this lower bound can be estimated by drawing a subset of the inter-partition edges, and checking with a domain expert how many were correctly estimated. With this procedure, it is possible to draw an estimate of \(FP_{inter}\), \(FN_{inter}\) and \(E_{cut}\) to evaluate the real performance of CaST.

8.2.0.2 Intra-Partition Analysis

We hereby show that under the assumptions of sound and completeness, errors during the Conquer phase appear mainly as False Positives.

In case a partitioning is incorrect, some d-separating sets might end being scattered across partitions, making it impossible to find those sets within a partition. This results in FCI being impeded to remove certain edges, which we call spurious adjacencies (SA).

In other words, the performance of FCI during the conquer step is hindered by the quality of the partitioning operation, as a bad partitioning might result in breaking the d-separating set across partitions (a d-separation failure), which results in false positives i.e.  Spurious Adjacencies.

From this observation, we can derive an hard lower error-bound for the Conquer step

The precision of the LLMs is crucial for achieving good intra-partition performance. From our experiments, the intra-partition precision of LLMs it typically very close to 1, which is enabled by the critic mechanism that helps filtering out unwanted edges.

We remark that this identity is improved further in the asymptotic limit as FCI removes all false negatives in the infinite-data limit.

8.2.0.3 General Results

After analyzing what happens within partitions, and between partitions, we aggregate all the past results in order to obtain general estimate on the most important drivers for CaST’s performance.

In essence, we can now see more clearly how the total SHD depends on: 1) The quality of the partitioning, as the number of spurious adjacencies might increase under bad partitioning, 2) The quality of the heuristic, as merge agents act as a safety-net to recover edges lost due to partitioning, and 3) The quality of the LLM’s prior constraints within each partition.

8.3 Conflict Management↩︎

Conflicts might arise when, after performing causal discovery on two partitions that are overlapping, we observe different edges in different partitions.

From a theoretical standpoint, the exact/most rigorous way of managing conflicts is to search for conditioning sets on the merged graph, but that is not applicable to large-size graphs due to computational reasons. Therefore, we need a tractable criterion, and for CausalSteward we adopted what follows.

Let \(u, v \in \boldsymbol{P}_1 \subseteq \boldsymbol{V}\) and \(u, v \in \boldsymbol{P}_2 \subseteq \boldsymbol{V}\), i.e.  both nodes belong to the overlap \(\boldsymbol{P}_1 \cap \boldsymbol{P}_2\). Further, denote with \(G_1\) the graph derived from \(\boldsymbol{P}_1\) and with \(G_2\) the graph derived from \(\boldsymbol{P}_2\).

We identify 3 cases:

1. An edge (any type) is present in \(G_1\) but not in \(G_2\): In this case, it means there exist a conditioning set s.t. \(u \perp v\; |\;\boldsymbol{Z}\) with \(\boldsymbol{Z}\in \boldsymbol{P}_2\) and \(\boldsymbol{Z} \notin \boldsymbol{P}_1\). Since \(\boldsymbol{Z}\subset \boldsymbol{P}_2 \subset \boldsymbol{V} \implies u\perp v \;|\boldsymbol{Z} \;\text{with}\; u, v, \boldsymbol{Z}\in \boldsymbol{V} \implies\) No edge between \(u\) and \(v\).

2. For all other cases, we "overlap" the causal relationship: If the edge \(u \rightarrow v\) is present in \(G_1\), but the opposite one \(v \rightarrow u\) is also present in \(G_2\), we insert a bi-directed edge. If the edge \(u \rightarrow v\) is present in \(G_1\), but the edge \(v \circ - \circ u\) is present in \(G_2\), we insert the \(u \circ - >v\) edge.

Also other available methods leveraging Divide&Conquer adopt approximations to manage conflicts tractably: For example, DCDILP (Dong et al. 2025) manages conflicts via Linear Programming, and other methods maximize a BIC score greedily.

9 Additional results↩︎

Hereby, we present a more complete exposition of our results which also includes additional metrics.

9.1 Case-Study on Earthquakes Dataset↩︎

The Earthquakes dataset contains 7 variables that describe occurences of earthquakes by date, geographic location, and power. It contains the variables \(\boldsymbol{V} = \{richter, deaths, day, month, year, area, region\}\).

Given the small graph size, CAST partitioned the nodes into three groups: \(\boldsymbol{P}_1 = \{richter, deaths\}\), \(\boldsymbol{P}_2 = \{day, month, year\}\), and \(\boldsymbol{P}_3 = \{area, region\}\).

We observed that, during the explain phase, it understood correctly the variable meaning without the need of the domain expert. During the conquer phase:

• On the first cluster, LLMs correctly establish that richter \(\rightarrow\) deaths.

• On the second, the hypothesis agent suggests year \(\rightarrow\) month \(\rightarrow\) day, which is discarded by the critic agent, showing a nice corrective mechanism.

• On the third, it correctly suggests that region \(\rightarrow\) area, as an area is contained within a region, and some regions are more susceptible to earthquakes.

During the merge-phase, CAST reflects on possible connections between clusters. Here is an extract:

Overall, we have more meaningful causal relations compared to prior works. CAST is more conservative, and removes connections when uncertain.

9.2 CausalMan Small↩︎

9.3 CausalMan Medium↩︎

9.4 Neuropathic Pain Dataset↩︎

9.5 Extended Discussion↩︎

9.5.0.1 Tool usage across LLMs:

Ablating with respect to RAG and HITL, we can evaluate the impact of prior knowledge during the discovery process. However, we see that different LLMs respond differently to having those new tools available. For Qwen3 and GPT4o-mini, the number of human queries is linked to an increase in performance. However, we observe that GPT 4o-mini is very prone to forget past interactions, and frequently asks multiple times for the same information. Other LLMs, in particularly o3-mini, exhibit a smaller increase in performance. Although prompts encourage human interaction, o3-mini shows a scarce amount of HITL calls, even in instances where it is necessary. From this, we deduce that the best fit for CaST are those LLMs that have good instruction-following capabilities. Finally, results show how CaST(HITL+RAG) provides a viable trade-off between automatization and human control, and is consistently better than using just RAG. Again, this holds only for those models which follow the prompted instructions.

9.5.0.2 Ablation for Partitioning Hyperparameter \(k\):

In CaST, the divide agents \(\mathcal{D}_{hyp}\) and \(\mathcal{D}_{critic}\) are queried every time a group has a number of variables bigger than \(k\), which is an integer hyperparameter to choose. We remark that this partitioning is not enforced: Divide agents can choose to not partition further even if the partition-size is bigger than \(k\). In Table 6, we varied this hyperparameter and observed how performance varied. We see how increasing the partition size reduces SHD but also recall, while increasing precision. Overall \(F_1\) also degrades. As partitions get bigger, it becomes harder to get a good coverage, and LLMs tend to act more conservatively.

9.5.0.3 Performance on Neuropathic-Pain diagnosis data:

Although high-dimensional, data from the Neuropathic Pain dataset is binary and causally sufficient, which results in less limitations from a causal identifiability point of view. Indeed, purely data-driven methods tend to be less in disadvantage with respect to CaST. Still, it is evident that the impact of prior knowledge permits CaST to achieve high precision and lower SHD. We still observe, again, that other LLM baselines could not run due to slow inference (LLM-Pairwise grows \(\mathcal{O}(D^2)\)) and limited context window.

10 Agentic RAG↩︎

One of the pillars of CaST is the capacity to dynamically query an agentic RAG system on demand. In detail, it takes the form of a tool-call, and every agent can decide when to query the RAG system. In this way, agents can use their own internal prior for trivial tasks, and retrieve further prior information when it is necessary.

10.1 Architecture↩︎

The system is composed by a a set of agents which, upon receiving a query \(\mathcal{Q}\), are responsible for performing a web search to retrieve relevant causal knowledge.

10.1.0.1 Web-search agents:

The system is composed by a set of agents which perform a web search. The steps are:

1. A Query agent receives the query \(\mathcal{Q}\), and translates it into keywords to be used on a search engine.

2. A web-search API is executed with the keywords, and we extract the 5 best results.

3. A summary agent aggregates all results by writing a summary.

4. A reflection agent reflects on the summary and extrapolate further causal information.

5. A final summary agent provides a conclusive answer with a comprehensive explanation.

11 Divide-Conquer-Combine Algorithm↩︎

Before detailing the logic of the process, we clarify the organization of variable partitions and their local causal graphs. Each partition is represented as \(\mathbf{P}_i\), with its corresponding local causal graph defined as \[\mathcal{G}_i := \mathcal{G}(\mathbf{P}_i, \mathbf{E}_i),\] where \(\mathbf{E}_i\) is the edge list for that partition.

Partitions are stored as nodes within a Partition Tree, denoted by \(\mathtt{T}\), whose structure has the following key aspects.

Attributes of each partition node:

• Variable list (\(\mathbf{P}_i\)): the subset of variables in the partition.

• Edge list (\(\mathbf{E}_i\)): the edges defining the local causal graph.

• Description: specific information about the partition, used together with the general description \(I\) to write prompts \(\boldsymbol{p}\) for the agents.

• Solved flag (solved): a boolean indicating whether the partition has been processed by the Conquer or Merge operations.

Functions of the Partition Tree:

• Remove node: deletes a partition node from \(\mathtt{T}\).

• Retrieve children: obtains the list of child partitions for a given node. For example, for a partition \(\mathbf{P}_i\), its subpartitions \(\{\mathbf{P}_{i,1}, \dots, \mathbf{P}_{i,N}\}\) are stored as its children.

• Find unsolved leaves: identifies the leaf nodes (nodes without children) that have not yet been marked as solved.

• Find ready parents: identifies parent nodes for which all children have been marked as solved.

The root node of \(\mathtt{T}\) stores the full variable set \(\mathbf{V}\).

12 Benchmarking setting↩︎

In this section we provide additional details on the benchmarking setting, including details on the implementation and how each dataset has been pre-processed.

12.0.0.1 Hardware:

Experiments for CaST using GPT 4o-mini and o3-mini were performed through Azure OpenAI. For Qwen3-14B, experiments were performed by using an A100 GPU (80GB VRAM) and an AMD EPYC 7643 CPU. Identically, also GranDAG used the same GPU. XGES instead has been run as a CPU-only job.

12.1 Neuropathic Pain Dataset:↩︎

We perform our experiments on the Neuropathic pain dataset (222 nodes). All variables are binary and we do not perform any normalization.

We remark that the data-driven FCI algorithm within the Conquer phase is executed by extracting the relevant columns from the dataset (related to the nodes in the sub-graph to refine). However, this dataset contains a number of constant columns, therefore we added a small gaussian noise \(\epsilon \sim \mathcal{N}(0, \sigma)\) with \(\sigma = 0.0001\) to the dataset, with the goal of maintaining the correlation matrix always non-singular. This is necessary, as the \(\mathcal{X}^2\) conditional independence tests require it. This dataset is publicly available at Link

12.2 CausalMan Dataset:↩︎

We perform our experiments on CausalMan Small (53 nodes) and Medium (186 nodes) with 50.000 samples. Data has been normalized between -1 and 1. Categorical variables have been embedded on an equally spaced grid, still between -1 and 1. Further details on the data in the next section 13.

13 Manufacturing Data: CausalMan Dataset↩︎

The CausaMan Dataset [37] is modeled after a real world production line performing a press-fitting process. It presents two variants, namely CausalMan Small and CausalMan Medium, which feature respectively 53 and 186 variables. From the evaluations present in [37], we observe how classic data-driven methods are limited due to limitations arising from causal identifiability.

13.1 Data Description↩︎

Data from the CausalMan Dataset features different characteristics which makes it a challenging benchmark. Importantly, it exhibits a large amount of confounding effects and non-identifiable causal relationships, which bounds the efficacy of purely data-driven methods.

We recall here the main characteristics:

• Causal Insufficiency: A large SCM where half of the variables are hidden, implying an high level of confounding effects.

• Hybrid Data-types: Continuous, discrete, categoricals and binary variables are all present.

• Non-linear Causal Mechanisms and non-additive noise models: Causal mechanisms are often non-linear and the noise is not treated additively.

• Discrete-to-Continuous relationships: Relationships from discrete variables to continuous ones are present. They take the form of switching mechanisms, where the noise distribution of certain continuous nodes varies depending on the discrete values of its parents.

13.1.1 ↩︎

14 Prompts↩︎

We present in this section all the prompt templates that have been used. We remark that every phase -except for the explain phase- adopts an Hypothesis-Critic approach, where an agent proposes an hypothesis for the solution, and a critic agent follows with a refined version. We recall our notation: \(\mathcal{E}\) is the explainer agent, \(\mathcal{D}_{hyp}\) is the Divide-Hypothesis agent, \(\mathcal{D}_{critic}\) is the Divide-Critic agent,\(\mathcal{C}_{hyp}\) is the Conquer-Hypothesis agent, \(\mathcal{C}_{critic}\) is the Conquer-Critic agent, \(\mathcal{M}_{hyp}\) is the Merge-Hypothesis agent, and finally \(\mathcal{M}_{critic}\) is the Merge-Critic agent.

We follow with every prompt template that has been used. We additionally concatenate to those prompts a number of few-shot examples on how to efficiently use the provided tool (RAG and HITL), which we omit for brevity.

14.1 Divide Phase↩︎

14.1.1 Divide-Hypothesis agent↩︎

First, the Divide hypothesis agent \(\mathcal{D}_{hyp}\) received the following system prompt.

Following, at every iteration of the Divide phase, \(\mathcal{D}_{hyp}\) adopts the following user prompt.

14.1.2 Divide-Critic Agent↩︎

The Divide hypothesis agent \(\mathcal{D}_{critic}\) receives the following system prompt.

Following, at every iteration of the Divide phase, \(\mathcal{D}_{critic}\) adopts the following user prompt.

14.2 Conquer Phase↩︎

14.2.1 Conquer-Hypothesis Agent↩︎

14.2.2 Conquer-Critic Agent↩︎

14.3 Combine Phase↩︎

14.3.1 Combine-Hypothesis↩︎

14.3.2 Combine-Critic↩︎

To illustrate how CaST’s execution flows, we report here a complete interaction on the Earthquakes dataset. To keep it readable, we omit to repeat the system and user prompt templates (already provided in Sec.14), and only report the LLM answers, HITL Calls, and User responses. An additional end-to-end interaction on the CausalChambers dataset is provided in the supplementary materials.

References↩︎