acceptodds
Under review as a conference paper at ICLR 2027

CausalVerify: End-to-End Verification of Causal Analyses by Language Models

Abstract

Language models increasingly perform empirical analyses end to end, yet existing evaluations assess the written explanation or whether generated code executes, not whether the executed workflow recovers the intended causal estimand. We introduce CausalVerify, an execution-grounded benchmark for end-to-end causal analysis that follows a model from research-context interpretation to estimand recovery. It scores this workflow at four distinct layers: method recognition, design specification, executable implementation, and estimand recovery. It combines 259 real-paper contexts, 100 fixed-seed synthetic scenarios with executable reference estimates, and 23 paper–twin pairs in which a model commits to a design before seeing the data and its executed analysis is scored against a canonical estimator on the same realised dataset. Execution is not correctness. Among 426 model-written workflows that run without error, 15.5% fail verification, and a keyword score of the effect direction stated in the text is a poor proxy for recovery. In a 23-pair, nine-model paired study, replacing a model's committed design with the reference design and its execution conventions raises joint recovery of the point estimate and standard error from 15.0% to 51.5%; yet 48.5% of eligible seeds still fail under the reference design. The direction replicates on six pairs built afterwards under a frozen construction protocol, although on the two newest pairs the gain is confined to models from the family that built the references. Design specification is consequential but not sufficient: a plausible method and runnable code do not guarantee recovery, and even supplying the reference design and its conventions leaves substantial downstream failure. CausalVerify evaluates the executed workflow rather than its surface plausibility, and every reported number is recomputed from frozen artifacts by a single script.

Primary area:
datasets and benchmarks
Keywords:
causal inference, large language models, benchmarks, execution-grounded evaluation, scientific workflows

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_XLmqOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces CausalVerify, a benchmark for evaluating LLM-generated causal analyses across four dimensions: method recognition, identification specification, executable implementation, and numerical estimation. It includes 259 real-paper contexts, 100 synthetic scenarios, and a paired evaluation involving 23 synthetic twins and nine models. The paired protocol compares model-generated analyses with an oracle setting that provides reference designs and execution conventions.

Critical strengths

a. The paired protocol evaluates model-generated and reference-guided analyses on matched tasks, allowing a more informative comparison of identification and execution performance. The use of consistent evaluation conditions and careful reporting of denominators strengthens the experimental analysis.

b. The paper examines scoring sensitivity, model and task differences, and potential evaluation errors, while also including prospective experiments. The authors explicitly acknowledge limitations and report unfavorable findings, which strengthens the credibility of the evaluation.

Critical weaknesses

a. The benchmark evaluates agreement with reference estimates and standard errors, while the oracle receives execution conventions that are not fully specified to the main agent. Consequently, some failures may reflect reasonable alternative implementations rather than incorrect causal reasoning.

b. The paired reference designs, synthetic tasks, and adjudication procedures rely substantially on agents from the same model family, with limited independent expert validation. The sensitivity of reported success rates to adjudication decisions raises questions about the robustness and generalizability of the evaluation.

Questions for authors

a. Could the authors clarify how many failures reflect incorrect causal identification or implementation, rather than differences in unspecified estimation conventions? A targeted analysis, particularly for RDD, and a comparison where both arms receive the same execution conventions would help clarify the contribution of reference-design information.

b. Could the authors provide an independent expert assessment of a subset of paired reference designs, synthetic tasks, and adjudication decisions? Additionally, how is consistency between the committed causal-design representation and the subsequently executed code verified?

c. Could the authors provide a breakdown of the remaining 48.5% oracle failures, distinguishing runtime issues, interface restrictions, truncation, and numerical mismatches? This would help clarify how much of the remaining difficulty reflects substantive causal-analysis errors rather than execution constraints.

1 comment
AuthorsOpenReview ↗

Author response to Reviewer XLmq

Thank you for asking how scoring differences arise. We traced the original RDD submissions and revised Figure 3 to show where oracle runs fail.

What the RDD failures measure. The oracle receives both the reference design and pinned execution conventions. On the six original RDD pairs, 370/1,060 eligible main-arm seeds failed the primary check after execution, versus 0/1,060 for the oracle. Removing 68 failures on the diagnostic-target pair and 20 non-finite estimates leaves 282 finite point misses on five conventional RDDs. We examined all 16 historical main-arm scripts that produced those misses against their frozen commitments, available variables and registered estimators. Across 320 seed runs we independently reconstructed the point outputs, including placeholders. This post hoc, AI-assisted review selects scripts with a finite miss. Each script is reused across 20 seeds (Appendix D).

