acceptodds
Under review as a conference paper at ICLR 2027

ACT: Agentic Classification Tree

Abstract

When used in high-stakes settings, AI systems are expected to produce decisions that are transparent, interpretable and auditable—a requirement increasingly expected by regulations. Decision trees such as CART provide clear and verifiable rules, but they are restricted to structured tabular data and cannot operate directly on unstructured inputs such as text. In practice, large language models (LLMs) are widely used for such data, yet prompting strategies such as chain-of-thought or prompt optimization still rely on free-form reasoning, limiting their ability to ensure trustworthy behaviors. We present the Agentic Classification Tree (ACT), which extends decision-tree methodology to unstructured inputs by formulating each split as a natural-language question, refined through impurity-based evaluation and LLM feedback via TextGrad. Experiments on text benchmarks show that ACT matches or surpasses prompting-based baselines while producing transparent and interpretable decision paths.

Primary area:
interpretability and explainable AI
Keywords:
Interpretable Machine Learning, Large Language Models (LLMs), Semantic Decision Trees, Prompt Optimization, Unstructured Data Classification

Reviews

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

The authors propose a method that utilizes LLM to build decision tree on unstructured (text) data. On the technical side, at each tree node they iteratively refine the rule via TextGrad by computing Gini + Semantic Analysis features. On the evaluation side, they use 5 small datasets, 4 LLM backbones (gemma3 4b, gpt-4.1 nano and mini, qwen3 4b) and compare against a few baselines such as CART+TF-IDF, CoT, TextGrad: they outperform LLM-based methods and tie CART+TF-IDF.

Critical strengths
  1. The paper is easy to follow. The authors supply examples and concrete implementation steps, so it seems easy to reproduce.
  2. The method is intuitive. It mimics CART in that it also minimizes the impurity index and greedily splits the space. To integrate the text, the authors use iterative refinement via TextGrad and also add semantic features.
  3. Compared to other naive LLM approaches, the proposed method is better on the given set of 5 datasets.
Critical weaknesses
  1. While the method is intuitive, it is not principled per se. For example, what if we skip the semantic analysis, sgs_g, entirely? Do you do sample bagging? TextGrad has non-trivial variance, how do you battle this, e.g., it would help to see stability analysis (re-run with different seeds / initial prompts)?
  2. Cost analysis. The proposed method requires LLM at train and inference time and still performs only on par with CART+TF-IDF.
  3. Many naive baselines are skipped. For example, I would try initializing from CART+TF-DF, then ask a SOTA coding agent such as GPT-6 or Opus 5.5 to replace the TF-IDF with some semantically-informed program, e.g., suppose at node ii CART splits based on the terms cough and blood, the agent could rewrite into an inspectable human-readable and transparent code snippet that would use a regexp to check the symptoms. Another approach one could try is to simply prompt the SOTA agent to produce semantically meaningful decision tree with questions at each node. This is cheap, does not require any specific method, and would be the first thing I would try in practice.
  4. Potential data leak. Datasets such as IMDB and Spam have most likely already appeared in the pre-training corpus of the modern LLMs. Hence, I find the following claim to be doubtful. Indeed during the iterative refinement, TextGrad, may steer the prompt towards known solutions. Already in iteration 0 in the Appendix, the model has proposed to split on severe systemic symptoms such as coughing blood, weight loss, which overlaps with WHO symptom list wording.

derived from the training data rather than from prior knowledge

Some future directions, if the authors choose to pursue this project further is to try combine their method with Jev-like model: it's more budget-friendly, faster to run, and also provides calibrated probabilities.

Questions for authors

Please, see weaknesses above.

4 comments
AuthorsOpenReview ↗

Answer (1/2) to reviewer z2pj

We thank the reviewer for their time and helpful comments, which we address below.

