Pith. sign in

REVIEW 4 major objections 4 minor 3 cited by

CausalMACE: Causality Empowered Multi-Agents in Minecraft Cooperative Tasks

T0 review · 4 major / 4 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read CausalMACE claims that counterfactually reversing Minecraft rules and pruning edges whose dependency judgments do not change produces task graphs aligned with actual game rules, improving multi-agent and single-agent completion.

desk verdict Solid Minecraft multi-agent engineering, but the central causal refinement test is invalid—it can delete true edges when rules are redundant. read the letter →

arxiv 2508.18797 v1 pith:EFOY5LBO submitted 2025-08-26 cs.AI

Qi Chai , Zhang Zheng , Junlong Ren , Deheng Ye , Zichuan Lin , Hao Wang This is my paper
classification cs.AI
keywords causalitymulti-agentplanningLLMagentsMinecrafttaskdependencygraphcausalinterventioncounterfactualrulescooperativetasks
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to fix a practical failure in LLM multi-agent systems: when agents are handed subtasks whose prerequisites are unmet, the task fails. It proposes a planner that first decomposes a Minecraft task into subtasks, builds a global dependency graph using the game's rules, and then refines that graph by causal intervention. For each game rule, the LLM is asked how a dependency edge would behave if the rule were replaced by its opposite; if the overall rule set has no average treatment effect on the edge, the edge is removed. The paper claims this yields dependency graphs that match the environment's actual rules, and reports 12 percent higher average completion in multi-agent cooperative tasks and 7 percent higher in single-agent tasks over prior methods. A general reader should care because the same move—using counterfactual rule changes to prune model-generated plans—could be a cheap way to ground LLM planning in any rule-governed environment.

What carries the argument

The causal-intervention graph-refinement module. It constructs an initial dependency graph from LLM decomposition plus a rule set, then for each candidate edge computes the average treatment effect by comparing the LLM's dependency output under the real rules and under a counterfactual rule set where one rule is negated; edges with zero ATE are pruned. The structural causal model in the paper casts the LLM's internal knowledge as a confounder, the inference steps as a mediator, and the game rules as an instrumental variable that can reach the output through the path R -> M -> Y.

What would settle it

Take a hand-built task with a known dependency, such as 'obtain block' must precede 'place block.' Replace the rule 'you must have a block before placing it' with its counterfactual and ask the LLM whether the dependency still holds. If the LLM still reports the dependency, or if the framework's ATE=0 rule removes a known-necessary edge and agents then fail the task in Minecraft, then the causal pruning is not tracking true game dependencies.

Watch

Extended reading notes

Core claim

On the paper's own terms, the discovery is that dependency edges in an LLM-built task graph can be validated by treating Minecraft's rule set as an instrumental variable: for each game rule, replace the rule by a counterfactual opposite, ask the LLM whether the edge's dependency judgment changes, and measure the average treatment effect across rules. Edges that survive this intervention are considered causally grounded in the game rules; edges with zero effect are treated as artifacts of the LLM's internal knowledge and are removed. Across construction, cooking, escape-room, and item-gathering tasks, this graph refinement, combined with global planning and workload-aware assignment, is repor

Load-bearing premise

The framework assumes the LLM's answer to 'would this dependency still hold if a rule were reversed?' measures whether the dependency truly follows from Minecraft's rules, even though the same model proposed and judges the dependency.

Editorial extensions

If this is right

  • Agents should stop attempting subtasks whose prerequisites are missing, because spurious dependency edges have been removed by the causal refinement.
  • A global dependency graph lets the worker enumerate and assign all feasible execution paths with DFS, so the team can scale from two to six agents without losing completion rate on most tasks.
  • Workload can be balanced at assignment time by a busy rate that counts assigned agents weighted by distance to the path entrance, reducing idle repetition and improving efficiency.
  • The same graph-and-causality pipeline works with a single agent, since causal scheduling resolves long chains of item-gathering subtasks.
  • The ablation pattern indicates causal intervention is the component that most directly protects completion rate, while busy rate mainly protects efficiency.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Beyond Minecraft, the counterfactual-rule pruning scheme is a candidate generic validator for any LLM-generated plan with an explicit rule set; a natural next test is tool-use or instruction-following domains where dependencies are similarly spurious.
  • The ATE criterion as stated keeps an edge whenever any game rule changes the dependency answer, so a single weak rule can rescue an otherwise spurious edge; a sharper version would threshold per-rule effects or require agreement across several counterfactuals.
  • The busy rate approximates load by subtask counts and distances, not by expected durations; the paper's own balanced-score tradeoff suggests that estimating durations from historical execution logs and rebalancing mid-path is a testable improvement.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 4 minor

