Pith. sign in

REVIEW 5 major objections 5 minor 2 cited by

PlotGen: Multi-Agent LLM-based Scientific Data Visualization via Multimodal Feedback

T0 review · 5 major / 5 minor · reviewed 2026-08-09 · deepseek-v4-flash

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

Pith's one-line read PlotGen claims that letting LLM agents inspect a rendered chart's numbers, labels, and visuals, then feed textual fixes back to the code writer, improves automated scientific visualization by 4-6 percent on MatPlotBench.

desk verdict PlotGen is a real but incremental extension of MatPlotAgent with consistent gains across four backbones, though the same-model feedback/judge loop and sloppy headline numbers leave the true size of the win uncertain. read the letter →

arxiv 2502.00988 v1 pith:5W5TDKIY submitted 2025-02-03 cs.CL cs.AI

Kanika Goswami , Puneet Mathur , Ryan Rossi , Franck Dernoncourt This is my paper · ORCID
classification cs.CLcs.AI
keywords agenticgenerationmultimodalretrievalfeedbackLLMagentsdatavisualizationself-reflectionMatPlotBenchcodeGPT-4V
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 tries to establish that automated scientific chart generation becomes substantially more accurate when multiple LLM agents inspect an intermediate plot the way a human would: reading its numbers, labels, and visual appearance, and sending textual corrections back to the code-writing agent. This matters because novice users often get subtly wrong charts from a single LLM call and spend significant time debugging them. If the claim is right, a pipeline of agents with vision feedback can replace much of that manual debugging and raise trust in LLM-generated visualizations. The paper states the gain as 4-6 percent on MatPlotBench, though its introduction and conclusion also mention 10-12 percent; Table 1's numbers align with the smaller figure.

What carries the argument

The machinery is the multimodal feedback loop: a draft Matplotlib figure is rendered, then GPT-4V is used in three roles—as a de-renderer that reads plotted values back and compares them with the data table, as a reader that verifies textual labels, and as a viewer that judges visual layout and aesthetics. The resulting textual critiques are appended to the code-generation prompt for the next iteration. This treats the rendered image, not just the source code, as an artifact the system can inspect, which is what lets it catch errors that are invisible in code alone.

What would settle it

Take the 100 MatPlotBench queries, run PlotGen and MatPlotAgent, and have human experts score the final charts blind using the same 0-100 rubric; if human rankings do not reproduce the 4-6 percent gap, the reported advantage is an artifact of the GPT-4V judge. A more direct test: feed a chart whose values are deliberately shifted by a small constant and see whether the Numeric Feedback Agent flags it; if it does not, the de-rendering comparison that drives the method fails.

Watch

Extended reading notes

Core claim

PlotGen is a five-agent system. A Query Planning Agent decomposes the user request into executable steps; a Code Generation Agent writes and self-debugs Python code; then Numeric, Lexical, and Visual Feedback Agents, all using GPT-4V, examine the rendered figure and compare it against the original data table and user specifications. The Numeric agent de-renders the chart to recover plotted values and checks trends and chart type; the Lexical agent reads titles, axis labels, ticks, and legend text against ground truth; the Visual agent checks color, layout, and aesthetics. Each returns textual critique to the code agent, and iteration continues until satisfactory or the maximum trial count is reached. On MatPlotBench, PlotGen scores 48.82, 57.13, 53.25, and 65.67 for WizardCoder, Magicoder, GPT-3.5, and GPT-4, compared with 45.96, 51.70, 47.51, and 61.16 for MatPlotAgent, a 4-6 percent relative improvement, with an ablation showing that removing visual feedback causes the largest drop (10-15 percent).

Load-bearing premise

The whole gain rests on GPT-4V being able to look at a rendered chart and correctly recover its data values, read its labels, and judge its visual layout; if those perceptions are wrong, the critique sent back to the code generator is wrong too.

Editorial extensions