W1: Principledness, ablation of semantic analysis, bagging and TextGrad variance

  • Principledness: the split choice in ACT is the same as in CART: among the evaluated candidates, the question with the lowest weighted Gini impurity is kept. The LLM components only propose candidates. Two rules from our code were missing from Algorithm 1 and are now stated: the seed question is never kept, and subtrees whose leaves all carry the same label are collapsed into a single leaf, which removes questions that cannot affect the prediction.
  • Semantic analysis ablation: the semantic analysis is the only channel through which training examples reach the question generator. Since ACT starts from a task-agnostic seed, removing it entirely would leave the optimizer with only the current question and a scalar impurity value, i.e., with no information on what the task is about. Appendix G.1 therefore studies the meaningful variant of this ablation: it reduces how many examples the semantic analysis sees (Tables 12–13). With the number of candidates fixed, ACT (d=4, k=20) goes from 65.8% (m=5) to 70.3% (m=50), which indicates that the semantic feedback drives the quality of the questions; the effect is not monotonic for ACT (d=3, k=10).
  • Bagging: ACT does not use sample bagging. Gini is evaluated on all samples reaching the node. The semantic analysis uses at most m=50 randomly sampled well-classified and m=50 misclassified examples per branch.
  • Variance: over 5 seeds × 4 LLMs × 3 datasets, ACT significantly outperforms TextGrad (+3.74 pts, Wilcoxon p<0.0001, r=0.828) and CoT (+9.61 pts, p<0.0001, r=1.0). At inference, the learned questions are stable across 10 repeated runs: 98.3% label agreement and 91.2–98.9% per-depth agreement (DIAGNO, GPT-4.1-Nano). Please see answer to W2/Q3 and Q5 of reviewer m4L6 for the more detailed results.

Changes in the paper: Section 3.2 and Algorithm 1 now include the seed-exclusion and pruning rules. The "Ablation studies" paragraph of Section 4.1 discusses the m-ablation. Appendix H (Table 17) reports the significance analysis and Appendix J (Tables 19–20) the consistency of node answers.

W2: Cost vs. TF-IDF+CART

At inference, ACT only queries the nodes along one path. This averages about 1.1–3.1 LLM calls per sample (Table 11), and inference cost stays within the same order of magnitude as TextGrad and below DSPy in tokens (Appendix A). ACT is of course more expensive than TF-IDF+CART.

ACT is also not merely on par with TF-IDF+CART:

  • it outperforms TF-IDF+CART on IMDB (95.1 vs. 66.8), SPAM (99.0 vs. 92.7), JAILBREAK (93.4 vs. 92.8) and BANKCHURN (65.2 vs. 63.2);
  • on DIAGNO, it outperforms TF-IDF+CART with GPT-4.1-mini (82.3 vs. 78.8), but not on average over LLMs (72.8 vs. 78.8);
  • new result on binary SNLI (entailment vs. neutral, GPT-4.1-nano, 600 training and 6,587 test samples): ACT reaches 90.3%, compared with TextGrad (88.5%), TF-IDF+CART (51.1%), TF-IDF+XGBoost (53.0%) and RuleFit (51.8%).

TF-IDF splits also ignore negation and word order ("this movie is not good"), and they often rely on uninformative terms such as our or also (Fig. 7–8).

Changes in the paper: the paragraph of Section 4.1 on TF-IDF + CART now gives per-dataset numbers, DIAGNO included. Appendix I (Table 18) reports binary SNLI, and Appendix A corrects the training-cost comparison.

AuthorsOpenReview ↗

Answer (2/2) to reviewer z2pj

W3: Naive baselines (CART+TF-IDF rewritten by a coding agent; SOTA agent prompted to produce a tree)

We could not run these two baselines within the discussion period. The closest baseline in the paper is the concept-bottleneck baseline (Con. tag.): the same LLM as ACT proposes 50 salient concepts from the training data and labels each text with them, and a CART of depth 4 is fit on these binary features. ACT outperforms it on all five datasets (e.g., 72.8 vs. 64.7 on DIAGNO and 65.2 vs. 55.8 on BANKCHURN, averaged over LLMs). The closest published variant is LeaPR (Poesia & Sampaio, 2025), now discussed in Section 2: an LLM writes Python features for the leaf being split from its training examples, and the split with the lowest impurity is kept. These features are proposed once per leaf, whereas ACT refines each question over k steps. A program derived from TF-IDF splits also stays blind to negation and composition: a regular expression on cough and blood does not separate "coughing up blood" from "no blood when coughing", whereas an ACT node does.