Summary. The paper proposes CausalMACE, a multi-agent framework for Minecraft cooperative tasks. It comprises three components: a Judger that defines tasks and validates actions, a Planner that decomposes a task into subtasks and builds a dependency graph using Minecraft game rules, and a Worker that assigns subtasks to agents via depth-first search with a busy-rate-based balancing scheme. The central novelty is a 'causal intervention' module (§3.4): for each subtask dependency edge, the Planner asks an LLM whether the dependency persists after counterfactually negating each game rule one at a time, computes an average treatment effect (ATE) as in Eq. (1)–(2), and removes the edge when ATE = 0. Experiments on VillagerBench cooperative tasks and single-agent item-gathering tasks report state-of-the-art completion rates and efficiency, with ablation results in Table 4 suggesting that the causal graph component contributes to performance.

Significance. If the causal refinement module were valid, the paper would make a useful contribution by connecting LLM-based planning to causal intervention in an embodied multi-agent setting. The framework is clearly described, and the busy-rate scheduling idea is a reasonable engineering contribution. The paper also provides a substantial set of Minecraft experiments, including comparisons with RL-based and LLM-based baselines, and its single-agent item-gathering results are competitive. However, the central causal claim is not supported as stated: Eq. (1)–(2) define an ATE over LLM outputs without specifying how those outputs are scored or what threshold is used, and the 'keep iff ATE ≠ 0' criterion is logically invalid for dependencies entailed by redundant rules. The ablation in Table 4 may be explained by a consistency-filtering effect rather than by genuine causal identification. The paper's strengths are its clear system design and broad empirical evaluation, but the causal interpretation requires substantial rework.

major comments (4)
  1. [§3.4, Eq. (1)–(2)] The ATE in Eq. (1) is not operationalized. Y is described only as 'the dependencies given by LLMs'; there is no specification of how Y is numerically scored, how many counterfactual queries are run per rule, how the expectation over LLM outputs is computed, or what threshold is used to declare ATE = 0. Without this, the refinement rule 'if ATE = 0, remove the edge' is unfalsifiable from the manuscript. This must be specified before the causal claim can be evaluated.
  2. [§3.4, Eq. (2) and edge-removal rule] The criterion 'keep edge iff ATE(R, X_i) ≠ 0' is invalid when a dependency is entailed by multiple individually redundant game rules. For example, the edge 'collect wood → craft planks' may be supported both by 'crafting requires ingredients' and by 'planks are crafted from wood'. Negating either rule individually leaves the other rule sufficient to entail the dependency, so Y does not change, ATE(ri, X) = 0 for each ri, the average is zero, and the edge is incorrectly removed. This is not an implementation detail; it breaks the central claim that the module identifies causally grounded dependencies. The authors should either test joint sufficiency (e.g., negate all rules that could support the edge) or formally establish that the rule set is non-redundant with respect to each edge.
  3. [§3.4, Figure 3] The causal refinement is circular: the same LLM that proposes the initial graph G_init and the rule set R is also used to evaluate whether Y changes under a counterfactual rule set. Edge validity is therefore defined by the model's own willingness to change its answer under a prompt perturbation, not by any independent causal effect measured in the Minecraft environment. This concern is partially acknowledged in the Limitations section (dependence on LLM reasoning capacity), but it is not addressed. I recommend validating retained/removed edges against a formal rule engine or human annotations; otherwise the 'causal' component is better described as consistency filtering.
  4. [§4.2, Tables 1 and 3] The empirical comparison reports no error bars, number of seeds, or statistical significance tests. Since the agents are driven by GPT-4o and are stochastic, a single run per setting is insufficient to support the claim of a 12% average improvement or 'state-of-the-art' results. Please provide multiple runs with variance, or at least state the number of trials and the range of outcomes. This is particularly important because the main quantitative claim rests on small differences in some rows (e.g., Table 1, Escape CR for 3 agents).
