SysTemp: A Multi-Agent System for Template-Based Generation of SysML v2

Alexandre Poisson; Bruno Yun; Fr\'ed\'eric Armetta; Yasmine Bouamra

REVIEW 4 major objections 6 minor 29 references

SysTemp: A Multi-Agent System for Template-Based Generation of SysML v2

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

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

Pith's one-line read Inserting a rule-based template generator and a parser-feedback loop makes LLM-produced SysML v2 models syntactically valid in 4 of 5 tested scenarios, versus 1 of 5 without the template.

desk verdict A worthwhile niche system for NL-to-SysML v2, but the 'near-systematic convergence' claim rests on five single runs and needs a real evaluation before it can be believed. read the letter →

arxiv 2506.21608 v1 pith:USQTK4Q3 submitted 2025-06-20 cs.CL cs.AI

Yasmine Bouamra , Bruno Yun , Alexandre Poisson , Frédéric Armetta This is my paper · ORCID

classification cs.CLcs.AI

keywords SysMLv2multi-agentsystemtemplate-basedgenerationlargelanguagemodelsmodel-basedsystemsengineeringsyntaxvalidationfew-shotprompting

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

Auto-generating SysML v2 models from natural language is hard because the language is young, sparsely documented, and has a strict syntax. The paper proposes SysTemp, a multi-agent pipeline whose key addition is a TemplateGeneratorAgent that turns an LLM-extracted structured specification into a rule-based SysML v2 skeleton before a writer agent fills in details. A separate parser agent checks each draft and feeds error reports back to the writer. In an ablation on five bicycle-related scenarios, the template route produced parser-validated syntax in 4 of 5 cases, versus 1 of 5 without the template, with similar results for two closed-source LLMs. The finding offers a concrete recipe for making a low-resource formal language tractable: constrain the LLM with a validated syntactic scaffold and then repair iteratively.

What carries the argument

The TemplateGeneratorAgent is the component that carries the argument. It is an LLM-augmented tool: the LLM converts the extracted dictionary into the tool's expected signature, and a rule-based template then substitutes package, requirement, attribute, and constraint values into a fixed SysML v2 skeleton. Because the skeleton is produced by deterministic rules rather than by the LLM, the enclosing syntax is guaranteed before the writer begins; the LLM only fills in content. The ParserAgent then validates each completed draft against the formal grammar and returns location-tagged errors, which the WriterAgent uses to revise, forming a closed repair loop.

What would settle it

Run each of the five scenarios many times (for example, 20 repeated draws) with and without the TemplateGeneratorAgent, keeping the same iteration budget and parser, and check whether the with-template success rate stays clearly above the without-template success rate across repetitions; the claim collapses if the two conditions converge at comparable rates once variation is measured.

Watch

Extended reading notes

Core claim

The paper's central claim is that a rule-based template agent is the difference between failure and near-systematic success in LLM-generated SysML v2. Concretely, on five bicycle-related natural-language specifications, the full SysTemp pipeline (specification extraction into a structured dictionary, template-skeleton generation, writer completion, and parser feedback) ended with a parser-validated, syntactically correct model in 4 of 5 scenarios. Without the template agent, the same write-and-repair loop converged in only 1 of 5 scenarios. The two evaluated closed-source LLMs behaved similarly, with one showing a small average reduction in error count (about three fewer errors), which the paper does not treat as significant. The conclusion concerns syntax only: the parser certifies that the generated text conforms to the language grammar, not that the semantic content is correct.

Load-bearing premise

The comparison assumes that five single runs on the selected scenarios, without repeated trials or variance measures, are enough to attribute the 4-out-of-5 versus 1-out-of-5 gap to the template mechanism rather than to random variation or prompt differences.

Editorial extensions

If this is right

Generating a rule-based skeleton before asking the LLM to fill in details is enough to reach parser-valid syntax in 4 of 5 tested scenarios; without the skeleton the success rate drops to 1 of 5.
The benefit is not tied to a particular provider: both tested closed-source LLMs reach the same convergence rate, so the mechanism transfers across models.
The write-and-repair loop converges within the observed iteration budget when the skeleton is present, which means the ParserAgent's error reports are actionable enough for the writer to correct them.
The pipeline's explicit future applications include semantic refinement of generated values and synthetic data generation for this low-resource language, both of which become more feasible once syntax is reliably correct.

