Pith. sign in

REVIEW 3 major objections 4 minor 9 cited by

DART-LLM: Dependency-Aware Multi-Robot Task Decomposition and Execution using Large Language Models

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

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

Pith's one-line read By adding a dependency graph to structured JSON output, DART-LLM lets smaller language models plan multi-robot construction tasks at state-of-the-art success rates.

desk verdict Useful engineering integration with a clean execution loop, but the ablation supporting the main claim is confounded by the executor policy and needs clarification. read the letter →

arxiv 2411.09022 v2 pith:MYKSXQ2J submitted 2024-11-13 cs.RO

Yongdong Wang , Runze Xiao , Jun Younes Louhi Kasahara , Ryosuke Yajima , Keiji Nagatani , Atsushi Yamashita , Hajime Asama This is my paper · ORCID
classification cs.RO
keywords multi-robottaskplanningdecompositionlargelanguagemodelsdirectedacyclicgraphdependencymodelingconstructionroboticsnaturalinstructionvision-languageobjectdetection
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

This paper claims that a major bottleneck in LLM-driven multi-robot planning is not just model capability but the absence of explicit task-order information. DART-LLM makes a large language model decompose a natural-language instruction into subtasks, each named by a fixed atomic skill and each carrying a list of prerequisite subtasks, and then runs those subtasks in topological order of the resulting dependency graph. On 102 construction-robot instructions, the framework reports perfect instruction parsing at every complexity level and success rates of 0.94 on the hardest level with DeepSeek-r1 and 0.84 with the 8B-parameter Llama-3.1, against a SMART-LLM baseline of 0.65 and 0.24. An ablation on level-3 tasks shows Llama-3.1's success rate falling from 0.84 to 0.45 when dependencies are not modeled, which the paper reads as evidence that the dependency graph compensates for small models' weaker reasoning.

What carries the argument

The load-bearing mechanism is the dependency-annotated directed acyclic graph (DAG) that the QA LLM produces as structured JSON. Each subtask $T^k_{t_j}$ names a breakdown function from the closed skill library $S$, object keywords, and a dependency list $d_k$; the system turns those lists into directed edges $D \subseteq T \times T$ and executes subtasks in topological order. The prompt $P=(I,E,R,S,F)$ ties the model to the environment, the robot skills, and the few-shot examples, so the planner's output is executable by construction rather than code that needs parsing or debugging.

What would settle it

Run the level-3 benchmark with the same DART-LLM prompts but execute the generated subtasks in random order rather than topological order of the dependency graph; if Llama-3.1's success rate stays near 0.84, the DAG is not what produces the reported gain.

Watch

Extended reading notes

Core claim

The central discovery is that a directed acyclic graph of subtask dependencies, expressed in a constrained JSON output and enforced by a runtime scheduler, is enough to make end-to-end multi-robot task execution reliable across a range of foundation models. The QA LLM does not generate code; it selects atomic skills from the skill library $S$, lists object keywords, and annotates each subtask with its dependencies $d_k$. The DAG built from these lists lets independent subtasks execute in parallel and dependent subtasks wait, while a VLM-based detector keeps the object map current. The paper reports that DART-LLM with DeepSeek-r1 reaches success rates of 1.00/0.97/0.94 across the L1/L2/L3 task levels, DART-LLM with Llama-3.1-8B reaches 1.00/0.85/0.84, and both beat the corresponding SMART-LLM baselines, which score 1.00/0.78/0.65 and 1.00/0.36/0.24 respectively. The ablation makes the mechanism explicit: removing the dependency structure drops Llama-3.1's L3 success rate from 0.84 to 0.45.

Load-bearing premise

The load-bearing premise is that every instruction a user gives can be decomposed into the fixed atomic skills and object keywords listed in the prompt; instructions requiring new actions, object types, or spatial reasoning outside that closed menu cannot be represented.

Editorial extensions