If this is right

  • Using PlotGen with GPT-4 as the code LLM reaches 65.67 on MatPlotBench, the best score reported in the paper, indicating higher-fidelity charts for complex requests.
  • The visual feedback agent is the largest contributor: removing it drops performance by 10-15 percent across all code LLMs, so aesthetic and placement checking is load-bearing, not a nicety.
  • The gains hold across open-source backbones (WizardCoder-33B, Magicoder-6.7B) as well as closed-source models (GPT-3.5, GPT-4), so the framework does not depend on one code model.
  • A small user study with five participants on 200 queries found 40.5 percent of outputs rated Completely Accurate and 24.5 percent Somewhat Accurate, suggesting reduced debugging time for novice analysts.

Reading between the lines

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

  • Inference: the 4-6 percent headline is relative to MatPlotAgent; on an absolute scale the best PlotGen score is 65.67 out of 100, so roughly a third of generated charts still fail the GPT-4V judge, leaving room for further improvement.
  • Inference: if GPT-4V's de-rendering ability is the bottleneck, swapping the vision model in the feedback agents should shift scores without retraining, which is a directly testable extension.
  • Inference: the ablation shows visual feedback matters most, but the paper does not isolate whether that is because visual errors are more frequent or because the other two agents already catch many of them; a per-query error taxonomy would settle it.
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

5 major / 5 minor

Summary. The paper proposes PlotGen, a multi-agent LLM framework that generates scientific visualizations from natural-language requests and tabular data. The system combines a Query Planning Agent, a Code Generation Agent with debugger-based self-correction, and three multimodal feedback agents (Numeric, Lexical, and Visual) that use GPT-4V to iteratively critique intermediate plots. The authors evaluate on MatPlotBench, comparing PlotGen against direct decoding, zero-shot chain-of-thought prompting, and MatPlotAgent across four code LLMs, and they report a 5-participant user study. The central claim is that PlotGen outperforms strong baselines by 4-6% on MatPlotBench, and the paper includes an ablation discussion attributing performance drops to removal of each feedback agent. No code, prompts, or detailed experimental configurations are provided.

Significance. If the experimental claims hold, PlotGen would be a useful architectural contribution to LLM-based scientific visualization, since the decomposition into numeric, lexical, and visual feedback channels is a natural and plausible design. The paper gives credit where it is due: Table 1 shows consistent absolute-score improvements over MatPlotAgent for all four code backbones, and the three-agent feedback design is clearly described. The work also builds on an established benchmark, MatPlotBench, rather than an ad-hoc evaluation set. However, the significance is currently limited by the absence of statistical testing, the lack of code and prompt-level reproducibility, and by the fact that the reported headline gains are inconsistent across the abstract, introduction, and conclusion. The most serious concern is that GPT-4V is used both as the in-loop feedback critic and as the evaluation judge, which means the reported gains could partly reflect optimization against the judge's own preferences rather than human-visible quality.