minor comments (4)
  1. [§3.1/§3.4] The do-operator notation in Eq. (1) is used with a rule set R as the intervened variable, but the do-calculus is defined for variables. The paper should clarify what 'do(R)' and 'do(R*_i)' mean in terms of the actual prompt manipulation.
  2. [Table 4] The ablation table's column headings and row descriptions are ambiguous: the text says Row 4 removes Causal Intervention and Row 2 removes Graph, but the checkmarks in the printed table do not make this self-evident. Please label the columns clearly (e.g., 'Graph', 'Busy Rate', 'Causal Graph') and ensure the row references match the table.
  3. [Throughout] There are several typos and formatting inconsistencies: 'V oyager' in Tables and text, 'VillagerAgents' vs 'VillagerAgent' in Related Work, 'Ginit' formatting in §3.4, and inconsistent capitalization of 'CausalMACE'. These should be fixed.
  4. [Appendix B] The prompts in Appendix B are helpful and should be retained; however, the prompt for dependency prediction (Table 7) already contains a hard-coded set of Minecraft rules. The relation between these rules and the formal rule set R used in Eq. (1) should be stated explicitly.

Circularity Check

1 steps flagged · score 6.0 of 10

Causal refinement is a self-consistency filter: edge validity is defined as ATE≠0, and ATE is the same LLM's output change under a counterfactual prompt.

  1. self definitional [Section 3.4 (Planner with Casual Intervention), Eq. (1)-(2) and the graph-refinement criterion]
    "Specifically, we define two subtasks, sp and sq, as input X, and their dependencies given by LLMs as output Y . ... AT E(ri, X) = E(Y |X, M, do(R))− E(Y |X, M, do(R∗ i )) ... For each edge in Ginit, if it is correctly generated by the game rule set R with given input node pair Xi, then AT E(R, Xi) ̸= 0. ... When AT E(R, Xi) = 0 , it implies that the edge is independent of the entire set of game rules."

    The refinement criterion equates 'correctly generated by the game rule set' with ATE≠0, but ATE is defined as the difference in the LLM's own stated dependencies Y when one rule in the prompt is negated. No environment measurement or independent rule engine is used. Thus an edge's 'grounding in game rules' is by construction the same LLM's prompt sensitivity: if the LLM changes its answer under the counterfactual rule, the edge is kept; if it keeps the answer (e.g., because redundant rules still entail the dependency), the edge is removed. The causal validation therefore reduces to a self-consistency filter on the model that generated Ginit, not to an estimate of whether the dependency actually holds in Minecraft.

full rationale

The paper's final benchmark results are externally measured in Minecraft, so the broad empirical claim is not circular. However, the paper's central causal contribution—the graph-refinement module—is circular in a narrower sense: the only evidence that an edge 'adheres to the game rules' is the LLM's own change in output when one rule is replaced by its negation (Eq. 1). Because Y is defined as 'dependencies given by LLMs,' ATE≠0 and ATE=0 are not independent tests of causal grounding; they are the same model's answer under two prompts. This means the refined graph is a consistency-filtered version of Ginit, and the causal interpretation of the ablation gains (Table 4) is not supported as a distinct causal identification. A separate logical flaw—dependencies entailed by redundant rules can yield ATE=0 and be wrongly deleted—reinforces that the operationalization does not measure what it claims, though that flaw is a correctness issue rather than another circular step. No load-bearing self-citations were found; the limitations paragraph admits the intervention 'highly depends on the reasoning capacity of LLMs,' which is consistent with the self-referential nature identified here.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

No numeric free parameters are explicitly fitted to data, though the implicit scoring rule for LLM outputs and the ATE=0 threshold act as an unstated decision parameter. The load-bearing axioms are the SCM assumptions in Figure 3, the validity of counterfactual LLM queries as causal estimates, and the completeness of the game rule set for dependency structure. No new physical or ontological entities are introduced.