If this is right

  • Small models become deployable on constrained robots: on the hardest task level, Llama-3.1-8B with the DAG scores 0.84 success rate versus 0.24 for the SMART-LLM baseline using the same model.
  • The benefit is not specific to one foundation model; all five tested LLMs improve when dependencies are explicit, so the JSON-plus-DAG format is a model-agnostic prompt intervention.
  • Perfect instruction parsing across all 102 instructions means failure, when it happens, lies in dependency satisfaction or execution rather than in understanding the command.
  • Because the skills are atomic and executed through the ROS navigation stack, the planner runs end-to-end without manual code execution, which is the practical advantage over code-generating baselines.
  • The DAG's parallelism rule directly supports multi-robot coordination: independent subtasks launch concurrently and dependent subtasks wait, which is what the L3 tasks require.

Reading between the lines

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

  • The paper leaves untested how much of the gain comes from the dependency semantics versus the strict JSON format; a version that outputs the same JSON but ignores dependency lists at execution time would separate the two.
  • Because the skill library is closed, transfer to new construction or rescue domains depends on whether their operations can be enumerated in advance; open-ended tasks would need a hierarchical skill expansion mechanism.
  • A natural prediction, testable on the released benchmark, is that error rates track the number of dependency edges rather than the number of subtasks, since the DAG offloads ordering reasoning from the model to the scheduler.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 4 minor

Summary. The paper proposes DART-LLM, an end-to-end framework for multi-robot task execution in which an LLM parses natural-language instructions into JSON subtasks with explicit dependency lists, constructs a DAG, assigns robots, and executes atomic navigation and robot-specific skills, while a VLM-based detector maintains an object map. It introduces a 102-instruction construction benchmark at three complexity levels, evaluates five LLMs inside DART-LLM against SMART-LLM, and reports success rate, instruction parsing accuracy, dependency satisfaction rate, semantic grounding success rate, and response time reliability. The central claims are that explicit DAG-based dependency modeling improves task performance and especially compensates for the limited reasoning capabilities of small models, and that DART-LLM significantly outperforms the baseline across all evaluation metrics.

Significance. If the claims hold, the contribution is practically valuable: a structured dependency representation in the prompt, a fixed atomic skill library, real-time ROS2-based execution, and a reusable benchmark for multi-robot construction tasks. The idea that explicit dependency lists improve small-model planning is directionally sensible, and the paper provides a concrete system plus videos and a claimed code release. However, the evidence as presented is not yet sufficient: the ablation control is underspecified and potentially confounded, the state-of-the-art claim rests on a single baseline with point estimates on small samples, and the pseudocode contains an ordering inconsistency. The contribution is therefore promising but needs a revised experimental and presentation pass.

major comments (3)
  1. [IV-C-2 and Algorithm 1 (lines 11-18)] The 'Without Dependency' ablation condition is not specified, and this ambiguity is load-bearing for the paper's central claim that explicit DAG modeling compensates for small-model reasoning limits. If the control simply removes dependency lists from the JSON output, then every subtask has an empty dependency list and Algorithm 1 launches all subtasks in parallel; since L3 tasks are defined by strict execution order, the observed drop (e.g., Llama3.1: 0.84 to 0.45 in Fig. 3) could be caused by the executor policy change alone, not by degraded LLM reasoning. Please provide the exact control prompt template and the scheduling rule used in the 'Without Dependency' arm, or rerun the control while preserving execution order through an alternative mechanism (e.g., list order) so that the only difference is the explicit DAG representation.
  2. [Table V and Section IV-C-1] The claim that DART-LLM 'significantly outperforms' the baseline and achieves state-of-the-art performance is not statistically supported. The comparison uses only one baseline method (SMART-LLM), and all metrics are point estimates without confidence intervals, error bars, or significance tests. This matters particularly for L3, which contains only 22 tasks, so a difference of 0.94 vs. 0.93 corresponds to about one task; small absolute differences in Table V cannot support the stated significance. Please report multiple trials with intervals and appropriate statistical comparisons, and ideally add additional baseline methods.
  3. [Section IV-C-2 and Fig. 3] Even if the ablation scheduling confound is resolved, the mechanism claim—that dependency modeling improves the model's reasoning—requires evidence that the effect is not solely due to output format differences. The current paper only reports end-to-end success rates; it does not compare decomposition quality, dependency satisfaction, or parsing accuracy between the with/without conditions. Adding these metrics for the ablation arms would strengthen the claim that the DAG representation changes the model's planning behavior rather than merely changing how the executor interprets the output.