major comments (5)
  1. [Abstract, §1, §5, and Table 1] The headline improvement is inconsistent and does not match the numbers in Table 1. The abstract and the contributions in §1 state a '4-6% improvement on the MatPlotBench dataset,' while the introduction's first mention and the conclusion state '10-12%.' Relative to MatPlotAgent, the Table 1 gains are approximately 6.2%, 10.5%, 12.1%, and 7.4% for WizardCoder, Magicoder, GPT-3.5, and GPT-4 respectively; neither '4-6%' nor '10-12%' describes these values, and the paper does not state whether the percentages are relative improvements or absolute score differences. The authors should choose one formulation and report both absolute and relative gains consistently.
  2. [§4 Evaluation and Table 1] The evaluation reports no variance, no significance tests, and no per-instance breakdown. MatPlotBench contains only 100 queries, so the differences in Table 1—for example, 48.82 vs. 45.96 for WizardCoder and 65.67 vs. 61.16 for GPT-4—could be within run-to-run noise, especially because the feedback loop includes stochastic LLM calls. The paper should provide confidence intervals, significance tests, or at least multiple independent runs for each configuration, along with an explanation of how the 100 queries were split or repeated.
  3. [§3 Multimodal Feedback and §4 Evaluation] There is a potential evaluation circularity: GPT-4V is the model that generates all three types of in-loop feedback in §3, and it is also the LLM-as-a-judge used to score the final visualizations in §4, following MatPlotBench. The cited validation of the GPT-4V judge in [26] was established for one-shot static scoring, not for an agent that iteratively optimizes against the same model's feedback. Because PlotGen's code revisions are driven by GPT-4V's own visual preferences, the reported gains may reflect reward hacking or judge self-preference rather than improvements humans would perceive. The authors should break this loop by adding a blinded head-to-head human evaluation against MatPlotAgent, or by scoring with a different multimodal judge and showing agreement.
  4. [§5 Ablation Study] The ablation claims are not supported by a results table. The text reports '5-7%' deterioration without the Lexical Feedback agent, a 'severe' drop of '10-15%' without the Visual Feedback agent, and an unspecified drop for the Numerical Feedback agent, but no ablation scores are given for any code LLM backend. Since the central claim is that each of the three feedback agents contributes to the overall gain, the paper should include a full ablation table with exact scores for each ablated variant, in addition to the complete PlotGen and baseline rows.
  5. [Reproducibility (Methodology, §3-§4)] The manuscript does not release code, prompts, agent temperatures, maximum trial counts, or satisfaction thresholds, despite the methodology stating that 'we restrict the number of iterations of self-debugging' and that each feedback agent 'repeatedly' iterates 'until satisfactory results are achieved in that domain or the maximum trial count runs out.' Without these details, the system is not reproducible and the free parameters cannot be assessed. The authors should provide the full prompt templates, the exact values for maximum trials and satisfaction thresholds, the GPT-4V version used, and the code or an anonymized artifact.
minor comments (5)
  1. [§2 Related Work] Several references are malformed or duplicated: Code Llama is cited as both [17] and [18], and the sentence listing open-source LLMs reads 'DeepSeekCoder [6], [9], [23]' without naming the model for [9]; the authors should clean up the reference list and inline citations.
  2. [Figure 2] Figure 2, labeled 'User Evaluation,' is a bar chart with no axis labels, legend, or numeric values, and the caption does not explain what is being compared; the text reports percentages such as 40.5% and 24.5%, but the figure alone is uninterpretable.
  3. [§5 User Evaluation] The user study is described too briefly: it is unclear how the five participants were recruited, what interface they used, whether they saw the ground-truth reference, how 'Completely Accurate' versus 'Somewhat Accurate' was defined, and whether the 200 requests were the same across participants; additionally, the study does not compare PlotGen against MatPlotAgent, so it cannot support the relative superiority claim.
  4. [General formatting] The paper retains ACM template placeholder metadata, including 'Conference acronym 'XX,' 'June 03–05, 2018, Woodstock, NY,' and a 2018 copyright line; the authors should update these formalities before any publication.
  5. [§4 Evaluation] The sentence 'The authors show that automatic evaluation scores provided by GPT-4V are sufficiently reliable due to their strong correlated with human evaluation results' contains a grammatical error and should be rewritten as '...are sufficiently reliable because they are strongly correlated with human evaluation results,' with a proper restatement of the relevant finding from [26].

Circularity Check

1 steps flagged · score 2.0 of 10

No definitional circularity; the reported MatPlotBench gain is mildly confounded because GPT-4V serves both as the in-loop feedback engine and as the LLM-as-a-judge scorer.

  1. other [Section 4 (Evaluation) and Section 3 (Multimodal Feedback Agents 3–5)]
    "Following [26], we use LLM-as-a-judge automatic scoring metric between 0 to 100 to evaluate model-generated visualizations with corresponding ground-truth as a reference. The authors show that automatic evaluation scores provided by GPT-4V are sufficiently reliable due to their strong correlated with human evaluation results."

    The same GPT-4V model family is used inside the three multimodal feedback agents that iteratively revise the plotting code (Numeric, Lexical, and Visual Feedback Agents, each using GPT-4V to inspect the draft figure) and is also the judge that assigns the final 0–100 score. PlotGen is therefore partially optimized against GPT-4V's own visual and lexical preferences and then evaluated by that same model, which can inflate the observed 4–6% improvement over MatPlotAgent — especially since the visual-feedback ablation shows the largest performance drop. This is a closed-loop evaluation concern rather than a definitional equivalence, because the feedback also verifies numeric trends and labels against the original data table and the benchmark itself is external.