Changes in the paper: Section 2 now discusses LeaPR and concept-bottleneck approaches, and Section 4 and Appendix E.1 describe the Con. tag. baseline.

W4: Potential data leakage

We agree that pretraining exposure (e.g., IMDB, SPAM) cannot be ruled out and may steer the refinement. However, all LLM-based baselines (CoT, DSPy, TextGrad, Con. tag.) use the same LLMs, so the comparison remains fair. Moreover, these baselines receive the task description and class names, whereas ACT starts from a task-agnostic seed question. The baselines are therefore, if anything, better positioned to exploit prior knowledge.

ACT also yields its largest gains on BANKCHURN, which relies on dataset-specific attribute relationships rather than pretraining-aligned semantics (Appendix B.3): 65.2% vs. 54.1% for DSPy and 53.4% for TextGrad. Regarding the WHO symptoms, DIAGNO derives from DDXPlus, whose synthetic patients are generated from a medical knowledge base compiled from the literature: the WHO symptoms are the human-defined concepts behind the data, which ACT recovers from labeled examples without being told the task. The differences are more telling (Table 4, Appendix D.1). ACT does not use loss of appetite, a TB symptom listed in the medical sources, because it also occurs in the allergic-sinusitis cases of DIAGNO and therefore does not separate the two classes in this data. Conversely, it uses shortness of breath, which is not among the symptoms we collected from these sources but was selected because it splits the training data well. Generic medical knowledge would favour the canonical TB symptoms; ACT's questions instead follow what discriminates the classes in the training data. We revised the discussion of Table 4 accordingly.

We rephrased the sentence in Section 3. It is meant to say that no task information is provided to the LLM, not that prior knowledge plays no role.

Changes in the paper: the sentence of Section 3.2 is rephrased. Section 4.1 and Appendix D.1 revise the discussion of Table 4 accordingly, and Appendix B.3 explains how DDXPlus is generated.

Future direction (Jev-like model)

We thank the reviewer for this suggestion. Since each ACT node is a yes/no question, a decision model such as TypeSafe's Jev could answer node questions at a lower inference cost, with calibrated probabilities that flag uncertain answers. This is a promising direction, with two challenges: question generation would still require a generative LLM, and using probabilities for soft routing would turn a single decision path into a weighted mixture of paths, which is harder to read and contest.

Thank you for the extensive answers! However, I choose to maintain my score. I believe the revisions needed to push this paper are substantial and would change its nature. Hence, I am not comfortable recommending acceptance.

We thank the reviewer for their feedback. In the rebuttal, we added an ablation of the semantic analysis, a significance and stability analysis (5 seeds × 4 LLMs, repeated inference runs) and per-dataset results. These show that ACT outperforms TF-IDF+CART on 4 of 5 datasets and on a new SNLI experiment. We also revised our wording on prior knowledge and data leakage.

These revisions are clarifications and additional analyses that leave the method unchanged. We would therefore be grateful if the reviewer could say which remaining concerns justify the current score and which revisions they believe would change the nature of the paper. We would be happy to provide further clarifications in the remaining time.

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

The Agentic Classification Tree (ACT) is an algorithm that combines decision trees with LLMs. The main motivation of this paper is to bring together the semantic capabilities of LLMs, with the interpretability that decision trees provide. ACT consists of nodes with binary questions answered by an LLM (yes/no), following the tree until a leaf node is reached. The tree is built recursively, inspired by CART (Classification and Regression Tree), where each node starts from a generic question that is optimized via TextGrad to maximize class separation. The authors claim this method gives a more transparent and auditable decision process. They also report that decomposing the classification into subquestions improves accuracy without changing the LLM. They validate the approach with five binary text datasets with four LLMs, reporting metrics such as accuracy and F1 score against prompting-based and interpretable baselines and perform ablations of tree depth and refinement steps.

Critical strengths

S1. Simple and clear formulation. ACT extends the CART framework to unstructured text via changing the feature threshold with yes/no questions answered by a LLM, giving a easily auditable decision tree.

S2. Broad evaluation. The experiments cover five datasets, four small LLMs, and both prompting-based and interpretable baselines. ACT reports accuracy comparable to or better than prompt-optimization methods, and the authors openly report where simpler baselines wins. This suggests that more interpretability does not translate into an accuracy reduction.