assumptions (4)
  • domain assumption The structural causal model in Figure 3(b) is correct: LLM internal knowledge C is a confounder of X, M, and Y, while game rules R cause both input X and mediator M.
    Section 3.4 and Figure 3 introduce this SCM as a framing device. No measurement or test is provided to justify the claimed causal edges, especially R causing X.
  • ad hoc to paper A counterfactual prompt response is a valid estimate of the causal effect of a game rule on a dependency edge.
    Equation (1) defines ATE as E(Y|X,M,do(R)) - E(Y|X,M,do(R*_i)) using LLM outputs. The paper assumes the LLM's changed answer under R*_i reflects true task causality rather than prompt sensitivity or hallucination.
  • domain assumption The explicit game rule set R is complete for all valid subtask dependencies, so any edge with ATE=0 is invalid and should be removed.
    The refinement step in Section 3.4 removes edges whose existence does not change under counterfactual rules. This assumes the listed Minecraft rules capture every relevant dependency, including implicit ones such as agent position and resource availability.
  • domain assumption Mineflayer and the VillagerBench setup provide reliable and faithful execution and evaluation for the agent actions.
    Section 4.1.1 and Appendix A rely on Mineflayer as the action interface and prior benchmark settings for metrics. The paper does not audit this tooling, treating it as standard infrastructure.

how reviews work

0 comments
Cite this review

Pith. "Pith review of CausalMACE: Causality Empowered Multi-Agents in Minecraft Cooperative Tasks." pith.science (2026). https://pith.science/paper/EFOY5LBO

@misc{pith2026250818797,
  author       = {Pith},
  title        = {Pith review of: CausalMACE: Causality Empowered Multi-Agents in Minecraft Cooperative Tasks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/EFOY5LBO}},
  note         = {Machine review of arXiv:2508.18797}
}
read the original abstract

Minecraft, as an open-world virtual interactive environment, has become a prominent platform for research on agent decision-making and execution. Existing works primarily adopt a single Large Language Model (LLM) agent to complete various in-game tasks. However, for complex tasks requiring lengthy sequences of actions, single-agent approaches often face challenges related to inefficiency and limited fault tolerance. Despite these issues, research on multi-agent collaboration remains scarce. In this paper, we propose CausalMACE, a holistic causality planning framework designed to enhance multi-agent systems, in which we incorporate causality to manage dependencies among subtasks. Technically, our proposed framework introduces two modules: an overarching task graph for global task planning and a causality-based module for dependency management, where inherent rules are adopted to perform causal intervention. Experimental results demonstrate our approach achieves state-of-the-art performance in multi-agent cooperative tasks of Minecraft.

Figures

Figures reproduced from arXiv: 2508.18797 by the authors.

Figure 1
Figure 1. The impact of dependencies among tasks. (a) describes tasks with dependency (arrows). (b) shows the consequences of ignoring dependencies: agents failed to execute due to unmet prerequisites. (c) demon￾strates the proper dependency processing: sequentially complete root node tasks before leaf nodes. quences of action or collaboration remain a chal￾lenge, since single-agent approaches often face is￾sues of inefficien… view at source ↗
Figure 2
Figure 2. Overview of the framework. Our framework contains Judger, Planner and Worker. The Judger defines the objective and gives the environment feedback. The Planner decomposes the task into subtasks and constructs a dependency graph via game rules. The Worker assigns subtasks to agents to process. ATE denotes the average treatment effect, which is introduced in Section 3.4. lelization potential inherent in multi-agent sys… view at source ↗
Figure 3
Figure 3. Procedures for generating the dependencies. X and Y denote the input and output, M is the inference steps of LLMs and C represents the internal knowledge of LLMs. (a) and (b) indicate the procedures with and without game rules R, respectively, where the dotted arrow denotes the uncertain causal edges. (c) shows the successful intervention procedure, (d) reveals the failure cases where the effect of R on M is blocked… view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Visualization of construction cooperation. VillagerAgent exhibits incoherent structural features, while CausalMACE maintains structural rationality and high consistency to ground truth with only minor local difference. Row Setting Construction Busy Rate Causal Graph CR…