full rationale

PlotGen's derivation chain is largely self-contained: the system generates code, renders plots, and iteratively checks the rendered output against the original data table and user request. The benchmark (MatPlotBench) and its GPT-4V-as-judge metric are external to this paper, and the central comparison is an empirical head-to-head on that benchmark. No claim reduces to a fitted parameter, an equation, or a self-citation chain; the only author self-citation (DocPilot, [10]) is unrelated to the main result. The one substantive circularity-adjacent issue is the evaluation overlap: the same GPT-4V model that supplies visual/lexical/numeric feedback also serves as the final automated judge, so the reported gain may partly reflect optimization against the judge's own preferences rather than purely human-visible quality. This is a mild evaluation-overlap concern, not a definitional circularity, and the paper also reports a small human study; hence a low score of 2.

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

The central result rests on unstated hyperparameters (trial counts, satisfaction thresholds), on the perceptual reliability of GPT-4V for both feedback and evaluation, and on the validity of Matplotlib rendering as a proxy for chart quality. No code or independent validation is provided.

free parameters (2)
  • Per-agent maximum trial count = not reported
    The feedback loop stops when agents are satisfied or the max trial count is reached; no value or sensitivity analysis is given, yet this controls cost and final quality.
  • Satisfaction threshold for feedback agents = not reported
    The criterion for 'satisfactory results' in each feedback domain is not specified, making the stopping behavior underdetermined.
assumptions (3)
  • domain assumption GPT-4V can accurately de-render plot images and compare data trends with the source table.
    Invoked in Section 3, Numeric Feedback Agent, to justify automated data accuracy checks.
  • domain assumption GPT-4V-based LLM-as-a-judge scores correlate with human evaluation.
    Adopted from [26] in Section 4, Evaluation; the paper does not independently validate this for its own outputs.
  • domain assumption Matplotlib code output is a faithful representation of the visualization intended by the user request.
    The entire pipeline judges correctness on rendered Matplotlib figures, assuming rendering preserves the semantic content.
invented entities (4)
  • Query Planning Agent
    purpose: Decompose user requests into executable steps
    Novel component introduced by this paper; no external evaluation separate from the full system.
  • Numeric Feedback Agent
    purpose: Check plotted data trends and chart type against source data
    Part of the proposed architecture; contribution is only supported by the paper's aggregate results and prose ablation.
  • Lexical Feedback Agent
    purpose: Verify titles, labels, ticks, and legends
    Same as above; no standalone validation.
  • Visual Feedback Agent
    purpose: Check color, layout, scaling, and aesthetics
    Similar to MatPlotAgent's visual feedback [26]; here it is one of three parallel agents, with no isolated external benchmark.

how reviews work

0 comments
Cite this review

Pith. "Pith review of PlotGen: Multi-Agent LLM-based Scientific Data Visualization via Multimodal Feedback." pith.science (2026). https://pith.science/paper/5W5TDKIY

@misc{pith2026250200988,
  author       = {Pith},
  title        = {Pith review of: PlotGen: Multi-Agent LLM-based Scientific Data Visualization via Multimodal Feedback},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/5W5TDKIY}},
  note         = {Machine review of arXiv:2502.00988}
}
read the original abstract