Critical weaknesses

W1. Missing related work and unclear novelty. The paper does not include a discussion or comparison against prior work that follows the same conceptual framework, trees based on questions answered by an LLM such as Tree Prompting [1] and LLM-Symbolic Programs [2].

W2. Limited experimental rigor. The reported gains come from single runs on 600 test examples, without variance across seeds. A few points of difference may be noise. The headline gains also often rely on the most expensive ACT configuration (d=4, k=20), which explores far more candidates than the baselines, so it is unclear whether the improvement reflects the method or simply more search.

References: [1] Chandan Singh, John Morris, Alexander Rush, Jianfeng Gao, and Yuntian Deng. 2023. Tree Prompting: Efficient Task Adaptation without Fine-Tuning. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 6253–6267, Singapore. Association for Computational Linguistics. https://aclanthology.org/2023.emnlp-main.384/ [2] Ruochen Wang, Si Si, Felix Yu, Dorothea Rothuizen, Cho-Jui Hsieh, and Inderjit Dhillon. 2025. Large Language Models are Interpretable Learners. In International Conference on Learning Representations (ICLR ’25), 54829–54852. https://proceedings.iclr.cc/paper_files/paper/2025/file/887932131fddf943e8fe3310b62c0147-Paper-Conference.pdf

Questions for authors

Q1. Tree Prompting [1] already learns node-level yes/no prompts and, in its dynamic-prompt variant, selects splits by Gini impurity. What then is the essential difference between ACT and that line of work, and what does ACT contribute beyond it?

Q2. How much does the iterative TextGrad refinement actually matter? Consider the ablation in which each node's question is obtained by sampling N candidates from the LLM in a single round and keeping the one with the lowest impurity, with no iterative refinement. How much of ACT's gain survives under that best-of-N procedure?

Q3. Are the gains over DSPy and TextGrad stable across seeds? With only 600 test examples, a difference of a few points may fall within noise. Reporting mean and variance over several seeds, or a significance test or confidence intervals, would establish whether the improvement is real.

Q4.There is a reported average gain of 5 points over TextGrad and DSPy. If TextGrad and DSPy were given the same budget as ACT (d = 4, k = 20, i.e. the same number of LLM calls or tokens), would the gap remain?

Q5. Which model acts as the TextGrad optimizer, and is it the same model used as the backbone? Is the tree built with one model and then queried at inference time with a different one, and if so, how much does accuracy degrade when the backbone is swapped at test time? If the optimizer and the backbone differ, how sensitive are the results to that choice?

3 comments
AuthorsOpenReview ↗

Answer (2/2) to reviewer m4L6

W2/Q4: Equal budget for TextGrad and DSPy

Figure 3 in Section 4, Appendices A and G.2 report costs. On DIAGNO with GPT-4.1-Nano, DSPy uses more training tokens (152.6×10⁵) than even the most expensive ACT configuration with d=4 and k=20 (143.8×10⁵, Table 13). With Gemma-3-4B (Fig. 4), ACT (d=3, k=10) uses about half of DSPy's training tokens for the same training time, whereas ACT (d=4, k=20) uses 1.3× DSPy's tokens and 3.5× its training time; at inference, ACT uses 2–3× fewer tokens than DSPy. Averaged over the 20 dataset–LLM pairs of Table 2, ACT (d=3, k=10) is on par with DSPy (+0.8 pts) and TextGrad (+1.2 pts), while the largest configuration run on each dataset gains +4.7 and +5.1 pts. All ACT configurations were fixed a priori, without tuning on test data; for TF-IDF + CART and TF-IDF + XGBoost, by contrast, we report the best configuration on the test set, which favours these baselines.

On DIAGNO, the cheapest configuration, ACT (d=3, k=10), already outperforms both baselines with GPT-4.1-mini and GPT-4.1 at a comparable cost (Table 15):

ModelACT (d=3, k=10)TextGradDSPy
GPT-4.1-mini77.3% at $3.0965.8% at $2.3064.5% at $7.92
GPT-4.180.2% at $19.0864.8% at $17.7668.2% at $37.10