minor comments (4)
  1. [Algorithm 1] The pseudocode is internally inconsistent: lines 11-18 execute subtasks in topological order before lines 19-25 assign robots to subtasks, but robot assignment must logically precede execution. Please reorder the algorithm so that assignment happens before execution, or clarify the intended control flow.
  2. [Section III-A and III-C] The prompt template P = (I, E, R, S, F) and the few-shot example set F are central to reproducibility, but the paper does not include the actual prompt or the few-shot examples. Since F is a free parameter, please release the full prompt templates, the JSON schema, and the few-shot examples along with the code.
  3. [Section IV-B] The Response Time Reliability (RTR) metric is described only verbally as using average response time and standard deviation; the paper does not give the exact formula that maps these quantities to a value in [0,1]. Please define RTR formally.
  4. [Table IV] The skill list for L3-T2-001 is given as 'FE1, FE2, FE2, FD2', which appears to contain a duplicated FE2; please check whether this is a typo and ensure the skill lists match the task descriptions.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: the evaluation is measured against externally defined ground truth, and the dependency-ablation concern is an experimental-control ambiguity rather than a definitional reduction.

full rationale

The paper's core claim is that explicit dependency modeling via a DAG compensates for the limited reasoning capabilities of smaller models. Tracing the derivation chain, the QA LLM is prompted with P = (I, E, R, S, F) and asked to emit JSON subtasks with dependency lists; the DAG is constructed from those lists, and the executor follows topological order. No equations are fitted to the reported metrics, and no parameter is trained on the benchmark. The evaluation metrics (SR, IPA, DSR, SGSR, RTR) are defined with reference to dataset ground truth in Section IV-B, and the ground-truth task descriptions in Table IV are not defined in terms of the method's outputs. The comparison against SMART-LLM is an external baseline on the same benchmark, so the central result is not forced by construction. The only self-citation is reference [10], used in the introduction to motivate multi-robot construction scenarios; it is general related work and is not load-bearing for the dependency-aware contribution. The most substantial concern is the ablation in Section IV-C-2 / Fig. 3: the 'Without Dependency' condition is not specified in terms of how subtasks are scheduled, and Algorithm 1's default is to execute dependency-free subtasks in parallel. If the control arm removes dependency lists, the executor policy alone could produce the observed success-rate drop, independently of any change in LLM reasoning. However, this is an experimental-control ambiguity or validity threat, not a case where a prediction reduces to its input by definition or where a fitted parameter is renamed as a prediction. Therefore, no circular step meeting the stated evidentiary standard is present; the score is low, reflecting the non-load-bearing self-citation and the benchmark-design caveat rather than any detected circularity.

Assumptions & free parameters 2 free parameters · 3 assumptions · 0 invented entities

The central claims rest on the closed menu of atomic skills (Tables II-III), the unpublished few-shot prompt set F, the correctness of LLM-generated dependency edges, and the accuracy of the VLM object map. None of these is independently verified in the manuscript. No fitted numeric parameters appear in the framework.

free parameters (2)
  • few-shot example set F = not disclosed
    F defines the decomposition style for the QA LLM (Section III-A); its content is an authorship choice that affects all reported metrics and is not published, so the method cannot be exactly reproduced or audited.
  • atomic skill library S (navigation N1-N4, robot FE1-FE2, FD1-FD2) = hand-specified
    Defined by authors in Tables II-III; the closed set determines the output space for all decompositions and is a central design choice for the framework.
assumptions (3)
  • domain assumption Every high-level instruction I can be decomposed into a sequence of subtasks drawn from the fixed atomic skill library S (Tables II-III).
    Used in Sections III-A and IV-A; if real instructions require skills outside S, the framework cannot parse them.
  • domain assumption The dependency edges D elicited by the QA LLM are correct and complete; the LLM's stated dependencies match the physical constraints.
    Section III-B executes subtasks strictly in topological order of D; an incorrect D causes failure regardless of downstream actuation.
  • domain assumption VLM-based object detector positions are accurate enough for navigation and manipulation skills.
    Section III-D; object map database feeds parameters to the Breakdown Function Handler; no error analysis is provided.

how reviews work

0 comments
Cite this review