Discussion (0). Sign in to comment.

Forward citations

Cited by 3 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. MultiWorld: Scalable Multi-Agent Multi-View Video World Models

    cs.CV 2026-04 unverdicted novelty 7.0 of 10

    MultiWorld is a scalable framework for multi-agent multi-view video world models that improves controllability and consistency over single-agent baselines in game and robot tasks.

  2. EvolveNav: Proactive Preflection and Self-Evolving Memory for Zero-Shot Object Goal Navigation

    cs.AI 2026-06 unverdicted novelty 5.0 of 10

    EvolveNav adds an agentic rule memory with UCB retrieval and a memory-guided preflection module to enable continuous improvement in zero-shot object goal navigation, reporting a 10.1% success rate gain over baselines.

  3. Gated Coordination for Efficient Multi-Agent Collaboration in Minecraft Game

    cs.MA 2026-04 unverdicted novelty 5.0 of 10

    Gated escalation and partitioned states enable more efficient multi-agent collaboration in Minecraft by making communication selective rather than automatic.

Reference graph

Works this paper leans on

41 extracted references · 28 canonical work pages · cited by 3 Pith papers

  1. [1]

    Bowen Baker, Ilge Akkaya, Peter Zhokov, Joost Huizinga, Jie Tang, Adrien Ecoffet, Brandon Houghton, Raul Sampedro, and Jeff Clune. 2022. Video pretraining (vpt): Learning to act by watching unlabeled online videos. Advances in Neural Information Processing Systems, 35:24639--24654

    work page 2022

  2. [2]

    Damir \'C avar, Zoran Tiganj, Ludovic Veta Mompelat, and Billy Dickson. 2024. Computing ellipsis constructions: Comparing classical nlp and llm approaches. In Proceedings of the Society for Computation in Linguistics 2024, pages 217--226

    work page 2024

  3. [3]

    Chi-Min Chan, Weize Chen, Yusheng Su, Jianxuan Yu, Wei Xue, Shanghang Zhang, Jie Fu, and Zhiyuan Liu. 2024. Chateval: Towards better llm-based evaluators through multi-agent debate. In The Twelfth International Conference on Learning Representations

    2024

  4. [4]

    Weize Chen, Yusheng Su, Jingwei Zuo, Cheng Yang, Chenfei Yuan, Chi-Min Chan, Heyang Yu, Yaxi Lu, Yi-Hsin Hung, Chen Qian, et al. 2023. Agentverse: Facilitating multi-agent collaboration and exploring emergent behaviors. In The Twelfth International Conference on Learning Representations

    work page 2023

  5. [5]

    David Maxwell Chickering and Christopher Meek. 2015. Selective greedy equivalence search: finding optimal bayesian networks using a polynomial number of score evaluations. In Proceedings of the Thirty-First Conference on Uncertainty in Artificial Intelligence, pages 211--219

    work page 2015

  6. [6]

    Kai-Hendrik Cohrs, Gherardo Varando, Emiliano Diaz, Vasileios Sitokonstantinou, and Gustau Camps-Valls. 2024. Large language models for constrained-based causal discovery. arXiv preprint arXiv:2406.07378

    arXiv 2024

  7. [7]

    Yubo Dong, Xukun Zhu, Zhengzhe Pan, Linchao Zhu, and Yi Yang. 2024. Villageragent: A graph-based multi-agent framework for coordinating complex task dependencies in minecraft. arXiv preprint arXiv:2406.05720

    arXiv 2024

  8. [8]

    Yuxuan Guo, Shaohui Peng, Jiaming Guo, Di Huang, Xishan Zhang, Rui Zhang, Yifan Hao, Ling Li, Zikang Tian, Mingju Gao, et al. 2024. Luban: Building open-ended creative agents via autonomous embodied verification. arXiv preprint arXiv:2405.15414

    arXiv 2024