Moreover, TextGrad and DSPy accuracy does not increase consistently with cost, whereas ACT's does (Fig. 3). On SPAM, the cheapest ACT (d=2, k=5) already exceeds both baselines on average (Table 2). We did not run budget-matched variants of TextGrad or DSPy.

Changes in the paper: The expanded Appendix A (text and caption of Fig. 4) corrects the training-cost comparison with DSPy, reports the two cost regimes with their token ratios and defines the axis labels.

Q2: Iterative refinement vs. best-of-N sampling

Fig. 2 (right) shows that test accuracy increases with the number of refinement steps k, compared with the unrefined seed question at k=0. The ablation on m (Tables 12–13) also keeps the number of candidates and impurity evaluations fixed and only changes the information given to the feedback step: for ACT (d=4, k=20), test accuracy goes from 65.8% (m=5) to 70.3% (m=50). This suggests that the content of the feedback matters, which a single-round best-of-N would not exploit; the effect is not monotonic for ACT (d=3, k=10), however. This remains indirect evidence: we did not run the best-of-N ablation within the discussion period.

Changes in the paper: the "Ablation studies" paragraph of Section 4.1 now discusses the m-ablation in this light.

Q5: Optimizer vs. backbone LLM

Within one ACT, every step is performed by the same LLM: question answering (f_split), semantic feedback (f_purity), loss evaluation (f_loss) and the TextGrad optimizer. Only the prompts and system prompts differ, depending on the sub-task. In the paper, the same LLM is used for training and inference, with a sampling temperature of 1. We now state this in Section 4, and Appendix B.4 gives the exact prompts of f_loss and of TextGrad's feedback step.

New result: we ran each test input 10 times through the same tree, queried with the same or a different backbone (DIAGNO, depth 3). Path agreement is the rate of inputs that follow the same path in all 10 runs, i.e., get the same yes/no answer to every question on their path; label agreement is the rate of inputs that get the same final label, possibly through different paths:

Trained withInference modelLabel agr.Path agr.
NanoNano / Mini / GPT-4.198.3 / 99.6 / 98.3%88.8 / 94.4 / 94.4%
MiniNano / Mini / GPT-4.193.8 / 96.2 / 96.3%87.2 / 92.7 / 92.9%

Swapping the backbone keeps label agreement high. Using a stronger inference model improves path consistency without retraining the tree. These figures measure consistency, not accuracy after the swap (Appendix J).

Changes in the paper: the "Models" paragraph of Section 4 now states that one LLM performs all steps of ACT. Appendix J (Table 19) reports the consistency analysis across inference models, summarized in the "Reliability of node answers" paragraph of Section 4.1.

[1] Singh et al. Tree Prompting: Efficient Task Adaptation without Fine-Tuning. EMNLP 2023. [2] Wang et al. Large Language Models are Interpretable Learners. ICLR 2025.

AuthorsOpenReview ↗

Answer (1/2) to reviewer m4L6

We thank the reviewer for their time and helpful comments, which we address below.

W1/Q1: Related work and novelty w.r.t. Tree Prompting and LLM-Symbolic Programs

Our core contributions are:

  • (i) jointly optimizing statistical impurity (Gini) and semantic contrastive feedback from an LLM within a hierarchical, self-improving decision process;
  • (ii) starting from a task-agnostic seed question, which requires minimal human intervention;
  • (iii) producing transparent and contestable decision paths.

Differences with prior work:

  • Tree Prompting [1] first builds a pool of prompts: random few-shot demonstration sets by default, or iPrompt-generated prompts per node in its dynamic variant. Each prompt yields a binary feature through a verbalizer, and CART selects among these features. Prompts are selected, not refined from their errors, and the authors note that few-shot prompts are hard to interpret. ACT instead refines a single natural-language yes/no question per node over kk steps, each step conditioned on the current impurity and on contrastive feedback on misrouted examples.
  • LSP [2] grows a tree whose nodes are LLM classifiers: each node predicts a class and routes the input on that prediction, with instructions summarized from the node's data and ranked by performance. In ACT, each node is a predicate on the input (e.g., "does the patient cough up blood?") and leaves carry the majority label, as in CART. This matters for contestability: an ACT node answer can be checked against the input without knowing the label.