Pith. "Pith review of DART-LLM: Dependency-Aware Multi-Robot Task Decomposition and Execution using Large Language Models." pith.science (2026). https://pith.science/paper/MYKSXQ2J

@misc{pith2026241109022,
  author       = {Pith},
  title        = {Pith review of: DART-LLM: Dependency-Aware Multi-Robot Task Decomposition and Execution using Large Language Models},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/MYKSXQ2J}},
  note         = {Machine review of arXiv:2411.09022}
}
read the original abstract

Large Language Models (LLMs) have demonstrated promising reasoning capabilities in robotics; however, their application in multi-robot systems remains limited, particularly in handling task dependencies. This paper introduces DART-LLM, a novel framework that employs Directed Acyclic Graphs (DAGs) to model task dependencies, enabling the decomposition of natural language instructions into well-coordinated subtasks for multi-robot execution. DART-LLM comprises four key components: a Question-Answering (QA) LLM module for dependency-aware task decomposition, a Breakdown Function module for robot assignment, an Actuation module for execution, and a Vision-Language Model (VLM)-based object detector for environmental perception, achieving end-to-end task execution. Experimental results across three task complexity levels demonstrate that DART-LLM achieves state-of-the-art performance, significantly outperforming the baseline across all evaluation metrics. Among the tested models, DeepSeek-r1-671B achieves the highest success rate, whereas Llama-3.1-8B exhibits superior response time reliability. Ablation studies further confirm that explicit dependency modeling notably enhances the performance of smaller models, facilitating efficient deployment on resource-constrained platforms. Please refer to the project website https://wyd0817.github.io/project-dart-llm/ for videos and code.

Figures

Figures reproduced from arXiv: 2411.09022 by the authors.