Two scripts returned invalid primary outputs. One reported zero cost per life saved and zero SE when the twin contained no spending data. Another regressed the age-65 treatment indicator on itself after retaining only treated observations. Two debt-panel scripts each omitted one fixed effect explicitly named in the data dictionary. Adding just the omitted term to each regression reproduced all 20 registered points per script. On the election twin all 20 recomputed IK bandwidths exceeded o3's committed cap of 0.05. Its triangular local-linear fit reproduced every submitted point. Sixteen estimates missed the full-sample quartic reference. Election-year effects in its commitment could not be checked because the twin supplied no year.

Of the other eleven scripts, five combined several discrepancies including identifiable implementation departures, and four changed outcome scale or returned only an observable component. On the Medicare twin two programs estimated the same jump in raw admissions on all 20 seeds. On seed 0 it was 52.12 admissions per age cell, while the reference was 0.03786 log points. We leave two Peru scripts unattributed because the brief came from a replication and the reference targeted the original study. These cases do not identify a population share of failures due to incorrect causal identification.

Common inference conventions. In a separate election-twin pilot, two fresh Codex implementations shared the same clustering, joint CR1 formula and conventional point-estimate rule. This overrode the original local design's bias-correction requirement. Both scripts reproduced their assigned estimator on all 20 datasets. The local fit passed the registered joint check on 15/20 and the reference quartic on 20/20. On the full original panel the point-only gain was +32.6 pp [23.0, 42.8]. Design and conventions still change together.

Independent assessment and commitment fidelity. Completed human audits cover paper labels (method κ = 0.61, sign κ = 0.29) and R coefficient extraction (40/44 numeric agreements). The prepared external packet covers 11 designs with eight questions for each of two independent economists. It includes a data dictionary unavailable at Stage 1. Ratings are pending. Twin generators and individual adjudications still await independent assessment. Of 187 commitments, 23 passed the raw design verdicts, 55 after removing the inference field, and 140 after the full review. Review voided 318 field mismatches. V4 still scores SEs. Internal re-adjudication agreed on 120/123 sampled critical-field matches. All three disagreements were corrected. The hash identifies the design passed to the coding model. Table 15 shows the limit of that guarantee. GPT-5 committed to average and wage-specific employment effects, reported the average, documented missing baseline wages for the second effect, and passed on all 20 datasets. A field-by-field fidelity audit across the panel remains open.

The 48.5% residual. Figure 3(c) and Table 16 account for 1,814 failures among 3,740 eligible oracle seeds. Of these, 54 missed the primary target, 80 met it but missed the SE-ratio band, 940 encountered a forbidden import, 500 another runtime exception, 140 a capped generation, 60 a timeout, 40 an extraction-rule failure and zero missing JSON. The runner accepted no output on 1,680/1,814 failures (92.6%). Of 134 accepted failures, 53 had a non-finite estimate or SE and 81 had two finite values. In total, 1,733/1,814 failures (95.5%) lacked an accepted finite estimate and SE. With fresh generations on the same 207 cells under the expanded harness, oracle execution rose from 57.9% to 75.8% and recovery from 52.7% to 67.7%. Several harness settings changed together.

Reviewer_vxFsOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Motivated from the statement that existing evaulation of LLM causal analsis stop at text plausibility or "the code runs", which never checks the executed workflow, authors proposed CausalVerify, an end-to-end causal-analysis workflow at four separate validity layers: method recognition (V1), design specification (V2), executable implementation (V3), and estimand recovery (V4).

Critical strengths
  1. The gap is well motivated and concretely measured compared with a canonical estimator, the executed estimate on the same dataset separates "run" from "recovered the target" well: 15.5% of the time it could be executed but wrong and text direction scores carry little information about recovery.
Critical weaknesses
  1. The paired evidence is small we have 23 pairs, 9 models, and ~20 seeds per pair, the recovery intervals include zero (page 7) and the experiment section read like many individual report (line 365 - 372 references scattered figures and numbers) also we can have a unified experimental design at the first part for the experiment for readers' understanding and roadmapping

  2. A circular reference construction may confound a paired effect We have goal CDRs, twins, design-layer adjudication, and reference review produced by Claude-family. On the six prospective pairs, the oracle gain on the two pairs with all conventions fixed in advance comes form Claude models (I read 0 - 0.5% when without them)