In short, ACT differs on three points:

  • what a node is: a predicate on the input, rather than a few-shot prompt (Tree Prompting) or a class prediction (LSP);
  • how it is obtained: refined from its own routing errors, rather than selected from a pre-built pool (Tree Prompting) or summarized from data and ranked by accuracy (LSP);
  • how it is selected: by weighted Gini impurity.

Two of our baselines are close to these designs. Con. tag. follows the Tree Prompting recipe (LLM-derived binary features, then CART), with concepts in place of few-shot prompts: ACT outperforms it on all five datasets (e.g., +8.1 points on DIAGNO and +9.4 on BANKCHURN, averaged over LLMs). A single LSP node is close to an optimized classification prompt, the setting of TextGrad, which the largest configuration of ACT reported for each dataset outperforms by 5.1 points on average. The revised Section 2 adds this positioning. We could not run these methods as baselines within the discussion period.

Changes in the paper: new paragraph "LLM-based trees and programs" in Section 2.

W2/Q3: Single runs and variance across seeds

We ran a significance analysis following Dror et al. (2018) comparing the largest configuration of ACT reported in Table 2, with CoT and TextGrad. We used a Wilcoxon signed-rank test over 60 paired observations: 3 datasets (DIAGNO, SPAM, JAILBREAK) × 4 LLMs × 5 seeds. We applied a Bonferroni correction (α = 0.025) and report the rank-biserial correlation r as the effect size.

BaselineMean ACT (%)Mean Baseline (%)Δ (pts)p-valuer
CoT88.1378.52+9.61<0.00011.000
TextGrad88.1384.39+3.74<0.00010.828

ACT significantly outperforms both baselines with large effect sizes. Per-LLM tests are significant for all four models, with one exception: ACT vs. TextGrad on Gemma-3-4B (p = 0.091, n = 15), where ACT still has the higher mean. This analysis is now Appendix H.

We also evaluated on larger test sets:

  • binary SNLI: 6,587 test samples (see W2 response to Reviewer z2pj);
  • full DIAGNO/SPAM/BANKCHURN: 997 / 2,725 / 1,969 test samples (Appendix E.3).

Changes in the paper: Appendix H (Table 17) reports the significance analysis, referenced from the "Test set accuracy" paragraph of Section 4.1. Appendix I (Table 18) reports binary SNLI.

Reviewer_m4L6OpenReview ↗

Response to Rebuttal

I thank the authors for the detailed rebuttal and the additional experiments. The new related-work section, the clarification on the optimizer and backbone (Q5), the consistency analysis in Appendix J, and the updated cost discussion improve the paper. However, my main concerns remain, and some points are still not clear to me from the paper.

1. Contribution (W1/Q1, Q2). I may be missing some implementation details, but from the paper (Appendix B.4) the optimization step appears to be TextGrad used largely as is, with Gini added to the loss prompt and used to select the question kept at each node. If TextGrad was adapted in other ways, this is not described. It would help to state it explicitly, since that is where the claimed contribution lies. GPTree and the dynamic variant of Tree Prompting, which also searches iteratively over prompts, seem to do something similar. The key question is therefore whether the iterative refinement helps over simply generating several candidate questions at once and keeping the one with the lowest Gini (the best-of-N comparison I asked for in Q2). This comparison was not run, and Fig. 2 does not fully answer it, since more refinement steps also mean more candidates. The paper also still describes ACT as "a new type of classifier", which seems stronger than what the results show.

2. Budget (W2/Q4). The rebuttal confirms that the baselines were not run with a matched budget. If I read the numbers correctly, the cheaper ACT configuration is only about 1 point better than TextGrad and DSPy on average. The roughly 5-point gain comes from the largest configuration, which appears to use about 3× TextGrad's training tokens. It is also not fully clear to me whether the reported token counts cover training only or also inference, and why the largest configuration reported differs across datasets. The DIAGNO results with the larger GPT-4.1 models are encouraging, but the main claim should be stated more carefully.

