SysTemp: A Multi-Agent System for Template-Based Generation of SysML v2
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.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
What is this paper about?
This paper introduces SysTemp, an AI “team” that helps engineers turn plain-English descriptions of a system (like a bike or a battery) into a formal computer-friendly description called a SysML v2 model. Think of SysML v2 like a precise, standardized way to write the blueprint of a complex system so computers and people can understand and build it correctly.
What questions did the researchers ask?
In simple terms, they wondered:
- How can we help engineers write correct SysML v2 code when the language is new, examples are rare, and the rules are tricky?
- Can a team of AI helpers—each with a different role—do better than a single AI trying to write everything at once?
- Does starting with a good “template” (a clean outline or skeleton) make the final code more correct and faster to fix?
How did they do it?
The problem, in everyday words
- Engineers are moving from scattered documents to model-based designs (MBSE), where everything is captured in a single, connected model.
- SysML v2 is a new modeling language with a text-based format, but it’s still evolving and there are very few good examples to learn from.
- Big AIs (LLMs) are good at writing text and code, but they struggle when the topic is super specific and there isn’t much training data—like SysML v2.
The idea: a team of AI helpers
Imagine you’re building a school project with friends, and each friend has a role:
- One friend pulls out the main points from the teacher’s instructions.
- Another creates a clean outline.
- A third writes the full draft.
- A fourth checks grammar and points out exactly what’s wrong.
SysTemp does the same with four AI “agents”:
- SpecificationGeneratorAgent: reads the natural-language description and turns it into a neat list of requirements (like a checklist in a simple dictionary format).
- TemplateGeneratorAgent: builds a correct SysML v2 skeleton—a clean outline with the right structure and headings.
- WriterAgent: fills in the details to make a complete SysML v2 model.
- ParserAgent: acts like a strict grammar checker for code, finds syntax mistakes, and tells the WriterAgent what to fix.
Step-by-step: how the team works
Here is the general flow the system follows:
- The user writes a description in plain English (for example, “a mountain bike with a lightweight aluminum frame and 9 gears”).
- The SpecificationGeneratorAgent turns that into a structured checklist.
- The TemplateGeneratorAgent turns the checklist into a correct SysML v2 outline (the “skeleton”).
- The WriterAgent fills in the outline with parts, attributes, and details.
- The ParserAgent checks the code for syntax errors (like missing brackets or wrong keywords) and reports them.
- The WriterAgent fixes the code using that feedback, repeating until the model is error-free or stops improving.
This “loop” is like drafting, proofreading, and revising an essay until it passes the teacher’s checks.
What did they find, and why is it important?
The researchers tested SysTemp on five small scenarios about bicycles (like mountain bikes, electric bikes, tires, and forks). They compared two setups:
- With the TemplateGeneratorAgent (using the skeleton first)
- Without the TemplateGeneratorAgent (jumping straight to full code)
They used two strong AI models (GPT-4 Turbo and Claude 3.5 Sonnet) and measured how many syntax errors remained at each step.
Key results:
- With the template (skeleton), the system produced syntactically correct SysML v2 in 4 out of 5 cases (80%).
- Without the template, it got a clean result in only 1 out of 5 cases.
- Both AI models performed similarly; GPT-4 had slightly fewer errors on average, but not by a big margin.
Why this matters:
- Starting with a good outline helps the AI stay organized, make fewer mistakes, and finish faster—just like writing an essay with a solid outline.
- This makes it easier for engineers to use SysML v2, even though the language is still new and complex.
What’s the impact, and what could come next?
This work shows a practical way to use AI to help with specialized, low-data tasks: split the work among specialized helpers, start from a clean template, and use a strict checker to guide fixes. In the near term, this could:
- Speed up how engineers create correct SysML v2 models
- Reduce frustrating syntax errors
- Make model-based design more accessible
For the future, the authors suggest:
- Checking not just syntax (is it written correctly?) but also semantics (does it mean the right thing?).
- Building better benchmarks to fairly measure quality.
- Adding expert knowledge (like ontologies or knowledge graphs) so the AI can make smarter choices.
- Using the system to create synthetic training data, which could help the AI learn SysML v2 better.
- Extending the approach to other technical languages with few examples.
In short: SysTemp shows that a coordinated team of AI agents, guided by a strong template and a reliable checker, can make writing complex system models simpler, faster, and more accurate.
Collections
Sign up for free to add this paper to one or more collections.