Scientific data visualization is pivotal for transforming raw data into comprehensible visual representations, enabling pattern recognition, forecasting, and the presentation of data-driven insights. However, novice users often face difficulties due to the complexity of selecting appropriate tools and mastering visualization techniques. Large Language Models (LLMs) have recently demonstrated potential in assisting code generation, though they struggle with accuracy and require iterative debugging. In this paper, we propose PlotGen, a novel multi-agent framework aimed at automating the creation of precise scientific visualizations. PlotGen orchestrates multiple LLM-based agents, including a Query Planning Agent that breaks down complex user requests into executable steps, a Code Generation Agent that converts pseudocode into executable Python code, and three retrieval feedback agents - a Numeric Feedback Agent, a Lexical Feedback Agent, and a Visual Feedback Agent - that leverage multimodal LLMs to iteratively refine the data accuracy, textual labels, and visual correctness of generated plots via self-reflection. Extensive experiments show that PlotGen outperforms strong baselines, achieving a 4-6 percent improvement on the MatPlotBench dataset, leading to enhanced user trust in LLM-generated visualizations and improved novice productivity due to a reduction in debugging time needed for plot errors.

Figures

Figures reproduced from arXiv: 2502.00988 by the authors.

Figure 1
Figure 1. PlotGen generates accurate scientific data visualizations based on user specifications by orchestrating multimodal LLMs: (1) Query Planning Agent that breaks down complex user requests into executable steps; (2) Code Generation Agent that converts pseudocode into executable Python code; and three code retrieval feedback agents—(3) Numeric Feedback Agent, (4) Lexical Feedback Agent, and (5) Visual Feedback Agent—that… view at source ↗
Figure 2
Figure 2. User Evaluation are sufficiently reliable due to their strong correlated with human evaluation results. Libraries: We use MatPlotlib to generate final output from LLM code output. We use Huggingface library to run open-source code LLMs. 5 Results and Discussion Performance Evaluation [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

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

  1. From EduVisBench to EduVisAgent: A Benchmark and Multi-Agent Framework for Reasoning-Driven Pedagogical Visualization

    cs.AI 2025-05 conditional novelty 6.0 of 10

    EduVisAgent, a five-agent framework, outperforms all baseline AI models at generating pedagogically effective interactive visualizations for STEM problems, according to the new EduVisBench benchmark and its GPT-4o-bas...

  2. AI for Auto-Research: Roadmap & User Guide

    cs.AI 2026-05 unverdicted novelty 4.0 of 10

    The paper delivers a stage-by-stage roadmap for AI in research, showing reliable assistance in retrieval and tool tasks but fragility in novelty and judgment, advocating human-governed collaboration.

Reference graph

Works this paper leans on

27 extracted references · 10 canonical work pages · cited by 2 Pith papers

  1. [26]

    Zhiyu Yang, Zihan Zhou, Shuo Wang, Xin Cong, Xu Han, Yukun Yan, Zhenghao Liu, Zhixing Tan, Pengyuan Liu, Dong Yu, Zhiyuan Liu, Xiaodong Shi, and Maosong Sun. 2024. MatPlotAgent: Method and Evaluation for LLM-Based Agentic Scientific Data Visualization. ArXiv abs/2402.11453 (2024). https: //api.semanticscholar.org/CorpusID:267750198

    arXiv 2024

  2. [1]

    GPT-4 Technical Report

    2023. GPT-4 Technical Report. https://api.semanticscholar.org/CorpusID: 257532815

    work page 2023

  3. [2]

    Matthew Berger and Shusen Liu. 2024. The Visualization JUDGE: Can Multi- modal Foundation Models Guide Visualization Design Through Visual Perception? PlotGen: Multi-Agent LLM-based Scientific Data Visualization via Multimodal Feedback Conference acronym ’XX, June 03–05, 2018, Woodstock, NY arXiv preprint arXiv:2410.04280 (2024)

    work page Pith review arXiv 2024

  4. [3]

    Liying Cheng, Xingxuan Li, and Lidong Bing. 2023. Is GPT-4 a Good Data Analyst? ArXiv abs/2305.15038 (2023). https://api.semanticscholar.org/CorpusID: 258866019

    arXiv 2023

  5. [4]

    Victor Dibia. 2023. LIDA: A Tool for Automatic Generation of Grammar-Agnostic Visualizations and Infographics using Large Language Models. In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrations), Danushka Bollegala, Ruihong Huang, and Alan Ritter (Eds.). Association for Computational Lin...

    doi:10.18653/v1/2023.acl-demo.11 2023

  6. [5]

    Dibia and Ça ˘gatay Demiralp

    Victor C. Dibia and Ça ˘gatay Demiralp. 2018. Data2Vis: Automatic Gen- eration of Data Visualizations Using Sequence-to-Sequence Recurrent Neu- ral Networks. IEEE Computer Graphics and Applications 39 (2018), 33–46. https://api.semanticscholar.org/CorpusID:4706694

    work page 2018

  7. [6]

    Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Yu Wu, Y . K. Li, Fuli Luo, Yingfei Xiong, and Wen- feng Liang. 2024. DeepSeek-Coder: When the Large Language Model Meets Programming - The Rise of Code Intelligence. ArXiv abs/2401.14196 (2024). https://api.semanticscholar.org/CorpusID:267211867

    arXiv 2024

  8. [7]

    Ziwei Ji, Tiezheng Yu, Yan Xu, Nayeon Lee, Etsuko Ishii, and Pascale Fung. 2023. Towards Mitigating LLM Hallucination via Self Reflection. In Conference on Empirical Methods in Natural Language Processing. https://api.semanticscholar. org/CorpusID:266176951

    work page 2023