Reading between the lines

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

If the template effect holds at scale, the practical lesson for low-resource formal languages is to invert the usual prompting advice: rather than asking the model to produce the whole artifact, provide a grammar-derived scaffold and reduce the generative task to content filling.
The syntax-only success metric leaves open how much of the generated model is semantically faithful to the requirements; an immediate follow-up would be an automated check that each stated requirement appears as a requirement block with the intended property values.
Because the parser is the only piece that depends on SysML v2 specifically, the same orchestration should transfer to other formal languages simply by swapping the parser and the template rules; a cheap test would be to apply SysTemp unchanged to a second language with a small grammar.

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.

Desk Editor's Note

read the letter

Colleague,

Here's the quick read on arXiv:2506.21608. The new thing is narrow but real: the authors apply the familiar multi-agent code-generation recipe—specialized LLM agents plus parser feedback—to SysML v2 textual notation, and add a TemplateGeneratorAgent that produces a Jinja2-based skeleton so the LLM only fills in slots. That is a sensible way to tame a low-resource formal language, and the paper describes the architecture clearly enough to reimplement. The parser is the actual OMG Java parser, so the evaluation metric is objective, not the LLM grading its own output.

The problem is the evidence. Section 5 claims 'near-systematic convergence' on the strength of four out of five scenarios converging with the template agent and one out of five without. Those numbers come from a single run per scenario, two closed-source LLMs, no seeds, no temperature settings, and no repeated trials. A Fisher exact test on the 4/5 vs 1/5 table gives p around 0.10, so the gap is consistent with chance. The runs are also truncated at a fixed fifth iteration, so a baseline that would converge later is counted as a failure. No code or raw logs are released, so I can't check the counts. That is the load-bearing result, and it is too wobbly to carry the wording.

The milder concern is that both the correction loop and the evaluation use the same parser, which is slightly incestuous, but given that the grammar is an OMG standard this is more a limitation than a flaw. The bigger gap is semantic: the paper only measures syntax, and the conclusion acknowledges that the generated values haven't been checked for meaning. For MBSE practitioners, that leaves the practical value unproven.

None of this is fatal. The architecture is sensible, the paper is honest about being preliminary, and the authors explicitly list the missing pieces (benchmarks, semantic checks, variance). I would not desk reject this. It deserves a referee: it's a serious systems paper with a real parser-based metric, and the evaluation can be strengthened with more scenarios, repeated runs, and released code. I'd ask for those before acceptance.

For a reading group: it's a quick read if you work on LLM generation for formal languages, but it's a niche application, so maybe. I wouldn't cite it in my own work in the next year unless I moved into MBSE.

Recommendation: engage with it in peer review, but push for a real evaluation before publication.

Referee Report

4 major / 6 minor

Summary. The paper proposes SysTemp, a multi-agent pipeline for generating SysML v2 concrete syntax from natural language specifications. The pipeline consists of four agents: a SpecificationGeneratorAgent that extracts a structured Python dictionary, a TemplateGeneratorAgent that produces a syntactic skeleton using Jinja2 rules, a WriterAgent that completes the skeleton, and a ParserAgent that validates the output against the OMG SysML v2 grammar and returns error feedback. The main empirical claim is an ablation: with the TemplateGeneratorAgent, 4 out of 5 scenarios converge to error-free syntax at step 5, whereas without it only 1 out of 5 converges, which the paper calls 'near-systematic convergence'. The evaluation uses five bicycle-related scenarios and two commercial LLMs, GPT-4 Turbo and Claude 3.5 Sonnet.

Significance. The problem is relevant and the proposed direction is sensible: SysML v2 is a low-resource formal language with a complex, evolving syntax, and decomposing generation into specification extraction, template-based skeleton creation, and iterative parser feedback is a plausible way to improve reliability. The formalization of the agents in Section 3.1 is clear, and the use of an external OMG grammar as the validation oracle is a strength. Appendix B gives concrete templating rules, which helps reproducibility of the skeleton generation. However, the paper's central empirical claim is not supported by the evidence as presented. Five single-run scenarios, with no repeated trials, no variance measures, no statistical test, and a fixed five-iteration horizon, are insufficient to establish 'near-systematic convergence'. The gap between 4/5 and 1/5 is not statistically significant under a Fisher exact test (one-sided p approximately 0.10). The contribution is therefore best viewed as a promising preliminary system description rather than a validated method.