3. Seeds (W2/Q3). Thank you for running multiple seeds. However, DSPy is not included, two datasets are left out, and no standard deviations are reported. It is also not stated what the seed controls (e.g., data sampling, LLM sampling, or both). It is therefore still hard to judge the variability of the main results in Table 2.

Overall, the rebuttal improves the clarity of the paper, but the contribution beyond existing LLM-based question trees is not yet clearly demonstrated, and it remains unclear how much of the gain comes from the method rather than from the larger search budget. I therefore keep my score for now. I would be happy to reconsider if a best-of-N comparison, a clearer description of how TextGrad is used, and a more careful statement of the gains were provided.

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

The paper proposes an approach to learning decision trees with LLMs deciding splits based on natural language. The authors posit that this will make the tree more interpretable and demonstrate improvements (or the same performance) over baselines based around prompting.

Critical strengths
  • The paper is attempting an interesting solution to an important problem, I like the general idea and think it quite creative.
  • The method could potentially be quite useful for things like auditing.
Critical weaknesses
  • I do not like that the paper never demonstrates a concrete usecase for the supposed increased interpretability. The paper would be drastically improved if the authors could demonstrate the improved interpretability helps human reliance or model improvement, but we are just left wondering what was point.
  • Several basic baselines like BERT or XGBoost are doing better than the tree model, and they can supply explanations also, so again it seems that this method is just trading accuracy for natural language explanations (which again are not shown to be useful)
  • Lastly, there are many potential baselines missing (see below)

Missing baselines?

Xiong, S., Ihlamur, Y., Alican, F. and Yin, A.O., 2024. GPTree: Towards explainable decision-making via LLM-powered decision trees. arXiv preprint arXiv:2411.08257.

Wang, R., Si, S., Yu, F., Rothuizen, D., Hsieh, C.J. and Dhillon, I., 2025, May. Large language models are interpretable learners. In International Conference on Learning Representations (Vol. 2025, pp. 54829-54852).

Singh, C., Morris, J., Rush, A.M., Gao, J. and Deng, Y., 2023, December. Tree prompting: Efficient task adaptation without fine-tuning. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing (pp. 6253-6267).

Urrutia, F., Calderon, C. and Barriere, V., 2023, December. Deep natural language feature learning for interpretable prediction. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing (pp. 3736-3763).

Questions for authors

Please see weakness above.

1 comment
AuthorsOpenReview ↗

Answer to reviewer UvCz

We thank the reviewer for their time and helpful comments, which we address below.

W1: Concrete use case for interpretability

Our target use case is contestability in high-stakes settings (Section 2): a patient or regulator can dispute a criterion such as "Does this example involve coughing up blood or weight loss?" by checking whether it is clinically appropriate and correctly applied. This is not possible for TF-IDF splits such as our≤0.041\text{our} \le 0.041, a threshold on the TF-IDF weight of the word our that the SPAM tree of Fig. 8 uses as its root split: the condition has no meaning in the task domain that a stakeholder could check or dispute. Table 4 further shows that ACT's learned questions are consistent with TB symptoms from WHO and NHS sources. Since DIAGNO derives from DDXPlus, whose synthetic patients are generated from a medical knowledge base, these symptoms are the human-defined concepts hidden behind the data: ACT recovers them from labeled examples, without being told the task.

Interpretability also supports auditing and model improvement. We computed a node-level flip rate: the fraction of test samples whose yes/no answer changes across repeated inference runs (DIAGNO, GPT-4.1-Nano, sampling temperature 1 as in all our experiments). It identifies the ambiguous questions. Multi-condition questions reach up to 8.3% (e.g., "…severe, multi-organ illness involving symptoms like high fever, weight loss, or blood in cough?"), whereas crisp questions stay at 1.2–1.4% (e.g., "…blood in cough or loss of consciousness?"). This per-question flip rate is only available because ACT splits each prediction into separate yes/no answers. With a single optimized prompt (e.g., TextGrad), we could only observe that the final prediction changes across runs, without knowing which criterion causes the instability. In ACT, the unstable questions can be tightened, e.g., via the logical-operator constraint LL, before deployment, and a tree built with a small model can be queried with a stronger one to improve consistency without retraining (Appendix J).