Show all 27 references
  1. [8]

    Hanyu Lai, Xiao Liu, Iat Long Iong, Shuntian Yao, Yuxuan Chen, Pengbo Shen, Hao Yu, Hanchen Zhang, Xiaohan Zhang, Yuxiao Dong, et al. 2024. AutoWe- bGLM: A Large Language Model-based Web Navigating Agent. InProceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery a...

    2024

  2. [9]

    Ziyang Luo, Can Xu, Pu Zhao, Qingfeng Sun, Xiubo Geng, Wenxiang Hu, Chongyang Tao, Jing Ma, Qingwei Lin, and Daxin Jiang. 2023. WizardCoder: Em- powering Code Large Language Models with Evol-Instruct.ArXiv abs/2306.08568 (2023). https://api.semanticscholar.org/CorpusID:259164815

    2023 arXiv

  3. [10]

    Puneet Mathur, Alexa Siu, Varun Manjunatha, and Tong Sun. 2024. DocPilot: Copilot for Automating PDF Edit Workflows in Documents. InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrations). 232–246

    2024

  4. [11]

    Reiichiro Nakano, Jacob Hilton, Suchir Balaji, Jeff Wu, Ouyang Long, Christina Kim, Christopher Hesse, Shantanu Jain, Vineet Kosaraju, William Saunders, Xu Jiang, Karl Cobbe, Tyna Eloundou, Gretchen Krueger, Kevin Button, Matthew Knight, Benjamin Chess, and John Schulman. 2021...

    2021 arXiv

  5. [12]

    Joon Sung Park, Joseph O’Brien, Carrie Jun Cai, Meredith Ringel Morris, Percy Liang, and Michael S Bernstein. 2023. Generative agents: Interactive simulacra of human behavior. In Proceedings of the 36th annual acm symposium on user interface software and technology. 1–22

    2023

  6. [13]

    Patil, Tianjun Zhang, Xin Wang, and Joseph E

    Shishir G. Patil, Tianjun Zhang, Xin Wang, and Joseph E. Gonzalez. 2023. Gorilla: Large Language Model Connected with Massive APIs. ArXiv abs/2305.15334 (2023). https://api.semanticscholar.org/CorpusID:258865184

    2023 arXiv

  7. [14]

    Cheng Qian, Wei Liu, Hongzhang Liu, Nuo Chen, Yufan Dang, Jiahao Li, Cheng Yang, Weize Chen, Yusheng Su, Xin Cong, Juyuan Xu, Dahai Li, Zhiyuan Liu, and Maosong Sun. 2023. ChatDev: Communicative Agents for Software Development. In Annual Meeting of the Association for Computat...

    2023

  8. [15]

    Yujia Qin, Zihan Cai, Dian Jin, Lan Yan, Shihao Liang, Kunlun Zhu, Yankai Lin, Xu Han, Ning Ding, Huadong Wang, et al. 2023. Webcpm: Interactive web search for chinese long-form question answering. arXiv preprint arXiv:2305.06849 (2023)

    2023 arXiv

  9. [16]

    Gerstein, Dahai Li, Zhiyuan Liu, and Maosong Sun

    Yujia Qin, Shi Liang, Yining Ye, Kunlun Zhu, Lan Yan, Ya-Ting Lu, Yankai Lin, Xin Cong, Xiangru Tang, Bill Qian, Sihan Zhao, Runchu Tian, Ruobing Xie, Jie Zhou, Marc H. Gerstein, Dahai Li, Zhiyuan Liu, and Maosong Sun. 2023. ToolLLM: Facilitating Large Language Models to Maste...

    2023 arXiv

  10. [18]

    Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiao- qing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, et al. 2023. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950 (2023)

    2023 arXiv

  11. [19]

    Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. 2023. Toolformer: Language Models Can Teach Themselves to Use Tools. ArXiv abs/2302.04761 (2023). https://api.semanticscholar.org/CorpusID:256697342

    2023 arXiv

  12. [20]

    Noah Shinn, Beck Labash, and Ashwin Gopinath. 2023. Reflexion: an autonomous agent with dynamic memory and self-reflection. ArXiv abs/2303.11366 (2023). https://api.semanticscholar.org/CorpusID:257636839

    2023 arXiv

  13. [21]

    Yuan Tian, Weiwei Cui, Dazhen Deng, Xinjing Yi, Yurun Yang, Haidong Zhang, and Yingcai Wu. 2024. Chartgpt: Leveraging llms to generate charts from abstract natural language. IEEE Transactions on Visualization and Computer Graphics (2024)

    2024

  14. [22]

    Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi (Jim) Fan, and Anima Anandkumar. 2023. V oyager: An Open-Ended Embodied Agent with Large Language Models. Trans. Mach. Learn. Res. 2024 (2023). https://api.semanticscholar.org/CorpusID:258887849

    2023

  15. [23]

    Yuxiang Wei, Zhe Wang, Jiawei Liu, Yifeng Ding, and Lingming Zhang. 2023. Magicoder: Source Code Is All You Need. ArXiv abs/2312.02120 (2023). https: //api.semanticscholar.org/CorpusID:265609970

    2023 arXiv

  16. [24]

    Tianbao Xie, Fan Zhou, Zhoujun Cheng, Peng Shi, Luoxuan Weng, Yitao Liu, Toh Jing Hua, Junning Zhao, Qian Liu, Che Liu, et al . 2023. Openagents: An open platform for language agents in the wild. arXiv preprint arXiv:2310.10634 (2023)

    2023 arXiv

  17. [25]

    Yupeng Xie, Yuyu Luo, Guoliang Li, and Nan Tang. 2024. HAIChart: Human and AI Paired Visualization System. arXiv preprint arXiv:2406.11033 (2024)

    2024 arXiv

  18. [27]

    Shunyu Yao, Howard Chen, John Yang, and Karthik Narasimhan. 2022. Webshop: Towards scalable real-world web interaction with grounded language agents. Advances in Neural Information Processing Systems 35 (2022), 20744–20757

    2022

  19. [28]

    Shuyan Zhou, Frank F Xu, Hao Zhu, Xuhui Zhou, Robert Lo, Abishek Sridhar, Xianyi Cheng, Tianyue Ou, Yonatan Bisk, Daniel Fried, et al. 2023. Webarena: A realistic web environment for building autonomous agents. arXiv preprint arXiv:2307.13854 (2023)

    2023 arXiv

Pith tools

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