Show all 41 references
  1. [9]

    Sirui Hong, Mingchen Zhuge, Jonathan Chen, Xiawu Zheng, Yuheng Cheng, Jinlin Wang, Ceyao Zhang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, et al. 2024. Metagpt: Meta programming for a multi-agent collaborative framework. In The Twelfth International Conference on Learning Rep...

    2024

  2. [10]

    Wenlong Huang, Fei Xia, Ted Xiao, Harris Chan, Jacky Liang, Pete Florence, Andy Zeng, Jonathan Tompson, Igor Mordatch, Yevgen Chebotar, et al. 2023. Inner monologue: Embodied reasoning through planning with language models. In Conference on Robot Learning, pages 1769--1782. PMLR

    2023

  3. [11]

    Ziwei Ji, Tiezheng Yu, Yan Xu, Nayeon Lee, Etsuko Ishii, and Pascale Fung. 2023. Towards mitigating llm hallucination via self reflection. In Findings of the Association for Computational Linguistics: EMNLP 2023, pages 1827--1843

    2023

  4. [12]

    Emre K c man, Robert Ness, Amit Sharma, and Chenhao Tan. 2023. Causal reasoning and large language models: Opening a new frontier for causality. arXiv preprint arXiv:2305.00050

    2023 arXiv

  5. [13]

    Guohao Li, Hasan Hammoud, Hani Itani, Dmitrii Khizbullin, and Bernard Ghanem. 2023. Camel: Communicative agents for" mind" exploration of large language model society. Advances in Neural Information Processing Systems, 36:51991--52008

    2023

  6. [14]

    Hao Li, Xue Yang, Zhaokai Wang, Xizhou Zhu, Jie Zhou, Yu Qiao, Xiaogang Wang, Hongsheng Li, Lewei Lu, and Jifeng Dai. 2024 a . Auto mc-reward: Automated dense reward design with large language models for minecraft. In Proceedings of the IEEE/CVF Conference on Computer Vision a...

    2024

  7. [15]

    Zaijing Li, Yuquan Xie, Rui Shao, Gongwei Chen, Dongmei Jiang, and Liqiang Nie. 2024 b . Optimus-1: Hybrid multimodal memory empowered agents excel in long-horizon tasks. In The Thirty-eighth Annual Conference on Neural Information Processing Systems

    2024

  8. [16]

    Zijun Liu, Yanzhe Zhang, Peng Li, Yang Liu, and Diyi Yang. 2024. A dynamic llm-powered agent network for task-oriented agent collaboration. In First Conference on Language Modeling

    2024

  9. [17]

    Stephanie Long, Alexandre Pich \'e , Valentina Zantedeschi, Tibor Schuster, and Alexandre Drouin. 2023. https://openreview.net/forum?id=RXlvYZAE49 Causal discovery with language models as imperfect experts . In ICML 2023 Workshop on Structured Probabilistic Inference & Generat...

    2023

  10. [18]

    Judea Pearl. 2009. Causal inference in statistics: An overview

    2009

  11. [19]

    PrismarineJS. 2013. https://github.com/PrismarineJS/mineflayer/tree/master Prismarinejs/mineflayer: Create minecraft bots with a powerful, stable, and high level javascript api

    2013

  12. [20]

    Joseph D Ramsey. 2015. Scaling up greedy causal search for continuous variables. arXiv preprint arXiv:1507.07749

    2015 arXiv

  13. [21]

    Peter Spirtes, Clark Glymour, and Richard Scheines. 2001. Causation, prediction, and search. MIT press

    2001

  14. [22]

    Peter L Spirtes, Christopher Meek, and Thomas S Richardson. 2013. Causal inference in the presence of latent variables and selection bias. arXiv preprint arXiv:1302.4983

    2013 arXiv

  15. [23]

    Boshi Wang, Xiang Yue, and Huan Sun. 2023. Can chatgpt defend its belief in truth? evaluating llm reasoning via debate. In Findings of the Association for Computational Linguistics: EMNLP 2023, pages 11865--11881

    2023

  16. [24]

    Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. 2024 a . Voyager: An open-ended embodied agent with large language models. Transactions on Machine Learning Research

    2024

  17. [25]

    Zihao Wang, Shaofei Cai, Guanzhou Chen, Anji Liu, Xiaojian Shawn Ma, and Yitao Liang. 2024 b . Describe, explain, plan and select: interactive planning with llms enables open-world multi-task agents. Advances in Neural Information Processing Systems, 36

    2024

  18. [26]

    Zihao Wang, Shaofei Cai, Anji Liu, Yonggang Jin, Jinbing Hou, Bowei Zhang, Haowei Lin, Zhaofeng He, Zilong Zheng, Yaodong Yang, et al. 2024 c . Jarvis-1: Open-world multi-task agents with memory-augmented multimodal language models. IEEE Transactions on Pattern Analysis and Ma...

    2024

  19. [27]

    Junda Wu, Tong Yu, Xiang Chen, Haoliang Wang, Ryan Rossi, Sungchul Kim, Anup Rao, and Julian McAuley. 2024. Decot: Debiasing chain-of-thought for knowledge-intensive tasks in large language models via causal intervention. In Proceedings of the 62nd Annual Meeting of the Associ...

    2024

  20. [28]

    Jing Xiang and Seyoung Kim. 2013. A* lasso for learning a sparse bayesian network structure for continuous variables. Advances in neural information processing systems, 26

    2013

  21. [29]

    Fangzhi Xu, Zhiyong Wu, Qiushi Sun, Siyu Ren, Fei Yuan, Shuai Yuan, Qika Lin, Yu Qiao, and Jun Liu. 2023. Symbol-llm: Towards foundational symbol-centric interface for large language models. arXiv preprint arXiv:2311.09278

    2023 arXiv

  22. [30]

    Lin Xu, Zhiyuan Hu, Daquan Zhou, Hongyu Ren, Zhen Dong, Kurt Keutzer, See Kiong Ng, and Jiashi Feng. 2024. Magic: Investigation of large language model powered multi-agent in cognition, adaptability, rationality and collaboration. In Proceedings of the 2024 Conference on Empir...

    2024

  23. [31]

    Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. 2023. React: Synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations

    2023

  24. [32]

    Haoqi Yuan, Zhancun Mu, Feiyang Xie, and Zongqing Lu. 2024. Pre-training goal-based models for sample-efficient reinforcement learning. In The Twelfth International Conference on Learning Representations

    2024

  25. [33]

    Junkun Yuan, Xu Ma, Ruoxuan Xiong, Mingming Gong, Xiangyu Liu, Fei Wu, Lanfen Lin, and Kun Kuang. 2023 a . Instrumental variable-driven domain generalization with unobserved confounders. ACM Transactions on Knowledge Discovery from Data, 17(8):1--21

    2023

  26. [34]

    Lifan Yuan, Yangyi Chen, Ganqu Cui, Hongcheng Gao, Fangyuan Zou, Xingyi Cheng, Heng Ji, Zhiyuan Liu, and Maosong Sun. 2023 b . Revisiting out-of-distribution robustness in nlp: Benchmarks, analysis, and llms evaluations. Advances in Neural Information Processing Systems, 36:58...

    2023

  27. [35]

    Matej Ze c evi \'c , Moritz Willig, Devendra Singh Dhami, and Kristian Kersting. 2023. Causal parrots: Large language models may talk causality but are not causal. Transactions on Machine Learning Research

    2023

  28. [36]

    Yuzhe Zhang, Yipeng Zhang, Yidong Gan, Lina Yao, and Chen Wang. 2024. Causal graph discovery with retrieval-augmented generation based large language models. arXiv preprint arXiv:2402.15301

    2024 arXiv

  29. [37]

    Bohan Zhou, Ke Li, Jiechuan Jiang, and Zongqing Lu. 2024. Learning from visual observation via offline pretrained state-to-go transformer. Advances in Neural Information Processing Systems, 36

    2024

  30. [38]

    Chang Zong, Yuchen Yan, Weiming Lu, Jian Shao, Eliot Huang, Heng Chang, and Yueting Zhuang. 2024. Triad: A framework leveraging a multi-role llm-based agent to solve knowledge base question answering. arXiv preprint arXiv:2402.14320

    2024 arXiv

  31. [39]

    Arkaitz Zubiaga. 2024. Natural language processing in the era of large language models

    2024

  32. [40]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list...

  33. [41]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.