Changes in the paper: Section 2 now defines semantically grounded decision steps and links them to contestability. Section 4.1 revises the discussion of Table 4 accordingly and adds a paragraph on the reliability of node answers. Appendix J (Tables 19–20) reports the consistency and flip-rate analysis.

W2: BERT / XGBoost perform better and can also provide explanations

  • ACT with GPT-4.1-mini matches or surpasses TF-IDF+XGBoost on all datasets (82.3 vs. 83.0 on DIAGNO, higher elsewhere). It also matches BERT/RoBERTa on SPAM and JAILBREAK and surpasses them on IMDB (96.3 vs. 90.2/92.7), but remains below them on DIAGNO and BANKCHURN (Tables 6–7). We now state these gaps explicitly in Section 4.1.
  • ACT scales with the underlying LLM (Fig. 3, Table 14). New result: on BANKCHURN, ACT (d=4, k=10) with GPT-4.1 reaches 74.8%. This surpasses BERT (71.7%), RoBERTa (72.3%) and TF-IDF+XGBoost (56.7%). It also surpasses CART trained directly on the native tabular features (72.7%), and stays competitive with XGBoost on those features (77.0%), while providing an interpretable decision path.
  • Explanations for BERT/XGBoost are post-hoc (e.g., SHAP, LIME), and such explanations may not reflect the model's actual reasoning (Rudin, 2019; Laugel et al., 2019). In ACT, the explanation is the decision process.

Changes in the paper: the paragraph of Section 4.1 on strong non-interpretable baselines now states the gaps with XGBoost, BERT and RoBERTa explicitly. Appendix G.2 (Table 16) adds the BANKCHURN results with GPT-4.1 and with native tabular baselines, and Appendix I (Table 18) adds binary SNLI.

W3: Missing baselines (GPTree, LLM-Symbolic Programs, Tree Prompting, Urrutia et al.)

We now discuss all four works in Section 2.

  • GPTree proposes candidate questions from a task description and LLM summaries of the training samples and keeps the lowest-Gini one in a single round; ACT refines each question iteratively from a task-agnostic seed, using feedback on misrouted examples.
  • Urrutia et al. generate binary questions with an LLM, answer them with a BERT model trained on LLM labels, and fit a decision tree on the answers. Our concept-bottleneck baseline (Con. tag.) follows the same two-stage recipe, with the LLM answering the questions directly; ACT outperforms it on all five datasets (averaged over the four LLMs: 72.8 vs. 64.7 on DIAGNO, 99.0 vs. 73.0 on SPAM, 93.4 vs. 75.1 on JAILBREAK, 65.2 vs. 55.8 on BANKCHURN, 95.1 vs. 58.1 on IMDB).
  • Tree Prompting and LSP are discussed in our answer to Reviewer m4L6 (W1/Q1).

We could not run GPTree, Tree Prompting or LSP as baselines within the discussion period.

Changes in the paper: new paragraph "LLM-based trees and programs" in Section 2, with the corresponding references. Appendix E.1 details the Con. tag. baseline.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General response

We thank the reviewers for their careful reading. We uploaded a revised PDF in which all modifications are shown in red, so that the changes can be easily located. We summarize the main points here.

  1. Positioning. Section 2 now discusses Tree Prompting, LLM-based Symbolic Programs (LSP), GPTree, concept-bottleneck approaches (including Urrutia et al.) and LeaPR, and states how ACT differs from each (see our answers to Reviewers m4L6 and UvCz).
  2. Statistical evidence. We add a 5-seed significance analysis (Wilcoxon signed-rank test, Appendix H) and results on binary SNLI with 6,587 test samples (Appendix I).
  3. Cost. Expanded Appendix A to report in more detail the cost of each ACT configuration relative to DSPy and TextGrad, including where ACT is more expensive.
  4. Reliability of node answers. We add a consistency analysis: repeated inference, inference with a different LLM than the one that built the tree and per-question flip rates (Appendix J).
  5. Corrections. We rephrase the sentence of Section 3 on prior knowledge, correct Algorithm 1 to match our code (the seed question is never kept; subtrees whose leaves share the same label are collapsed) and state the gaps with TF-IDF + CART and fine-tuned encoders precisely.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.