major comments (4)

[§5, Fig. 6] The central claim 'near-systematic convergence' rests on the reported difference 4/5 with the TemplateGeneratorAgent versus 1/5 without it, at a fixed fifth iteration. Section 3.1 explicitly models the LLM as a non-deterministic function f, yet no repeated runs, temperature settings, seeds, or per-model/per-scenario counts are reported. Under the natural reading of the counts as a 2x2 table, Fisher's exact test gives a one-sided p-value of approximately 0.10, which does not establish the claimed improvement. In addition, success is defined as error-free at step 5, so a baseline that would converge at step 6 is counted as a failure, making the comparison horizon-limited. Please provide repeated trials with variance, a proper statistical test, and either relax the claim to a preliminary observation or substantiate it with more data. Releasing the code and raw logs would also allow independent verification of the reported trajectories.
[§4.2 and §5] The manuscript does not give a per-model or per-scenario breakdown of the results. Section 4.2 states that two LLMs, GPT-4 Turbo and Claude 3.5 Sonnet, were selected, and Section 5 says that 'both models yield similar results' and that GPT-4 has on average three fewer errors. However, it is unclear whether the 4/5 and 1/5 figures are pooled across the two models, whether each scenario was run once per model or once total, and what the error trajectories look like for each model and scenario. Please provide a full data matrix (scenario x model x condition x iteration) and state precisely which numbers correspond to which configuration.
[§3.1.4 and §4.1] The ParserAgent serves both as the in-loop corrector and as the evaluation oracle. While the grammar is the external OMG SysML v2 standard and the parsing mechanism is implemented in Java, the parser tool P is not described in enough detail: it is not stated how syntax errors are counted (per token, per message, per location), nor whether the tool has been validated against a set of known-good and known-bad SysML v2 snippets. Since 'success' is defined as zero errors reported by P, a parser that under-reports errors would directly inflate the main result. Please characterize the parser's behavior and, if possible, report precision/recall on a small labeled set of SysML v2 fragments.
[§4.1 and §6] The evaluation measures only syntactic correctness, while the abstract and introduction frame the contribution as improving the 'quality of the generations'. The TemplateGeneratorAgent produces the skeleton deterministically via Jinja2, and the WriterAgent prompt in Table 3 instructs the model never to change the template's structure. Under these conditions, the ablation partly measures the benefit of constraining the output format. Without any semantic metric, human review of the five final models, or at least a requirements-coverage check, it is unclear whether the generated models satisfy the natural-language specifications. The paper itself acknowledges in Section 6 that semantics are not addressed; please add a qualitative assessment or explicitly narrow the claims to syntactic convergence.

minor comments (6)

[§1 and keywords] There are several typos and inconsistent terms: 'SysML v11' should likely be 'SysML v1', 'Engenieering' should be 'Engineering', and 'Pytthon' in Section 3 should be 'Python'.
[§4.2, §5, and reference [24]] Model naming is inconsistent: Section 4.2 says GPT-4 Turbo and Claude 3.5 Sonnet, Section 5 says GPT-4 and Claude Sonnet 3.5, and reference [24] is titled 'Introducing Claude 2.1'. Please align the model names and versions throughout.
[§3.1.1] The formula defining Ex has mismatched braces: 'Ex = concat({(D(i) NL, Dict(i))| i∈{ 1, . . . , k})' is missing a closing brace. Please correct the notation.
[Fig. 6 caption] The caption should describe the axes, the unit of the error count, and whether the plotted lines are per-scenario, per-model, or average trajectories. Currently the reader cannot tell what is aggregated in the figure.
[Appendix A] The prompts refer to a 'syntax_checker_agent' while the main text calls it ParserAgent; please unify the terminology. Also, the quotation marks around code fences in the prompt tables are inconsistent across Tables 2-5.
[§5] The sentence 'On average, three fewer errors but this difference is not substantial enough to warrant a significant distinction' is ambiguous: it should state which model has fewer errors, in which condition, and over how many scenarios this average is taken.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the multi-agent pipeline is evaluated against an external OMG grammar, and no fitted parameter or self-citation is used as the load-bearing derivation.