Questions for authors

N/A

1 comment
AuthorsOpenReview ↗

Author response to Reviewer vxFs

Thank you for drawing attention to the interval that includes zero and to the two prospective pairs on which only Claude benefited. Both observations affect how we interpret the evidence.

What is estimated, and with how much precision? Figure 3 now puts four questions in one place. Panels (a) and (b) compare reference-guided and model-designed analyses on the original and prospective pairs. Panel (c) locates seed-level failures, and panel (d) repeats generation under a relaxed execution harness. Table 3 reports both pair sets by model.

In the original 23-pair panel, one defective pair was excluded. The remaining 187 schema-valid model–pair commitments contribute 3,740 eligible datasets per arm. The 20 datasets per script measure variation across realizations of one task. We resample pairs for uncertainty. For each trajectory that executed at least once, we calculated its recovery rate over the seeds it executed, then weighted trajectories equally within each design-verdict group. The difference was +21.6 percentage points (95% CI [−7.2, 45.1]). Only 12 trajectories in the V2-fail group executed at all. On the common denominator of all eligible seeds, supplying the reference design and its execution conventions raised recovery from 15.0% to 51.5% (+36.5 points [26.8, 46.9]). These comparisons answer different questions.

How much depends on the builder family? On the two pairs you identified, non-Claude recovery fell from 0.5% to 0.0%. We specified the pooled non-Claude comparison after observing the first six prospective pairs and before evaluating the next 21. Across all 27, 146 valid commitments gave 2,920 datasets per arm. Recovery rose from 2.5% to 22.0% (+19.5 points [13.8, 25.6]). Restricting to the 23 pairs whose conventions were fixed before evaluation gives +21.4 points [14.8, 28.4]. On the subsequent 21 alone, subtracting the first six from the published counts gives 59 versus 583 recoveries in 2,240 datasets per arm (+23.4 points, descriptive).

Table 3 implies 570 net additional recoveries across non-Claude respondents. GPT-5 contributed 283 and o3 contributed 229, together 512/570 (89.8%). Removing those two models as well leaves +3.1 points [−0.6, 7.2]. Excluding Claude respondents still leaves Claude-family involvement in construction and adjudication. Six prospective pairs also used a same-family second implementer for their final check. The human audits covered paper labels and coefficient extraction. Independent expert validation of the paired references remains open.

Reviewer_4vrDOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

The authors introduce a new benchmark named CausalVerify. It aims to combine both the realism of data from real papers with the verifiability of synthetic data. It does so by creating a "paper-twin" for each paper. Models are then evaluated on these paper twin pairs. The benchmark measures executability and correctness of model produced code. The authors show that simply checking whether model produced code executes is insufficient and the deeper analysis of checking correctness is required.

Critical strengths
  • The problem identified by the authors seems valuable.
  • The proposed benchmark approach seems valuable and reasonable.
Critical weaknesses
  • I believe that the benchmark design is not well explained. The benchmark is the central object of the paper; hence, a good explanation is critical. Within the main paper I was unable to understand how "paper-twin" are created and what they look like. Section 4 talks about the benchmark, but it does not explain the full benchmarking procedure. This is my primary concern. Without a strong understanding of what the benchmark looks like, I am unable to interpret the experimental results as I can't understand what is being evaluated
  • Benchmark choices are not justified. For example, in line 194 why do we choose "30 DID, 24 ES, 24 IV, 22 RDD" to be the distribution of scenarios? How do we know this is a representative/good distribution? Additionally, how are these reference scenarios sourced? Similarly, in line 199 the authors choose a "4,096-token output cap" for R code. How do we know this cap is reasonable? I would expect to see the authors do some analysis confirming the validity of this hyperparameter. For example, even something as simple as looking over all the reference R code and see that most code is below the 4096 token cap. This lack of supporting evidence makes it difficult to evaluate the generalizability of the results.
  • One of the claims of the paper is that executable code is not necessarily correct code. The authors explore this in section 5. However, it is unclear to me why this is novel. The idea that code compiling and executing, but still being incorrect has been around for decades, so I don't understand what is novel about the experiments in section 5. Am I misunderstanding the purpose of these experiments?
  • How many reference papers are in the benchmark? I saw "23 pairs" on line 318 but "100 scenarios" on line 271. I don't understand the difference between a "pair" and a "scenario". I'm assuming pair references to a reference paper and its paper twin. Either way, how do the authors justify that this is enough data to make statistically significantly predictions about model performance?