Figure 1
Figure 1. An overview of the DART-LLM system architecture. The system is divided into three main modules: the Sensor Module, the Intelligent Command [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Dependency-aware task decomposition in DART-LLM. Left: QA LLM decomposes high-level instruction into subtasks with explicit dependency [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Success Rate (SR) comparison between ”With Dependencies” (using [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: DART-LLM (Llama3.1) in the L2-T1-001 Task Using Real Robots: [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 9 Pith papers

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

  1. CADENZA: Compiling Natural-Language Intent into Task-Specific Operator DAGs for Semantic Query Processing

    cs.DB 2026-06 unverdicted novelty 7.0 of 10

    CADENZA introduces TxRA and dual planners to compile semantic operator intents into optimized task DAGs, claiming large gains in quality, latency, and cost on SemBench.

  2. LLM-Based Generalizable Hierarchical Task Planning and Execution for Heterogeneous Robot Teams with Event-Driven Replanning

    cs.RO 2025-11 conditional novelty 6.0 of 10

    An LLM-based hierarchical system lets heterogeneous robot teams plan, execute, and autonomously replan in response to unexpected events, demonstrated on physical robots and in simulation.

  3. Incentivizing Multimodal Reasoning in Large Models for Direct Robot Manipulation

    cs.AI 2025-05 conditional novelty 6.0 of 10

    A 7B multimodal model can control a robot by predicting each next gripper pose in natural language, trained from only 65 dialogues plus simulator reinforcement learning, and it claims strong generalization to new sett...

  4. AIGB-R1: Self-Evolving Generative Auto-Bidding via Hierarchical Planner-Executor Optimization

    cs.LG 2026-07 conditional novelty 5.0 of 10

    AIGB-R1 couples an LLM strategy planner with a prompt-conditioned Decision Transformer executor and trains both end-to-end with a decoupled-GRPO self-evolving loop, reporting the highest Score on the AuctionNet benchmark.

  5. Dynamic Task Adaptation for Multi-Robot Manufacturing Systems with Large Language Models

    cs.RO 2025-05 conditional novelty 5.0 of 10

    An LLM-based central controller successfully reassigned tasks to a surviving robot in 20 of 20 failure trials, with 60% valid on the first attempt.

  6. LLM-Flock: Decentralized Multi-Robot Flocking via Large Language Models and Influence-Based Consensus

    cs.RO 2025-05 conditional novelty 5.0 of 10

    LLM-Flock combines per-robot LLM planning with an influence-based plan-copying rule to stabilize decentralized multi-robot formations.

  7. GeoManip: Geometric Constraints as General Interfaces for Robot Manipulation

    cs.RO 2025-01 conditional novelty 5.0 of 10

    GeoManip uses large vision-language models to turn task descriptions into geometric constraints and cost functions, then solves for robot trajectories without training, reporting state-of-the-art success rates on simu...

  8. Get Experience from Practice: LLM Agents with Record & Replay

    cs.LG 2025-05 reject novelty 4.0 of 10

    AgentRR is a proposed paradigm that records agent traces, generalizes them into multi-level experiences, and replays them under safety checks to make LLM agents cheaper, faster, and more reliable.

  9. Multi-agent Embodied AI: Advances and Future Directions

    cs.AI 2025-05 conditional novelty 3.0 of 10

    A survey that maps multi-agent embodied AI methods and benchmarks across control, learning, and generative-model categories, and lists open challenges.

Reference graph

Works this paper leans on

21 extracted references · 4 canonical work pages · cited by 9 Pith papers

  1. [1]

    Decision transformer: Reinforcement learning via sequence modeling,

    L. Chen, K. Lu, A. Rajeswaran, K. Lee, A. Grover, M. Laskin, P. Abbeel, A. Srinivas, and I. Mordatch, “Decision transformer: Reinforcement learning via sequence modeling,” Advances in neural information processing systems , vol. 34, pp. 15 084–15 097, 2021

    2021

  2. [2]

    A generalist agent,

    S. Reed, K. Zolna, E. Parisotto, S. G. Colmenarejo, A. Novikov, G. Barth-Maron, M. Gimenez, Y . Sulsky, J. Kay, J. T. Springenberg et al. , “A generalist agent,” arXiv preprint arXiv:2205.06175 , 2022

    arXiv 2022

  3. [3]

    Do as i can, not as i say: Grounding language in robotic affordances,

    M. Ahn, A. Brohan, N. Brown, Y . Chebotar, O. Cortes, B. David, C. Finn, C. Fu, K. Gopalakrishnan, K. Hausman et al. , “Do as i can, not as i say: Grounding language in robotic affordances,” arXiv preprint arXiv:2204.01691, 2022

    arXiv 2022

  4. [4]

    Inner monologue: Embodied reasoning through planning with language models,

    W. Huang, F. Xia, T. Xiao, H. Chan, J. Liang, P. Florence, A. Zeng, J. Tompson, I. Mordatch, Y . Chebotar et al. , “Inner monologue: Embodied reasoning through planning with language models,” arXiv preprint arXiv:2207.05608, 2022

    arXiv 2022

  5. [5]

    Rt-1: Robotics transformer for real-world control at scale,

    A. Brohan, N. Brown, J. Carbajal, Y . Chebotar, J. Dabis, C. Finn, K. Gopalakrishnan, K. Hausman, A. Herzog, J. Hsu et al. , “Rt-1: Robotics transformer for real-world control at scale,” arXiv preprint arXiv:2212.06817, 2022

    arXiv 2022

  6. [6]

    Rt-2: Vision- language-action models transfer web knowledge to robotic control,

    A. Brohan, N. Brown, J. Carbajal, Y . Chebotar, X. Chen, K. Choro- manski, T. Ding, D. Driess, A. Dubey, C. Finn et al. , “Rt-2: Vision- language-action models transfer web knowledge to robotic control,” arXiv preprint arXiv:2307.15818 , 2023

    arXiv 2023

  7. [7]

    Palm-e: An embodied multimodal language model,

    D. Driess, F. Xia, M. S. Sajjadi, C. Lynch, A. Chowdhery, B. Ichter, A. Wahid, J. Tompson, Q. Vuong, T. Yu et al., “Palm-e: An embodied multimodal language model,” arXiv preprint arXiv:2303.03378 , 2023

    arXiv 2023

  8. [8]

    Code as policies: Language model programs for em- bodied control,

    J. Liang, W. Huang, F. Xia, P. Xu, K. Hausman, B. Ichter, P. Florence, and A. Zeng, “Code as policies: Language model programs for em- bodied control,” in 2023 IEEE International Conference on Robotics and Automation (ICRA) . IEEE, 2023, pp. 9493–9500

    2023

Show all 21 references
  1. [9]

    V oxposer: Composable 3d value maps for robotic manipulation with language models,

    W. Huang, C. Wang, R. Zhang, Y . Li, J. Wu, and L. Fei-Fei, “V oxposer: Composable 3d value maps for robotic manipulation with language models,” arXiv preprint arXiv:2307.05973 , 2023

    2023 arXiv

  2. [10]

    Innovative technologies for infrastructure construction and maintenance through collaborative robots based on an open design approach,

    K. Nagatani, M. Abe, K. Osuka, P.-j. Chun, T. Okatani, M. Nishio, S. Chikushi, T. Matsubara, Y . Ikemoto, and H. Asama, “Innovative technologies for infrastructure construction and maintenance through collaborative robots based on an open design approach,” Advanced Robotics, v...

    2021

  3. [11]

    Roco: Dialectic multi-robot collabo- ration with large language models,

    Z. Mandi, S. Jain, and S. Song, “Roco: Dialectic multi-robot collabo- ration with large language models,” arXiv preprint arXiv:2307.04738 , 2023

    2023 arXiv

  4. [12]

    Smart-llm: Smart multi-agent robot task planning using large language models,

    S. S. Kannan, V . L. Venkatesh, and B.-C. Min, “Smart-llm: Smart multi-agent robot task planning using large language models,” arXiv preprint arXiv:2309.10062, 2023

    2023 arXiv

  5. [13]

    Robot operating system 2: Design, architecture, and uses in the wild,

    S. Macenski, T. Foote, B. Gerkey, C. Lalancette, and W. Woodall, “Robot operating system 2: Design, architecture, and uses in the wild,” Science Robotics , vol. 7, no. 66, p. eabm6074, 2022

    2022

  6. [14]

    The marathon 2: A navigation system,

    S. Macenski, F. Martn, R. White, and J. Gins Clavero, “The marathon 2: A navigation system,” in 2020 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) , 2020

    2020

  7. [15]

    Efficient graph-based image segmentation,

    P. F. Felzenszwalb and D. P. Huttenlocher, “Efficient graph-based image segmentation,” International journal of computer vision , vol. 59, pp. 167–181, 2004

    2004

  8. [16]

    Learning transferable visual models from natural language supervision,

    A. Radford, J. W. Kim, C. Hallacy, A. Ramesh, G. Goh, S. Agarwal, G. Sastry, A. Askell, P. Mishkin, J. Clark et al., “Learning transferable visual models from natural language supervision,” in International conference on machine learning . PMLR, 2021, pp. 8748–8763

    2021

  9. [17]

    The llama 3 herd of models,

    A. Dubey, A. Jauhri, A. Pandey, A. Kadian, A. Al-Dahle, A. Letman, A. Mathur, A. Schelten, A. Yang, A. Fan et al. , “The llama 3 herd of models,” arXiv preprint arXiv:2407.21783 , 2024

    2024 arXiv

  10. [18]

    Gpt-4o system card,

    A. Hurst, A. Lerer, A. P. Goucher, A. Perelman, A. Ramesh, A. Clark, A. Ostrow, A. Welihinda, A. Hayes, A. Radford et al., “Gpt-4o system card,” arXiv preprint arXiv:2410.21276 , 2024

    2024 arXiv

  11. [19]

    OpenAI GPT-3.5 Turbo,

    “OpenAI GPT-3.5 Turbo,” accessed: 2025-03-01. [Online]. Available: https://openai.com/index/gpt-3-5-turbo-fine-tuning-and-api-updates/ ?utm source=chatgpt.com

    2025

  12. [20]

    Anthropic Claude 3.5 Haiku,

    “Anthropic Claude 3.5 Haiku,” accessed: 2025-03-01. [Online]. Avail- able: https://www.anthropic.com/news/3-5-models-and-computer-use

    2025

  13. [21]

    Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning,

    D. Guo, D. Yang, H. Zhang, J. Song, R. Zhang, R. Xu, Q. Zhu, S. Ma, P. Wang, X. Bi et al., “Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning,” arXiv preprint arXiv:2501.12948 , 2025

    2025 arXiv

Pith tools

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