full rationale

The paper's central claim—that the TemplateGeneratorAgent plus ParserAgent feedback yields near-systematic syntactic convergence—is supported by an ablation, not by a derivation from the system's own definitions. The TemplateGeneratorAgent is defined (Section 3.1.2) as a deterministic Jinja2 rule-based tool that emits a syntactically valid skeleton; this makes part of the syntax improvement a design property rather than an empirical discovery, but the evaluated artifact is the WriterAgent-completed model after up to five ParserAgent iterations, and the WriterAgent is free as an LLM to introduce errors. The ParserAgent is both the in-loop corrector and the evaluation oracle, which is a mild self-reference in the evaluation protocol; however, the parser checks conformance to the OMG SysML v2 grammar (Section 3.1.4), an external standard, so the success criterion is not defined in terms of the system's own output. No parameter is fitted to a subset of the five scenarios and then 'predicted' on the remainder; no uniqueness theorem or load-bearing claim is imported solely from the authors' prior work. The author-maintained benchmark cited in footnote 4 motivates the problem but is not load-bearing for the convergence result. The absence of repeated trials and variance measures is a statistical robustness limitation, not a circularity. Under the hard rule requiring a specific reduction of a result to its inputs, no such reduction is exhibited.

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

The central claim relies mainly on domain assumptions about parser correctness, scenario representativeness, and the sufficiency of single-run LLM evaluations. No free parameters are fitted to data; the only hand-chosen hyperparameter is the few-shot count k=3, which is not tuned against the test set.

free parameters (1)

k (number of few-shot examples for WriterAgent) = 3
Chosen with reference to literature, not tuned on the test scenarios; affects generation quality but also introduces arbitrariness.

assumptions (4)

domain assumption The Java parser P accurately implements the OMG SysML v2 grammar and is the correct oracle for syntax errors.
The paper's entire metric depends on P, but P is not released or independently validated; the authors note the official parser does not describe errors, so their custom parser is central (Section 3.1.4).
domain assumption The five scenarios are representative of SysML v2 modeling tasks.
All scenarios describe bicycles or components, a narrow domain (Appendix C); no diversity in system types, scale, or requirement complexity.
domain assumption LLM outputs are stable enough that single runs per scenario support the comparison.
No repeated runs, seeds, or variance measures are reported; LLM sampling is nondeterministic (Sections 4-5).
domain assumption Syntactic validity, as judged by the parser, is a meaningful proxy for generation quality.
The paper explicitly restricts evaluation to syntax and acknowledges semantics are not assessed (Section 6).

how reviews work

0 comments

Cite this review

Pith. "Pith review of SysTemp: A Multi-Agent System for Template-Based Generation of SysML v2." pith.science (2026). https://pith.science/paper/USQTK4Q3

@misc{pith2026250621608,
  author       = {Pith},
  title        = {Pith review of: SysTemp: A Multi-Agent System for Template-Based Generation of SysML v2},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/USQTK4Q3}},
  note         = {Machine review of arXiv:2506.21608}
}

read the original abstract

The automatic generation of SysML v2 models represents a major challenge in the engineering of complex systems, particularly due to the scarcity of learning corpora and complex syntax. We present SysTemp, a system aimed at facilitating and improving the creation of SysML v2 models from natural language specifications. It is based on a multi-agent system, including a template generator that structures the generation process. We discuss the advantages and challenges of this system through an evaluation, highlighting its potential to improve the quality of the generations in SysML v2 modeling.

Figures

Figures reproduced from arXiv: 2506.21608 by the authors.