In summary, I think that the benchmark contruction is not explained in enough detail and I believe this prevents readers from being able to interpret the results. This is a critical concern. If the authors update their explanation, I will read it and evaluate the results of the paper again potentially updating my scoring.

Questions for authors
  • Why is it required to for designs to be hashed before the data is revealed? Isn't it enough to just restrict the model's order of operations? Additionally, can't this order of operstaions restriction also be achieved with prior benchmarks, e.g., CauSciBench?
  • I don't understand what the paper twins look like. Do the authors simply take the data from the original papers and somehow modify it to create a new data sample? If so, how does this provide additional realism beyond what previous synthetic data papers have done?
  • What is "V_2" from line 353? Relatedly, what are V1-4 in figure 3?
1 comment
AuthorsOpenReview ↗

Author response to Reviewer 4vrD

Thank you for stating precisely where the paper lost you; the revision (changes in blue) is organized around that reading. Section 4 now follows one task from brief to coefficient.

What is a paper–twin pair? Table 2 distinguishes 259 real-paper contexts, 100 standalone synthetic scenarios, and 23 original plus 27 prospective paper–twin pairs. One pair links a source paper to a generator that produces fresh observations under a source-checked causal-design representation (CDR). The paper supplies the institutional setting and identification structure. Language-model agents draft and source-check the reference design, an author approves it, and the design is frozen before the generator creates observations. Appendix D, Figure 6 shows the construction funnel. Table 14 distinguishes the construction inventory from the evaluated pairs.

For example, the Card–Krueger brief describes 410 restaurants surveyed before and after New Jersey raised its minimum wage, with Pennsylvania as the comparison. The model commits its design before seeing the twin schema. The released twin records unit_id, treated, post and fte. For example, in seed 0, simulated restaurant 0 is in the treated region and has 8.78 full-time-equivalent employees before the change and 17.05 after it. On each of 20 datasets, the canonical regression supplies the treatment-by-post coefficient and its standard error. In separate calls, the model writes code given its commitment or the reference design with pinned execution conventions. All nine models identified DID. Table 15 shows that three recovered all 20 datasets in both arms, three only under reference guidance, and three in neither.

What do the layers and hash establish? Table 1 defines V1 as method-family agreement, V2 as agreement on scorable critical design fields, V3 as execution, and V4 as numerical recovery. Separate calls enforce the ordering. Hashing lets an auditor identify the commitment supplied to Stage 2. Other benchmarks, including CauSciBench, could adopt this ordering.

Why these scenarios and budgets? The initial DID/ES/IV/RDD counts of 10/8/6/6 grew by 20/16/18/16. These construction quotas give coverage of all four families. Their proportions have no population interpretation. Fixed templates varied effect size, noise and sample size. GPT-4o wrote the later briefs from these parameters. Omitting each family in turn gives execution-without-recovery rates of 14.0–16.1%. Five R-panel endpoints had 4,096 output tokens, while o3 and GPT-5 had 16,384 including reasoning. Gemini hit its cap on 55/100 calls, of which 43 had no code block. On its 45 complete responses, 25 executed and recovered the target. Opus hit its cap on 4/100 calls (Appendix C, Tables 7–8). The release provides Python canonical estimators and no completed human R solutions for the requested length check. A budget-only R comparison remains open.

What does execution miss? Section 5 measures how often a run-only evaluation would accept an unverifiable analysis. Of 426 executing R workflows, 40 returned an out-of-band estimate and 26 supplied no extractable target coefficient (66/426, 15.5%, scenario-clustered 95% CI [12.1%, 19.2%]). As the relative-error tolerance moves from 10% to 100%, the failure rate ranges from 27.2% to 14.1% (Table 5).

How precise is the paired comparison? Of 23 original pairs, 22 enter this comparison after excluding one defective reference. On these papers and nine models, reference guidance improved recovery by 36.5 percentage points (95% pair-bootstrap CI [26.8, 46.9]). Resampling papers keeps the repeated datasets for each task together.

You offered to re-read the paper if the explanation of the benchmark were updated. The revision was written for that reading, and we would welcome it.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.