**Figure 2.** Example of abstract syntax (left) and concrete syntax (right) in SysML v2 – The abstract syntax is the [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗

**Figure 3.** SysTemp pipeline: SysML v2 generation via a multi-agent system. This growing interest in multi-agent orchestration for structured generation tasks extends beyond code to include system modeling. Maria Stella de Biase [23], for example, explores state machine generation through a refinement process that allows users to iteratively adjust solutions to their specifications. In this vein, our contribution introduces a m… view at source ↗

Figures from the paper (3 more)

**Figure 4.** Figure 4: Specification as Python dictionary obtained from [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]

**Figure 5.** Figure 5: Skeleton (in textual notation) for a BikeFork SysML v2 Specification. [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]

**Figure 6.** Figure 6: Evolution of the number of errors with and without the [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

29 extracted references · 21 canonical work pages

[1]

Survey of Model-Based Systems Engineering (MBSE) Methodologies

Jeff A Estefan. Survey of Model-Based Systems Engineering (MBSE) Methodologies. 2008

work page 2008
[2]

Inc. GitHub. Github copilot, 2025. Accessed: 2025-03-12. 8 SysTemp: A Multi-Agent System for Template-Based Generation of SysML v2

work page 2025
[3]

Adobe photoshop with ai, 2025

Adobe. Adobe photoshop with ai, 2025

work page 2025
[4]

Boosting large language model for speech synthesis: An empirical study, 2023

Hongkun Hao, Long Zhou, Shujie Liu, Jinyu Li, Shujie Hu, Rui Wang, and Furu Wei. Boosting large language model for speech synthesis: An empirical study, 2023

work page 2023
[5]

How good are llms for literary translation, really? literary translation evaluation with humans and llms, 2025

Ran Zhang, Wei Zhao, and Steffen Eger. How good are llms for literary translation, really? literary translation evaluation with humans and llms, 2025

work page 2025
[6]

A survey on large language models for code generation, 2024

Juyong Jiang, Fan Wang, Jiasi Shen, Sungju Kim, and Sunghun Kim. A survey on large language models for code generation, 2024

2024
[7]

Lei Huang and et al. Yu. A survey on hallucination in large language models: Principles, taxonomy, challenges, and open questions. ACM Transactions on Information Systems, 43(2):1–55, January 2025

work page 2025
[8]

Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, and Jared Kaplan et al

Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, and Jared Kaplan et al. Language models are few-shot learners, 2020

work page 2020

Show all 29 references

[9]

Evaluating large language models trained on code, 2021

Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, and Henrique Ponde de Oliveira Pinto et al. Evaluating large language models trained on code, 2021

2021
[10]

On the dangers of stochastic parrots: Can language models be too big? In Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency , pages 610–623, 2021

Emily M Bender and Gebru et al. On the dangers of stochastic parrots: Can language models be too big? In Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency , pages 610–623, 2021

2021
[11]

Task contamination: Language models may not be few-shot anymore, 2023

Changmao Li and Jeffrey Flanigan. Task contamination: Language models may not be few-shot anymore, 2023

2023
[12]

Gpt-4 technical report, 2023

OpenAI. Gpt-4 technical report, 2023

2023
[13]

Introducing llama 2: The next generation of our open source large language model, 2023

Meta AI. Introducing llama 2: The next generation of our open source large language model, 2023

2023
[14]

Announcing mistral 7b, 2023

Mistral AI. Announcing mistral 7b, 2023

2023
[15]

Gemma: Open models based on gemini research and technology, 2024

Gemma Team, Thomas Mesnard, and Cassidy Hardin et al. Gemma: Open models based on gemini research and technology, 2024

2024
[16]

Chawla, Olaf Wiest, and Xiangliang Zhang

Taicheng Guo, Xiuying Chen, Yaqi Wang, Ruidi Chang, Shichao Pei, Nitesh V . Chawla, Olaf Wiest, and Xiangliang Zhang. Large language model based multi-agents: A survey of progress and challenges, 2024

2024
[17]

Why does the effective context length of llms fall short?, 2024

Chenxin An, Jun Zhang, Ming Zhong, Lei Li, Shansan Gong, Yao Luo, Jingjing Xu, and Lingpeng Kong. Why does the effective context length of llms fall short?, 2024

2024
[18]

John K. Dehart. Leveraging large language models for direct interaction with sysml v2. ResearchGate, 2023

2023
[19]

Ashish Vaswani and et al. Shazeer. Multi-agent language models for low-resource language generation. In Proceedings of the 38th International Conference on Machine Learning (ICML 2021) , pages 1234–1245, 2021

2021
[20]

Qingyun Wu, Gagan Bansal, Jieyu Zhang, and et al. Wu. Autogen: Enabling next-gen llm applications via multi-agent conversation. arXiv preprint arXiv:2308.08155, 2023

2023 arXiv
[21]

Parshin Shojaee, Aneesh Jain, Sindhu Tipirneni, and Chandan K. Reddy. Execution-based code generation using deep reinforcement learning. arXiv preprint arXiv:2301.13816, 2023

2023 arXiv
[22]

Stepcoder: Amélioration de la génération de code avec l’apprentissage par renforcement à partir des retours du compilateur

Shihan Dou, Yan Liu, Haoxiang Jia, Limao Xiong, Enyu Zhou, and Shan et al. Stepcoder: Amélioration de la génération de code avec l’apprentissage par renforcement à partir des retours du compilateur. arXiv préprint arXiv:2402.01391, 2024

2024 arXiv
[23]

Towards automatic model completion: from requirements to sysml state machines, 2022

Maria Stella de Biase, Stefano Marrone, and Angelo Palladino. Towards automatic model completion: from requirements to sysml state machines, 2022

2022
[24]

Package" :

Anthropic. Introducing claude 2.1, 2023. 9 SysTemp: A Multi-Agent System for Template-Based Generation of SysML v2 A Agents prompts A.1 SpecificationGeneratorAgent System Prompt You are an extractor-generator agent. You take a description in natural language. You return a pyth...

2023
[25]

type " :

Mountain Bike Specification { " type " : " input " , " content " : " Write me a s p e c i f i c a t i o n for a mountain bike that has : - An aluminum frame that weighs less than 3 kg . - A frame with a p r o n o u n c e d sloping design . - A cassette with 9 cogs ranging from...
[26]

type " :

Electric Bike Specification { " type " : " input " , " content " : " Write me a s p e c i f i c a t i o n for an electric bike that has : - An aluminum hardtail frame suitable for light off - road use . - 27.5 - inch wheels . - A 380 Wh lithium battery . " }
[27]

type " :

Tire Specification { " type " : " input " , " content " : " Write a s p e c i f i c a t i o n for tires that must be knobby , sized 24 x1 .95 , and support pr es su re s between 2 and 3.5 bars . " }
[28]

type " :

Mountain Bike with Specific Drivetrain { " type " : " input " , " content " : " Write me a s p e c i f i c a t i o n for a mountain bike that meets the f ol lo wi ng r e q u i r e m e n t s : - The front s u s p e n s i o n must have 50 mm of travel to absorb terrain i r r e g...
[29]

type " :

Bicycle Fork Specification 13 SysTemp: A Multi-Agent System for Template-Based Generation of SysML v2 { " type " : " input " , " content " : " " " Write me a s p e c i f i c a t i o n for a bike fork made of aluminum with a 1\" 1/8 Aheadset pivot . " } 14

Pith tools

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

[1] [1]

Survey of Model-Based Systems Engineering (MBSE) Methodologies

Jeff A Estefan. Survey of Model-Based Systems Engineering (MBSE) Methodologies. 2008

work page 2008

[2] [2]

Inc. GitHub. Github copilot, 2025. Accessed: 2025-03-12. 8 SysTemp: A Multi-Agent System for Template-Based Generation of SysML v2

work page 2025

[3] [3]

Adobe photoshop with ai, 2025

Adobe. Adobe photoshop with ai, 2025

work page 2025

[4] [4]

Boosting large language model for speech synthesis: An empirical study, 2023

Hongkun Hao, Long Zhou, Shujie Liu, Jinyu Li, Shujie Hu, Rui Wang, and Furu Wei. Boosting large language model for speech synthesis: An empirical study, 2023

work page 2023

[5] [5]

How good are llms for literary translation, really? literary translation evaluation with humans and llms, 2025

Ran Zhang, Wei Zhao, and Steffen Eger. How good are llms for literary translation, really? literary translation evaluation with humans and llms, 2025

work page 2025

[6] [6]

A survey on large language models for code generation, 2024

Juyong Jiang, Fan Wang, Jiasi Shen, Sungju Kim, and Sunghun Kim. A survey on large language models for code generation, 2024

2024

[7] [7]

Lei Huang and et al. Yu. A survey on hallucination in large language models: Principles, taxonomy, challenges, and open questions. ACM Transactions on Information Systems, 43(2):1–55, January 2025

work page 2025

[8] [8]

Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, and Jared Kaplan et al

Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, and Jared Kaplan et al. Language models are few-shot learners, 2020

work page 2020