betaFeedback

WorksComputer Science

From Language-Specific to Cross-DSL: Semantic-Role-Guided Model Completion with LLMs

Abstract

The rapid emergence of large language models (LLMs), trained on vast and diverse corpora, has positioned them as a promising source of domain knowledge to assist modelers. However, leveraging LLMs for model completion remains challenging: suggestions must respect both the syntax of a domain-specific language (DSL) and the intended domain semantics, while remaining consistent with an evolving model. This paper presents RAFiC, an LLM-based approach for iterative domain model completion that generalizes across DSLs. It drives completion using metamodel information to ensure syntactic validity and enriches prompts with semantic-role annotations to better capture the intended modeling role of DSL elements. The approach provides context-aware, incremental guidance during model construction. We evaluate RAFiC through an ablation-based comparative study over three DSLs and two scenarios per DSL to isolate the contribution of syntactic and semantic guidance. Across these six scenarios, semantic role guidance improves contribution rate in every case, and RAFiC improves completion effectiveness over weaker prompting configurations in most of them. The largest gains occur for DSLs that are less represented in LLM training data. In these cases, iterative guidance leads to earlier and more stable accepted suggestions, while semantic role guidance improves their relevance.

CCS Concepts: • Software and its engineering → Model-driven software engineering; Domain specific languages; • Human-centered computing → Interaction design process and methods.

Introduction

Domain modeling plays a central role in software and systems engineering by providing structured representations of domain concepts [8]. In Model-Driven Engineering (MDE), this is achieved through modeling languages, where a metamodel defines the abstract syntax and a concrete syntax provides notations for creating instance models [15, 21, 28, 38]. This process, however, is far from straightforward: Domain modeling is a challenging, time-consuming, and error-prone activity. One of its main difficulties lies in defining the boundaries of the domain to be modeled. Modelers

Authors’ Contact Information: Meriem Ben Chaaben, DIRO, Université de Montréal, Montréal, Canada, [email protected]; Théo Giraudet, Obeo, Univ Rennes, Inria, CNRS, IRISA, , France, [email protected]; Benoit Combemale, Univ Rennes, Inria, CNRS, IRISA, , France, [email protected]; Houari Sahraoui, DIRO, Université de Montréal, Montréal, Canada, [email protected].

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected].

© 2026 Copyright held by the owner/author(s). Publication rights licensed to ACM.

ACM XXXX-XXXX/2026/11-ART1

https://doi.org/

, Vol. 1, No. 1, Article 1. Publication date: November 2026. must determine which concepts belong to the domain, how they relate to one another, and which relevant concepts or relationships may have been overlooked. Missing or incomplete domain knowledge at this stage can propagate throughout the development process, leading to models that inadequately capture the intended system. This motivates domain model completion as a form of interactive assistance in software engineering processes [41]. Rather than generating an entire model from scratch, completion support helps modelers progressively define and refine the model by recommending candidate concepts, relationships, and refinements that can be inspected, accepted, rejected, or adapted. Such assistance reduces the risk of omitting important domain elements and relationships while leaving the final modeling decisions under the control of the modeler. Importantly, completion is inherently incremental: each modeling decision changes the state of the model and, consequently, what may be relevant to suggest next.

The assistance therefore requires mechanisms that can reason about both the modeling language and the evolving modeling context. Recent advances in large language models (LLMs), trained on vast corpora, make this perspective increasingly feasible, as they have shown promising capabilities in supporting software engineering tasks, including modeling assistance [5, 14, 43]. By providing context-sensitive suggestions during model construction, LLMs offer new opportunities to assist modelers, particularly when the model is incomplete or created by practitioners with different levels of modeling expertise. However, effective domain model completion cannot rely solely on the generative capabilities of LLMs. Although LLMs have accumulated extensive knowledge about many application domains, they are generally unfamiliar with the domain-specific modeling languages (DSLs) used to represent this knowledge. Recent work has shown that LLMs exhibit weaker performance on low-resource programming languages due to their limited representation in pretraining corpora [16]. The challenge is even greater for DSLs, which are rarely encountered during pretraining. Consequently, although an LLM may understand domain concepts and their relationships, it may not know how these concepts are represented in a particular DSL, nor infer the intended modeling role of its constructs. It may therefore generate suggestions that are plausible at the domain level but incompatible with the structure or intended use of the modeling language.

This observation points to a more general challenge: how can an LLM perform model completion when the language used to express the domain may be unfamiliar to it, while the model itself is continuously evolving? A completion mechanism must communicate to the LLM not only the current state of the partial model, but also the structural and semantic knowledge needed to interpret that model. Moreover, this information cannot be provided only once: as the model changes through accepted suggestions or manual edits, the context used to generate subsequent suggestions must evolve accordingly.

We address this challenge by viewing LLM-based model completion as an iterative communication process between the modeling environment and the LLM. At each modeling step, the LLM receives three complementary sources of information: (i) the structural constraints of the target DSL, captured by its metamodel; (ii) semantic guidance describing the intended modeling roles of DSL constructs; and (iii) the current state of the partial model under construction. The LLM then generates candidate completions, which are presented to the modeler. Once a suggestion is accepted or the model is otherwise modified, the resulting model state becomes part of the context for the next completion step. This closed loop allows suggestions to adapt to both the language and the evolving model rather than treating completion as a sequence of independent generation requests.

To provide semantic guidance across heterogeneous DSLs, we use a lightweight semantic annotation scheme that associates DSL constructs with generic modeling roles. Such annotations provide explicit cues about the intended modeling function of constructs beyond their DSL-specific names, allowing domain knowledge captured by an LLM to be connected to the abstractions of an unfamiliar modeling language. Unlike approaches that rely on a fixed prompt or provide guidance only once [12, 19], our approach continuously combines this syntactic and semantic language knowledge with the dynamically evolving model context.

More concretely, we propose RAFiC (Recommender for AI-assisted Framework for domaIn model Completion), an LLM-based approach for iterative domain model completion across DSLs. RAFiC realizes this iterative communication process by combining metamodel-driven structural guidance, semantic-role guidance, and context-aware orchestration. The metamodel and semantic annotations provide reusable knowledge about the target DSL, while the evolving model provides the context that is updated throughout the interaction. This combination enables RAFiC to generate completion suggestions that are adapted both to the modeling language and to the current state of the model. RAFiC is designed as an assistance layer integrated into a graphical modeling environment. The resulting mechanism is intended to generalize across DSLs without requiring the LLM itself to have been trained on each target language. Only the DSL-specific metamodel and the mapping between its constructs and the semantic annotation scheme need to be provided as static language knowledge. This enables the same completion mechanism to operate across modeling languages while adapting its recommendations to the specific structure, semantics, and current state of each model.

We evaluate RAFiC through an ablation-based comparative study over three DSLs and two scenarios per DSL, selected to differ in their expected presence in LLM pretraining data. Within these six scenarios, semantic role guidance improves contribution rate in every case, and RAFiC improves completion effectiveness over weaker prompting configurations in most of them, with the largest gains observed for less familiar DSLs where both iterative guidance and semantic role guidance contribute most.

Contributions.

  • We propose RAFiC, an LLM-based approach for iterative domain model completion that combines metamodel-driven structural constraints with semantic annotations of modeling constructs.

  • We introduce a cross-DSL semantic guidance mechanism that maps DSL-specific metamodel elements to generic semantic roles, allowing semantic information to be reused across heterogeneous modeling languages without requiring the LLM to have prior familiarity with each DSL.

  • We provide an extensive evaluation through targeted comparisons and ablations over three DSLs and two scenarios per DSL, demonstrating the benefits of iterative guidance over minimal and static prompting, and quantifying the contribution of semantic annotations to completion quality.

  • We implement RAFiC as a proof-of-concept tool integrated into Sirius Web, enabling interactive domain model completion within a web-based modeling environment.

The remainder of the paper is organized as follows. § 2 presents the necessary background. § 3 introduces RAFiC, detailing its main components and its implementation as a proof of concept. § 6 describes the study design, and § 8 reports the results. § 9 discusses the main observations and implications of our approach. § 10 discusses threats to the validity of our work. § 11 positions RAFiC with respect to related work, and § 12 concludes the paper.

Background

This section introduces the core concepts underlying our approach: modeling languages and their structure, semantic annotation in Model-Driven Engineering, domain model completion as a task, and the use of LLMs for generative assistance.

Core Concepts of Modeling Languages. Modeling languages, whether general-purpose or domain-specific, are typically defined through a structured process. This process begins with defining a metamodel, which serves as an abstract specification of the modeling language. The metamodel describes the essential concepts, relationships, and structural constraints that govern valid model instances [38] and acts as a blueprint for constructing models within the domain. Once the metamodel is established, a concrete syntax provides a representation for expressing models, either graphical (e.g., UML diagrams) or textual (e.g., DSLs using formal grammar) [21], enabling domain experts to create and manipulate models.

Finally, the modeling framework is enriched with semantics and constraints to ensure that models are meaningful and valid. Semantics define the interpretation and behavior of model elements [28], while constraints enforce consistency and correctness, often using languages such as OCL [39] or embedded validation mechanisms within the DSL. By structuring modeling languages around metamodels, concrete syntax, and explicit semantics, software engineers can create robust and reusable models that enhance automation, analysis, and verification in Model-Driven Engineering workflows.

Semantic Annotation in Model-Driven Engineering. Semantic annotation is a widely used mechanism in Model-Driven Engineering for making the meaning of model and metamodel elements explicit beyond what their structural definition conveys.

This idea has been applied across several MDE tasks. In business process modeling (BPMN), Lautenbacher et al. [32] annotate process elements such as tasks, roles, and data objects with domain and ontology concepts to make process semantics explicit and support automated validation, while Di Martino et al. [17] review and extend methodologies for annotating BPMN process models to support process comparison, retrieval, and reuse across organizations. In conceptual modeling, the TwoUse approach [37] annotates UML classes and properties with OWL DL axioms so that object-oriented modeling and description-logic reasoning can operate over the same artifact. Finally, Keet and Fillottrani [30] annotate the constructs of UML class diagrams, EER, and ORM2 with a shared set of ontological categories to enable comparison and translation across these otherwise incompatible notations.

Across these works, semantic annotation acts as a lightweight, tool-supported layer that complements the metamodel by making the intended role of its elements explicit and machine-usable, without requiring the modeling language itself to be redefined. We build on this same principle, but apply it to a task not addressed by prior work: guiding an LLM through the iterative completion of a partial model, using a small, DSL-independent set of semantic roles which we call a semantic annotation scheme.

Domain Model completion. Model completion is the task of extending a partial model with new elements that are properly integrated into it, so that the result is well-formed with respect to its metamodel [41]. The task has since been extended toward automation, generating completions with little or no manual specification effort from the modeler [42], and toward recommendation, ranking or suggesting candidate completions for the modeler to accept or discard rather than generating a single deterministic result [31]. In domain model completion, the partial model describes an application domain, so well-formedness is not enough: completions must also enrich it with relevant domain-specific vocabulary and concepts. More recently, the recommendation view has been combined with natural-language processing to autocomplete partial domain models directly from textual descriptions [9], and with few-shot prompting of large language models to automate completion without task-specific training [12].

Beyond filling gaps, completion also involves deciding what to do next during interactive modeling: which element to introduce, where to place it, and how it should connect to existing parts of the model [48].

Generative AI and LLMs. In recent years, the Natural Language Processing (NLP) domain has dramatically evolved, largely driven by the emergence of large language models (LLMs). These models use deep neural networks, typically based on transformer architecture [45], and are pretrained on vast textual data to capture human-generated knowledge for generative tasks [35]. Their human-like outputs stem from learning statistical regularities in language [29].

LLMs have been used across the software development lifecycle, from requirements engineering [40] to architecture [2] and testing [25], as well as for organizing software engineering knowledge [44]. In some cases, they require fine-tuning to adapt to specific tasks [33], although this can be computationally expensive and limited by data availability.

Thanks to large-scale pre-training, In-Context Learning (ICL) enables LLMs to adapt at inference time through prompting [18]. Prompting strategies specify task instructions and expected outputs, optionally with examples. Compared to fine-tuning, this lightweight adaptation requires less effort and can be combined with parameter tuning (e.g., temperature, top-pp) and iterative prompt refinement [49, 52].

A practical distinction concerns the deployment model of LLMs. Commercial models such as GPT-4 [1] offer strong generative capabilities but require sending data to external cloud services, which raises concerns regarding data privacy, confidentiality, and reproducibility in industrial and research settings. Open-source models such as LLaMA [24] and Qwen3 [51], which provides a family of models of different sizes, can be deployed locally, giving organizations full control over their data and infrastructure. Although open-source models may have narrower prior knowledge than their commercial counterparts, this gap can be mitigated through explicit guidance mechanisms, as explored in this work.

Approach

Our approach addresses domain model completion by combining three complementary mechanisms. First, it relies on a set of static artifacts that capture both the structural constraints of the target DSL and the semantic roles of its modeling elements. Second, it distinguishes between three types of modeling actions, each requiring a different prompting strategy. Third, it orchestrates these elements through a scoring mechanism that adapts to the evolving model state. The following subsections present an overview of the architecture, the modeling setup and semantic annotation required for each DSL, the orchestration engine that drives candidate selection, and the tool integration into Sirius Web.

Overview

Domain model completion has traditionally been studied for specific modeling formalisms, such as UML class diagrams [12] or goal-oriented models [13], where completion mechanisms are tightly coupled to a particular language and its constraints. In contrast, our approach is designed to generalize across modeling formalisms, e.g., UML, SysML-V2 with its different versions, etc. We realize our approach in RAFiC (Recommender for AI-assisted Framework for domain model Completion), an implementation built on top of Sirius Web, an open-source web-based language workbench that enables interactive and incremental modeling. RAFiC operationalizes the approach by integrating LLM-generated suggestions into the modeling environment and orchestrating their generation as the model evolves. It iteratively proposes extensions to the model

Modeling Setup

under construction while leveraging the DSL’s structural and semantic information to guide and constrain the completion process.

Artifacts and preparation. The approach relies on a set of artifacts, summarized in Table 1 and illustrated in Figure 1. These artifacts are configured once for each DSL and then reused across modeling sessions. The metamodel and concrete syntax are provided by the language designer, as in a standard language workbench setup. The semantic annotation scheme is a lightweight scheme provided by RAFiC that associates metamodel elements with generic modeling functions (e.g., process, goal, or resource). The language designer, possibly with support from domain experts, then defines the role-metamodel mapping by associating DSL concepts and relations with the corresponding categories of the annotation scheme.

ArtifactCategoryRole
MetamodelStatic guidance inputDefines the language structure and constraints; guides prompts, scoring, and validation.
Role-Metamodel mappingStatic guidance inputLinks metamodel elements and semantic annotation categories; guides semantic suggestion and prioritization.
Concrete syntaxStatic editor configurationDefines how the solution is written and displayed in the editor; not used in prompts.
Evolving solutionRuntime artifactCurrent model; updated after accepted suggestions or manual edits.
User feedbackRuntime artifactAccept/reject decisions and manual changes.
SuggestionsRuntime outputCandidate model extensions proposed at each iteration.

Table 1. Static configuration inputs and runtime artifacts used by RAFiC.

Overview of RAFiC showing the interaction between static knowledge, dynamic orchestration, and user feedback in the iterative completion loop

Figure 1. Overview of RAFiC showing the interaction between static knowledge, dynamic orchestration, and user feedback in the iterative completion loop.

The metamodel and role-metamodel mapping constitute the static guidance used during completion. The former captures the structural constraints of the DSL, while the latter provides semantic guidance by linking its constructs to their intended modeling roles. Together, they support prompt instantiation, candidate prioritization, and conformance checking. The concrete syntax serves a different purpose: it defines how models are represented and manipulated in the editor and is therefore not included as prompt content.

Iterative completion loop. During execution, RAFiC operates over an evolving solution, which may initially be empty or partial and is updated whenever the user accepts a suggestion or manually adds an element. At each iteration, the orchestration engine analyzes the current model, identifies structural and semantic gaps, and selects the most relevant candidate completions. It then instantiates a prompt tailored to the selected gap and sends it to the LLM. The generated suggestions are presented to the user, who may accept or reject them. Accepted suggestions update the model; rejected suggestions are discarded but may influence subsequent scoring through updated context. To keep suggestions focused, the engine distinguishes between three types of modeling actions: architectural (ARCH), for introducing new concepts; relational (REL), for connecting existing ones; and characteristic (CHAR), for enriching them with attributes, labels, or constraints. The same three types also drive prompt instantiation, each with its own family of templates (§ 4.3).

Modeling Setup

This section describes the preparation required to apply RAFiC to a new DSL. We first introduce a running example, then detail the required artifacts: metamodel, concrete syntax, semantic annotation scheme, and role-metamodel mapping.

Running example: We use a compact “Ticketing DSL” to model how support requests are taken from intake to resolution (Figure 2a, Figure 2b, and Figure 2c), and refer back to it throughout the following subsections. Tickets are progressed through a structured workflow of steps, carried out by responsible roles and accompanied by evidence or outputs. Figure 2a shows a minimal Ticketing metamodel in which a Workflow contains Steps, Roles perform Steps, a Ticket can be resolved by a Workflow, and Steps may use or produce Artifacts. A Ticket is also reported by a Role, may be assigned to a Role, and may attach Artifacts as evidence. Figure 2b gives one notation per metamodel class and reference. Figure 2c shows a model under construction: T-102, T-103 and the step Documentation are not yet connected, and the highlighted Workflow name, Standard Resolution, is a suggestion accepted by the user.

Ticketing DSL metamodel, concrete syntax, and example instance

Figure 2. Ticketing DSL: (a) metamodel, (b) concrete syntax, and (c) example instance.

Metamodel and concrete syntax

Before using RAFiC, the language designer defines the DSL-specific artifacts introduced in § 3.1, starting with the DSL metamodel and its concrete syntax. The metamodel specifies the abstract syntax of the language, including modeling concepts, relations, containment rules, and constraints. Following standard practice in metamodeling frameworks such as Ecore, the metamodel itself is expressed as a class diagram containing classes, attributes, and references, independently of whichever concrete syntax the DSL uses to display its instance models. RAFiC uses the metamodel artifacts as a structural source for prompt instantiation, candidate prioritization, and conformance checking. The concrete syntax defines how models are written, displayed, and manipulated in the editor. It supports user interaction in the modeling workbench, but is not used as prompt content for generating suggestions.

Semantic-annotation scheme definition

The semantic annotation scheme is defined once as part of the RAFiC framework and can be reused across different DSLs. Only the role-metamodel mapping, described below, is DSL-specific. The design of this scheme was motivated by the observation that many modeling languages, despite their syntactic differences, share recurring conceptual roles: elements that represent processes, resources, actors, goals, constraints, or structural containers. Several of these roles have direct precedent in the literature; for instance, Process corresponds to a formal category in the foundational ontology DOLCE [22], Role is a signature category of the Unified Foundational Ontology (UFO) [26, 27], and Thing is a primitive construct of the Bunge–Wand–Weber (BWW) ontology for information systems [47]. Importantly, the purpose of this scheme is not to define a universal formal semantics for modeling languages. Rather, it provides lightweight semantic hints that help the LLM interpret the intended role of a language construct and connect it to the general meaning of domain concepts acquired during pretraining. By making this connection explicit, the annotations help bridge the gap between the domain knowledge that an LLM may possess and the language-specific constructs used to express that knowledge in a model.

We defined the semantic-annotation scheme using an iterative refinement process. We began by collecting metamodels from several modeling languages, ranging from general-purpose notations such as UML class diagrams, SysML, goal models, ER diagrams, and state machines, to more narrowly scoped domain-specific languages studied in prior work, such as WebDSL for web application development [46] and a visual DSL for elevator controllers [50]. Then, we identified recurring modeling roles independently of their DSL-specific names. For instance, concepts that described elements acting or unfolding over time, such as activities and behaviors were grouped under a single Process role; resource- and structure-oriented concepts were grouped under Thing; agent-oriented concepts under Role; and objective- or requirement-oriented concepts under Goal. Concepts that did not recur across the DSLs we examined, or that were too fine-grained to be useful for prompt construction, were dropped. We repeated this process iteratively, refining the candidate set at each pass, until the retained categories, such as Process, Thing, Role, and Goal, consistently captured the concepts we encountered. Relations were derived the same way, keeping only those that expressed a recurring semantic link useful for completion, such as composition, participation, use/production, achievement, or constraint. The resulting scheme was collaboratively reviewed by the four authors, who checked whether its categories and relations could capture the intended roles of the DSL concepts considered in our case studies and additional DSL examples explored during design.

Figure 3 shows the resulting structure. A Root element, with a domain attribute, contains all role concepts, and every category specializes the abstract type RoleConcept. Its isAbstract boolean attribute lets a category be kept abstract or refined into a concrete one depending on the target DSL; for example, in SysML v2, some concepts are kept abstract to reflect the distinction between definitions and usages. The scheme is thus a flexible semantic framework rather than a fixed hierarchy.

Semantic annotation scheme used to annotate metamodel elements with their intended modeling role.

Figure 3. Semantic annotation scheme used to annotate metamodel elements with their intended modeling role.

The scheme acts as a lightweight semantic annotation layer: it enriches the prompts given to the LLM, supports candidate prioritization, and guides action selection, allowing RAFIC to communicate the intended modeling role of a DSL element rather than relying only on its name. For example, if a DSL element Ticket is mapped to Goal, the prompt can frame it as an objective or issue to be resolved; if Step is mapped to Process, the prompt can frame it as an action contributing to that resolution.

Role-metamodel mapping

After the semantic annotation scheme is available, the language designer defines a role-metamodel mapping, which links metamodel elements, and when relevant relation pairs, to concepts and relations from the annotation scheme. As noted in the overview section 3.1, this mapping is created once per DSL during language setup and reused across modeling sessions. It can be performed by the language designer alone, or with support from domain experts when the semantics of the DSL concepts require domain-specific interpretation.

The mapping follows a simple procedure. First, each metamodel class is assigned to the closest annotation category according to its role in the model. For instance, classes representing actions, workflows, behaviors, or states of progress are mapped to Process; classes representing resources, documents, data, or physical objects are mapped to Thing; classes representing actors, responsibilities, or organizational units are mapped to Role; and classes representing objectives, requirements, issues, or desired outcomes are mapped to Goal. Second, metamodel references are mapped to annotation relations according to their intended meaning, such as participation, use/production, composition, achievement, or constraint.

Example applied to the Ticketing metamodel. We denote by M\mathcal{M} the role-metamodel mapping, a function from metamodel symbols to annotation-scheme categories and relations: M:Σmeta→Σrole\mathcal{M} : \Sigma_{\mathrm{meta}} \to\Sigma_{\mathrm{role}}.

We overload M\mathcal{M} for both concepts and relations, preserving the argument structure: binary relations map to binary annotation relations, and unary concepts map to unary annotation categories. For the Ticketing DSL example, all mapped annotation elements are concrete, i.e., their attribute isAbstract is set to false. The mapping used in the running example is summarized below:

M(Workflow)↦ProcessM(contains)↦structural compositionM(Step)↦ProcessM(performs)↦participationM(Role)↦RoleM(uses)↦use/productionM(Artifact)↦ThingM(produces)↦use/productionM(Ticket)↦GoalM(resolvedBy)↦achievement\begin{aligned} \mathcal{M}(\mathrm{Workflow}) &\mapsto\mathit{Process} & \mathcal{M}(\mathrm{contains}) &\mapsto\mathit{structural\ composition} \\ \mathcal{M}(\mathrm{Step}) &\mapsto\mathit{Process} & \mathcal{M}(\mathrm{performs}) &\mapsto\mathit{participation} \\ \mathcal{M}(\mathrm{Role}) &\mapsto\mathit{Role} & \mathcal{M}(\mathrm{uses}) &\mapsto\mathit{use/production} \\ \mathcal{M}(\mathrm{Artifact}) &\mapsto\mathit{Thing} & \mathcal{M}(\mathrm{produces}) &\mapsto\mathit{use/production} \\ \mathcal{M}(\mathrm{Ticket}) &\mapsto\mathit{Goal} & \mathcal{M}(\mathrm{resolvedBy}) &\mapsto\mathit{achievement} \end{aligned}

The role-metamodel mapping narrows the completion space and specializes prompts for likely next steps. The orchestration engine, described next, uses these artifacts at each iteration to score candidates and select the most relevant completions. References without a mapped role (e.g., reports) are handled by the structural scores only.

Orchestration Engine

Let MtM_t denote the model at iteration tt, where M0M_0 is the initial partial model. At each iteration, the system constructs a set of candidate completions C(Mt)C(M_t), where each candidate c∈C(Mt)c \in C(M_t) corresponds to a possible modeling action. Each candidate is assigned a score S(c)S(c) reflecting its relevance in the current context. The engine selects the top-KK candidates and instantiates them into prompts. Accepted candidates update the model: Mt+1=Mt∪{c}M_{t+1} = M_t \cup\{c\}. The remainder of this section details how candidates are scored (§ 4.3.1), how the top-KK are dispatched (§ 4.3.2), and how prompts are constructed from three distinct action families (Section 3.3.3).

Candidate scoring

Each candidate receives a composite score:

S(c)=Smetamodel(c)+Scanvas(c)+Ssemantic(c)S(c) = S_{\mathrm{metamodel}}(c) + S_{\mathrm{canvas}}(c) + S_{\mathrm{semantic}}(c)

The scoring components use fixed heuristic weights in our prototype. They are not claimed to be optimal; rather, they encode simple modeling priorities, such as introducing structurally central elements, repairing missing relations, and favoring semantically meaningful completions. We describe each component below.

(1) SmetamodelS_{\mathrm{metamodel}}: structural prior and entrypoints. The prior Smetamodel(c)S_{\mathrm{metamodel}}(c) ranks candidates using only the metamodel, independently of the current canvas or role annotations. It highlights actions that the language makes structurally important, such as introducing central elements, establishing required relations, or completing mandatory characteristics. We compute this score using simple fixed heuristics (Table 2), which provide a first ranking before any context-specific adjustment. It also identifies a small set of entrypoints, Eentry=TopK⁡cSmetamodel(c)\mathcal{E}_{\mathrm{entry}} = \operatorname{TopK}_{c} S_{\mathrm{metamodel}}(c), which correspond to modeling actions that should be introduced early. If the canvas still lacks enough instances of these entrypoints, selection is temporarily biased toward them until this initial backbone is established. In the Ticketing running example, the resulting scores rank Ticket highest (Table 3). This makes it natural to start from Tickets, before refining Steps, Artifacts, Roles, and Workflows.

Entrypoint scoring heuristics
Containment+5 per containment
Outgoing ref.+2 each
Incoming ref.+1 each
“Many” rel.+3 each

Table 2. Scoring rules.

EntityCont.InOutManyTotal
Ticket0+1+6+1219
Step0+1+4+1217
Artifact0+30+912
Role0+1+4+611
Workflow+5+1006

Table 3. Top-KK entrypoint elements for the Ticketing example, ranked by SmetamodelS_{\mathrm{metamodel}}.

(2) ScanvasS_{\mathrm{canvas}}: canvas-aware adjustment. As the model evolves, Scanvas(c)S_{\mathrm{canvas}}(c) adjusts this initial ranking according to what is already present on the canvas. It raises candidates whose surrounding structural obligations are still unmet, such as missing relations, incomplete local neighborhoods, or pending characteristics. Prioritization therefore reflects both the metamodel and the current gaps of the partial model.

(3) SsemanticS_{\mathrm{semantic}}: Semantic-aware prioritization. Ssemantic(c)S_{\mathrm{semantic}}(c) uses the role-metamodel mapping M\mathcal{M} to favor semantically meaningful completions. It promotes candidates that match important semantic schema patterns, such as Process-Role, Process-Thing, and Goal-Process. Using these patterns, RAFiC detects missing relations and proposes semantically appropriate completions. For example, if a Step lacks a resource, the system may propose: Step →uses\xrightarrow{\mathrm{uses}} Artifact.

If a Ticket is unresolved, the system may propose: Ticket →resolvedBy\xrightarrow{\mathrm{resolvedBy}} Workflow and then suggest an initial Step toward resolution. By contrast, purely structural ARCH suggestions that do not support participation, resource use, or goal achievement are down-weighted. Table 4 illustrates the combined effect of ScanvasS_{\mathrm{canvas}} and SsemanticS_{\mathrm{semantic}} as a ranked list of focus patterns.

It.Rk.TypeMini-taskElementsReasonSS
11RELWire performer(s) to process stepsnew Role →\to TR (performs)[Wire] steps lack participants; [Sem] Process–Role; needs Rk. 290
12ARCHIntroduce missing actor/roleSA:Role[AfterE] participant gap; boosts REL (accepted)88
13RELWire step to its outputFX →\to new Artifact (produces)[Wire] output missing; [Sem] use/production86
14ARCHProvision output artifact(s)PT:Artifact[Spawn] to satisfy Rk. 3; prefer reuse84
15RELWire step to evidenceTR →\to new Artifact (uses)[Wire] evidence missing; [Sem] use/production79
16ARCHProvision evidence artifact(s)SC:Artifact[Spawn] for TR; complements Rk. 578
17RELBind goal to execution structureTK →\to WF (resolvedBy)[Sem] Goal–Process; achievement path71
18CHARAdd essential attributes to central itemsTK.priority[AfterE] few attrs66
21RELWire accepted role to key stepSA →\to TR (performs)[Wire] now possible; [Sem] Process–Role97(+7)
22ARCHProvision output artifact(s)PT:Artifact[Spawn] needed by Rk. 489(+5)
23RELExtend performer wiring across related stepsSA →\to VF (performs)[Wire] sibling step; [Inc] popular target [new]88
24RELWire step to its outputFX →\to PT (produces)[Wire] output gap; [Many] list-like86(+0)
25RELWire step to evidenceTR →\to SC (uses)[Wire] evidence gap81(+2)
26ARCHProvision evidence artifact(s)SC:Artifact[Spawn] complements Rk. 581(+3)
27RELBind goal to execution structureTK →\to WF (resolvedBy)[Sem] Goal–Process74(+3)
28CHARAdd operational attribute to stepFX.kind[AfterE] few attrs on step [new]73

Table 4. Unified ranking of the next modeling operation on the running example: two-iteration snapshot leading to the model of Figure 2c.

Iteration 2 shows how accepting one item in Iteration 1 reshapes the pool and raises the priority of the most consequential follow-up actions.

Parallel dispatch

The engine selects the top-KK focus elements and dispatches them, potentially in parallel. In practice, KK is kept small to limit unnecessary LLM calls, reduce computation time, and avoid overwhelming the user with too many unfocused suggestions. Each candidate then goes through prompt instantiation, generation, and post-processing. The resulting completions are presented to the user, who remains in control by accepting or rejecting the suggestions.

Prompt instantiation

A crucial design decision is to distinguish between three focus categories, each corresponding to a family of prompts. The ARCHitectural focus (ARCH) proposes new domain concepts such as entities, processes, or components. The RELational focus (REL) proposes links between concepts, such as containment, association, flow, or dependency. The CHARacteristic focus (CHAR) enriches existing concepts with attributes, roles, labels, or constraints. For graphical modeling languages, these naturally map to adding or refining nodes (ARCH), edges (REL), or annotations (CHAR). In practice, the engine selects one of three template-based prompts, instantiates it with structural and semantic guidance, and constrains the output to short labels. All templates share the same structure: (i) a fixed system instruction enforcing short label generation, (ii) a user prompt instantiated with contextual placeholders, and (iii) a rigid output format for lightweight parsing. The instantiated placeholders include the domain, focus type, partial instance context, optional semantic hint, and optional co-occurrence terms. All templates enforce the same response constraints: labels must be short, unique, explanation-free, and returned in a fixed parsable format.

TemplatePurpose and instantiated contextOutput
ARCHProposes candidate names for a focal element type using domain, local instance context, optional semantic hint, known facts, and co-occurrence cues.1–3 labels
RELProposes concise relation labels between a focal element and a trigger element using role phrase, trigger, local context, and optional semantic hint.1–3 labels
CHARProposes characteristic labels (e.g., attributes, roles, states) for a focal element using relation context, trigger, and optional semantic hints.1–3 labels

Table 5. Prompt template families used in the approach.

In addition, the prompts are influenced by the role-metamodel mapping. For each semantic scheme category, a small library of helper templates is defined in advance. For example, if a Ticket, mapped to the scheme category Goal, lacks a resolution path, the system selects the corresponding Goal helper and adds a semantic hint to the prompt: “This Ticket represents a goal to be achieved; propose a Workflow that achieves it.”

Example instantiation (REL, Ticketing). system: You are a precise naming assistant. Follow the output format exactly. Do not add explanations. User: In the ticketing context, consider a Ticket “Login failure”. This Ticket represents a goal to be achieved. It is resolved by a Workflow to be named. This Workflow is composed of the Steps {Triage, Verify, Fix}. Suggest up to three names for this Workflow. Rules:

  • Single tokens only (A-Z, a-z, 0-9, hyphen, underscore, slash). No spaces.

  • Each label >= 3 chars. NOT Camel Case. No duplicates. No extra text.

After post-processing, the generated list is: Standard Resolution, T-101 Workflow, Login Issue Remediation. In this case, Standard Resolution is the most suitable choice, as it remains general enough to cover fixes beyond the specific login issue.

Tool integration

We implemented our approach RAFiC as an open-source tool1. We provide in the repository’s README simplified demonstration videos illustrating both the language-design setup and the recommendation workflow. The tool is composed of two main parts: (i) a backend that orchestrates interactions with the LLM, and (ii) a client integrated into the modeling environment.

For the LLM server part, we implemented a dedicated backend responsible for the orchestration between the modeling environment and the language model. The server exposes a set of REST endpoints to receive model, metamodel, and semantic data, and to return structured completion recommendations. It performs context preparation, and dynamic prompt generation by combining information from the metamodel and semantic scheme to ensure that LLM prompts and responses remain both syntactically valid and semantically consistent. The server also maintains a trace of all interactions (inputs, prompts, and decisions) to support the reproducibility and evaluation of the experiment. Finally, it handles feedback from the client (accepted or rejected suggestions), to inform subsequent recommendations. The client side of RAFiC is integrated into Sirius Web2, an open-source web-based language workbench that enables the development of graphical domain-specific modeling languages and their associated modeling workbenches directly from a web browser [23]. It is developed using Java, Spring Boot, and EMF on the server side, and TypeScript and React on the client side, with GraphQL for communication. The platform provides two main meta-languages: the

Domain DSL for defining abstract syntax and the View DSL for defining concrete syntax with six default representation types (diagram, form, tree, table, Gantt, and kanban). It is domain-agnostic and primarily targets domain experts who need to build graphical DSLs for their specific concerns. In addition to developing DSLs, Sirius Web is also the platform on which produced modeling workbenches operate. To separate these different concerns, Sirius Web proposes two types of project: studio projects for DSL development; and basic projects to use developed DSLs. Finally, Sirius Web proposes a complete API on which our implementation entirely relies.

First, we added to Sirius Web the metamodel shown in Figure 3 which we implemented using Ecore, and configured Sirius Web to allow its instantiation only within studio projects. To map a semantic role concept to a DSL abstract syntax concept, the language designer simply sets the name attribute to the corresponding abstract syntax concept name.

On the language user side, RAFiC monitors model changes and sends the current model together with its language artifacts to the LLM server when needed. The LLM server then pushes recommendations to Sirius Web, which displays them in a dedicated view on the left side of the application, as shown in Figure 4 for the running example.

RAFiC in Sirius Web on the Ticketing example

Figure 4. RAFiC in Sirius Web on the Ticketing example: recommendations (left), model under construction (center), and properties of the selected step (right).

We consider two kinds of recommendation, each having its own tab in the view: element recommendations (ARCH and CHAR, i.e., new model objects or characteristics); and relation recommendations (REL, connecting existing model objects). Recommendations are ordered in the view by their frequency, i.e., the number of iterations in which the orchestration engine selected them among the top-KK candidates as the canvas evolved. Each recommendation also indicates the model elements to which it applies if accepted (e.g., the Step on which a suggested kind value is set). From this view, the language user can accept or reject each recommendation. Accepting it adds the recommended element or relation to the model; in both cases, the decision is sent back to the LLM server to inform subsequent recommendations. Finally, the recommendations are also displayed in the contextual palette of the elements to which they apply.

Evaluation Methodology

Evaluation Methodology

To assess the effectiveness of our approach, we designed an offline evaluation protocol that isolates the contribution of each guidance mechanism through controlled comparisons and ablations.

Research Questions

More concretely, we investigate the following three research questions (RQs):

  • RQ1: How much does RAFiC improve over an interactive LLM-based completion baseline that does not incorporate DSL syntax or semantics?

  • RQ2: How much does iterative, context-aware guidance in RAFiC improve over an interactive LLM-based approach where DSL syntax and semantics are provided only once upfront?

  • RQ3: What is the contribution of the semantic role guidance within RAFiC, as assessed through an ablation study?

Experimental Setup

Figure 5 provides an overview of the offline evaluation protocol followed in this study. The protocol is organized into three phases: co-designing the DSL artifacts with domain experts, constructing expert-defined ground-truth models, and running the completion sessions under the different experimental configurations. The following subsections detail each part of this protocol.

Offline evaluation protocol showing three phases: co-design, ground truth, and evaluation

Figure 5. Offline evaluation protocol.

DSL Preparation and Ground Truth Construction

4.2.1 DSL Preparation and Ground Truth Construction We begin by collaborating with domain experts to define the metamodel for each DSL, capturing its structural elements, relationships, and constraints. We then define the role-metamodel mapping by aligning metamodel elements with semantic categories, which supports context-sensitive prompt generation. Finally, we define the concrete syntax, including notations, graphical representations, and naming conventions, with continuous expert feedback throughout the process.

Once the DSLs are fully specified, we construct reference instances that serve as ground truth for evaluation. These complete models are built with domain experts based on agreed specifications and serve as the reference against which generated suggestions are evaluated.

Domain-Specific Languages Under Study

4.2.2 Domain-Specific Languages Under Study. To evaluate the applicability and effectiveness of our approach, we selected three domain-specific languages (DSLs) that differ in abstraction level, metamodel size, modeling paradigm, and industrial usage. This selection was designed to exercise the main dimensions on which our approach relies: metamodel-based guidance, domain-semantic guidance, and applicability across heterogeneous DSLs.

UML Class Diagrams (UML-CD). A widely used object-oriented structural language for software and data modeling. We use it to capture conceptual models for medical appointment management and food delivery systems. This DSL exemplifies schema-oriented modeling where class–attribute–association structures dominate.

Supply Chain Modeling (SCM). A process-oriented DSL for representing logistics, production flows, and resource dependencies. We designed two industrial scenarios, car manufacturing and aircraft maintenance routing, to test the approach on operational process networks.

SysML-v2. We use two illustrative scenarios, Flashlight assembly and BatMobile system design, to assess the approach on component-based models. SysML v23 offers richer semantics and stricter typing, making it an ideal stress test for semantic-aware completion.

Table 6 summarizes the selected DSLs and scenarios. Together, they cover diverse modeling styles (structural, behavioral, and systems-level) and support evaluating the assistant across several modeling languages. All specifications, metamodels, and ground-truth instances are provided in the replication package4.

Lang.Scenarios
UML-CDMedical appointment; Food delivery application
SCMCar manufacturing; Aircraft maintenance routing
SysML-v2Flashlight assembly; BatMobile system design

Table 6. Validation test cases.

Simulating the Modeling Process

To mimic interactive modeling, we simulate an iterative completion process. Each evaluation starts from an initial partial model derived from the ground truth by retaining only a minimal, syntactically valid subset of elements centered on the entrypoints of the modeling language, as defined by the metamodel-based prior SmetamodelS_{\mathrm{metamodel}} (§ 4.3). In practice, the model is initialized with zero or the top-1 instance of the highest-ranked entrypoint type, while all other ground-truth elements, relations, and characteristics are removed. At each iteration, a completion mechanism generates candidate suggestions from the current model state. These suggestions are evaluated against the ground truth and accepted or rejected based on semantic correspondence, allowing equivalent or conceptually aligned elements. To limit subjectivity, decisions follow predefined guidelines established with domain experts, prioritizing semantic equivalence over exact naming; in ambiguous cases, suggestions are conservatively rejected. The simulation stops when a fixed iteration limit is reached or no further valid suggestions can be identified.

Evaluation Metrics

We evaluate each configuration by comparing the suggestions it produces with the expert-defined ground-truth model, allowing synonym-level matches. We define a ground-truth unit as an atomic modeling contribution that can be recovered during completion. Depending on the DSL, such units may correspond to model elements, relations, or characteristics such as attributes, properties, or typed connections. Let GG denote the set of all ground-truth units in the reference model.

The contribution rate (Ctr) measures the percentage of the expected model recovered during the whole completion session. Let AA denote the set of unique suggested units accepted as belonging to GG, either directly or through semantic correspondence: Ctr=∣A∣∣G∣×100Ctr = \frac{|A|}{|G|} \times100

The total unique number of generated candidates (Cand) captures the overall amount of content proposed, independently of whether suggestions are accepted, rejected, or repeated. Let StS_t denote the set of candidate units suggested at iteration tt and TT the total number of iterations:

Cand=∑t=1T∣St∣Cand = \sum_{t=1}^{T} |S_t|

Redundancy (Red.) measures how often a configuration repeatedly suggests the same modeling units. Let UcandU_{\mathrm{cand}} denote the set of unique candidate units after merging identical or semantically equivalent suggestions: Red=Ncand−∣Ucand∣Ncand×100Red = \frac{N_{\mathrm{cand}} - |U_{\mathrm{cand}}|}{N_{\mathrm{cand}}} \times100

In addition, we report the cumulative number of accepted suggestions over the interaction. Let aia_i denote the number of new suggestions accepted at iteration ii: Ct=∑i=1taiC_t = \sum_{i=1}^{t} a_i. This curve complements the aggregate metrics by showing how accepted contributions accumulate during the interaction, distinguishing configurations that make early progress from those that stagnate after a few iterations.

Experimental results

Experimental Configurations

We evaluate four configurations along two prompt-design axes: (i) structural injection, which provides explicit structural guidance for the DSL, and (ii) semantic injection, which provides meaning-level guidance via the role-metamodel mapping. For each axis, guidance may be provided iteratively, as a whole upfront, or not at all. Different metrics are computed separately for each configuration.

CfgConfigurationSyntax injectionSemantic injection
RAFiCTool-based completionIterativeIterative
RAFiC-AblTool-based ablation (no semantics)IterativeNone
C-MinChat baseline (minimal prompt)NoneNone
C-FullChat baseline (full prompt)Whole (upfront)Whole (upfront)

Table 7. Experimental configurations along two prompt-design axes: syntax injection and semantic injection.

Tool-based completion. We evaluate our approach in two variants. RAFiC(syntax+semantics, iterative) injects structural constraints and semantic guidance derived from the annotation scheme at each iteration, using the current model state to tailor suggestions. RAFiC-Abl. (syntax-only, iterative) keeps the same structural prompting but removes guidance from the semantic annotation scheme, serving as an ablation.

Chat-based completion. Following the chat-based protocol of [11], we define two baselines that generate suggestions through direct LLM prompting without orchestration. C-Min (no injections) provides only the current partial model and the task instruction. C-Full (whole injections) provides the current partial model together with the full metamodel and the semantic annotation scheme injected upfront, rather than reconstructed iteratively. For reproducibility, the companion repository includes the exact prompts for C-Min/C-Full, configuration files, execution scripts, and raw logs5. All four configurations are evaluated under identical conditions. For each DSL and scenario, they start from the same initial partial model, use the same entrypoint algorithm and acceptance policy, and are evaluated against the same ground truth. They also rely on the same locally deployed LLM, Llama 3.1-70B6, with identical decoding parameters.

Experimental results

This section reports the empirical evaluation of RAFiC across the three DSLs introduced in § 6.2.2. Table 8 summarizes the three metrics defined in § 6.2.4 for all configurations: contribution rate (Ctr.), unique candidates (Cand.), and redundancy (Red.). Figure 6 complements these aggregate results by showing how accepted suggestions accumulate over the interaction, which helps interpret the progression patterns behind the final scores.

DSLScen.RQ1 RAFiC Ctr. (%)RQ1 RAFiC Cand. (u.)RQ1 RAFiC Red. (%)RQ2 C-Min Ctr. (%)RQ2 C-Min Cand. (u.)RQ2 C-Min Red. (%)RQ2 C-Full Ctr. (%)RQ2 C-Full Cand. (u.)RQ2 C-Full Red. (%)RQ3 RAFiC-Abl Ctr. (%)RQ3 RAFiC-Abl Cand. (u.)RQ3 RAFiC-Abl Red. (%)
UML-CDFood del.39%12242%43.3%2065.5%39%3165.6%34%9023%
UML-CDMed. appt.40%13538%44.8%3353.6%43%2756.5%36%10025%
SCMCar manuf.48.1%23928%23.1%1975.9%56.7%5534.5%23.3%18715%
SCMAircraft mt.74%29454.1%29%7042%61%7531.8%58%23948.82%
SysML-v2Flashlight57%15537%16%4544.4%22%5225%38%12813%
SysML-v2BatMobile50%22757%19%1790.2%20.7%4055%39%19841%

Table 8. Summary of results across DSLs and scenarios, grouped by configuration.

Cumulative AI-accepted suggestions across modeling progress for the DSLs and scenarios, grouped by DSL

Figure 6. Cumulative AI-accepted suggestions across modeling progress for the DSLs and scenarios, grouped by DSL.

RQ1: How much does RAFiC improve over an interactive LLM-based completion baseline that does not incorporate DSL syntax or semantics?

RQ1 compares RAFiC with C-Min. In this comparison, RAFiC improves contribution in 4 of the 6 scenarios, with the clearest gains in SCM and SysML-v2. For example, contribution rises from 29% to 74% in Aircraft maintenance and from 16% to 57% in Flashlight. By contrast, C-Min remains competitive in the two UML-CD scenarios, suggesting that simpler and more familiar modeling constructs can already be handled reasonably well by prompts that are minimally guided.

The candidate and redundancy metrics add nuance to this result. RAFiC generates more unique candidates in all scenarios and has lower redundancy in 5 of the 6 scenarios. This indicates that the improvement is not only due to producing more suggestions, but also to exploring the completion space more effectively. The main exception is Aircraft maintenance, where higher contribution is accompanied by higher redundancy, suggesting a trade-off between semantic coverage and repeated exploration in more complex scenarios.

The cumulative curves confirm this, RAFiC accumulates accepted suggestions earlier and more steadily, especially for Aircraft maintenance, Flashlight, and BatMobile scenarios.

RQ2: How much does iterative, context-aware guidance in RAFiC improve over an interactive LLM-based approach where DSL syntax and semantics are provided only once upfront?

RQ2 compares RAFiC with C-Full. In this comparison, providing DSL syntax and domain semantics only once upfront is not sufficient to consistently match iterative, context-aware guidance. RAFiC achieves higher contribution in 3 of the 6 scenarios, matches C-Full in 1, and is lower in 2. The clearest gains appear in the more complex settings, such as Flashlight, where contribution rises from 22% to 57%, and Aircraft maintenance, where it rises from 61% to 74%. By contrast, C-Full remains competitive in Car manufacturing and Medical appointment, while both configurations obtain the same contribution in Food delivery. Overall, the benefit of iterative guidance is limited for UML-CD, mixed for SCM, and strongest for SysML-v2.

The candidate and redundancy metrics further qualify this result. RAFiC generates more unique candidates than C-Full in all scenarios, confirming that iterative guidance explores a broader completion space than a one-shot provision of syntax and semantics. However, this broader exploration is not always less redundant. RAFiC reduces redundancy in the two UML-CD scenarios and in Car manufacturing, but shows higher redundancy in Aircraft maintenance, Flashlight, and BatMobile. This suggests that, in more complex scenarios, iterative context-aware guidance can recover more useful completions, but may also revisit similar semantic areas as the model evolves.

The cumulative curves show the same pattern, RAFiC rises earlier and stays above C-Full for most of the interaction in the SCM and SysML-v2 scenarios. Overall, iterative guidance matters most when useful completions depend on the evolving local context.

RQ3: What is the contribution of the semantic role guidance within RAFiC, as assessed through an ablation study?

RQ3 compares RAFiC with RAFiC-Abl. In this comparison, the effect of semantic role guidance is clear: RAFiC achieves higher contribution, i.e., it recovers a larger proportion of the expert-defined ground-truth units, in all 6 scenarios. The gains are modest for UML-CD, but more pronounced for SCM and SysML-v2. For example, contribution increases from 58% to 74% in the Aircraft maintenance scenario and from 38% to 57% in the Flashlight scenario. This suggests that semantic guidance is especially useful when relevant completions depend on domain-specific concepts that are not captured by the DSL structure alone.

Semantic role guidance also changes the explored completion space. In all 6 scenarios, RAFiC generates more unique candidates than RAFiC-Abl, indicating that semantic role guidance expands the set of distinct completion alternatives considered by the system. However, this broader exploration is also accompanied by higher redundancy in all scenarios. For example, redundancy rises from 13% to 37% in the SysML-v2 Flashlight scenario and from 23% to 42% in the UML-CD Food delivery scenario. This suggests that semantic guidance helps identify more semantically relevant completions, but can also lead the system to revisit similar semantic areas or produce partially overlapping suggestions.

The cumulative curves support the same conclusion. In several scenarios, especially for SCM and SysML-v2, the RAFiC curve rises more strongly and reaches a higher final level than RAFiC-Abl. Taken together, these results indicate that semantic role guidance substantially improves completion quality, with a trade-off in efficiency due to increased redundancy.

Discussion

This section interprets the main experimental findings and draws implications for the design of LLM-based modeling assistants.

Iterative guidance improves contextual completion. The comparison between RAFiC and the upfront-guidance baseline C-Full indicates that the benefit of iterative guidance is not about providing more information, but about providing the right information at the right time. When DSL syntax and semantic roles are injected upfront, the LLM receives all relevant knowledge but lacks a mechanism to focus on what matters now. As the model evolves, the initial context drifts from the current state, and the LLM cannot prioritize among the many valid but contextually irrelevant completions it could generate. RAFiC addresses this by reframing each generation step in the current model. The orchestrator recomputes scores, identifies the most pressing gap, and instantiates a prompt narrowed to that gap. This explains why the cumulative curves for RAFiC rise earlier and more steadily in the SCM and SysML-v2 scenarios. This suggests that for the incremental modeling tasks studied here, adapting prompt content to the current model state can be more effective than providing all available knowledge upfront.

Benefits vary across DSLs. The observed gains are not uniform across the three DSLs. This is consistent with recent findings showing that LLM knowledge of language constructs varies significantly depending on their representation in training data [16]. For UML-CD, whose patterns are well-represented in pretraining corpora, even C-Min recovers substantial ground truth, as the LLM’s already encoded knowledge acts as implicit guidance. For SCM and SysML-v2, this implicit knowledge is insufficient: their modeling patterns cannot be reliably inferred from general-purpose language understanding, and explicit metamodel and semantic role guidance fills a genuine knowledge gap. The practical consequence is that the preparation effort for RAFiC artifacts pays off most for specialized or proprietary DSLs, which are precisely the cases where modeling assistance is most needed.

Role-metamodel mapping improves semantic coverage. The ablation (RAFiC vs. RAFiC-Abl) isolates the contribution of the semantic annotation scheme from the basic structure of the metamodel. The role-metamodel mapping provides information the metamodel alone does not convey: the modeling role of DSL elements. This disambiguation operates through two mechanisms. First, it influences prompt construction: when a Ticket is mapped to Goal, the prompt frames it as an objective to be resolved, directing the LLM toward achievement-oriented completions. Second, it influences the scoring of candidate completions: the scoring function promotes completions that realize the semantic role patterns it predicts (such as Process/Role or Goal/Process), surfacing semantically meaningful next steps ahead of structurally valid but arbitrary alternatives. This distinction matters because metamodel conformance is necessary but not sufficient for useful completion. A conformant suggestion that introduces a random valid element is less useful than one that addresses a genuine semantic gap.

Semantic coverage comes with redundancy. A recurring observation is that configurations with higher contribution rate also exhibit higher redundancy, particularly when semantic role guidance is active. By promoting candidates that match semantic role patterns, the system concentrates exploration in semantically relevant regions, which increases the likelihood of accepted suggestions but also of revisiting similar modeling areas across iterations. This redundancy is not a deficiency of the semantic role guidance itself but rather reflects limited diversity control in the current prototype. The orchestration engine does not track which parts of the completion space have already been explored. Future versions should address this through semantic clustering of near-duplicate candidates, score penalties for suggestions similar to recently rejected ones, and adaptive focus shifting toward under-explored model areas.

Implications for LLM-based modeling assistance. Overall, these results suggest that LLM-based model completion can be effective and applicable across the DSLs studied here when the generation process combines metamodel constraints with semantic-role-guided enrichment. The approach also demonstrates that useful modeling assistance is achievable with an open-source LLM, provided that structural and semantic guidance are explicitly integrated into the completion loop.

Threats to validity

We discuss the threats to the validity of our study along three dimensions: construct, internal, and external validity. For each threat, we describe how we mitigated it.

Construct validity. Domain modeling is an open-world task, where there is rarely a single correct completion. A useful suggestion may differ from the reference model in naming, ordering, or level of detail while still expressing the same modeling intent, so strict syntactic matching would undercount valid suggestions. To mitigate this, suggestions were checked against the ground-truth model according to their intended meaning, the current modeling context, and the metamodel constraints, following predefined acceptance guidelines: a suggestion was counted as accepted only when it could be clearly associated with a missing ground-truth element.

Internal validity. First, one of the authors conducted the simulation and was familiar with both the tool and the target formalisms, which may have introduced bias in interaction decisions or in the interpretation of suggestions. To mitigate this, the human role was limited to verifying whether suggestions matched expected ground-truth elements, rather than judging their quality, and the same guidelines and procedure were applied across all configurations, DSLs, and scenarios. Future work could involve multiple independent checkers and report inter-rater agreement. Second, each configuration was run once per DSL or scenario, so the values in Table 8 are single-run estimates with no variance or significance testing. This follows from the study design: each run is an interactive session with the tool in which every suggestion is checked against the ground truth, so a run cannot be cheaply repeated. To mitigate this, decoding was deterministic, with the same model and decoding parameters for all configurations. This limits but does not eliminate the threat, since minor non-determinism in the LLM serving stack is still possible; future work should evaluate more scenarios per DSL and report variance and statistical tests across them.

External validity. First, each DSL was evaluated on only two scenarios, which cannot capture the full diversity of modeling situations in practice and may limit generalizability. To mitigate this, we selected three distinct formalisms with increasing metamodel complexity (Section 4.2.2): UML-CD as a small and compact metamodel, SCM as a medium-sized formalism with richer process and resource constructs, and SysML-v2 as a larger and more complex formalism combining structural, behavioral, and parametric aspects, each paired with two scenarios from different domains. Second, results could be inflated if the LLM had memorized the studied scenarios during pretraining. To mitigate this, we chose languages and scenarios that are not among the most widely studied, while keeping the languages plausibly known to LLMs through public resources, as our goal is to assess whether such existing knowledge can be leveraged in a context-aware and structurally valid way. Finally, the semantic annotation scheme was derived by examining a limited set of modeling languages rather than through an exhaustive survey of the design space, so DSLs or domains outside those considered here may require roles or relations not currently in the scheme. To mitigate this, the approach is extensible by construction: the scheme can be incrementally refined, and role-metamodel mappings can be added progressively for new DSLs and domains without requiring changes to RAFiC itself. Moreover, the three evaluated DSLs span distinct modeling paradigms, which reduces the risk that the scheme only fits a single notation.

Related work

Early work on automatic model generation mainly relied on traditional NLP pipelines to transform textual requirements into UML models, especially class diagrams [4, 34]. These approaches typically applied linguistic preprocessing steps such as sentence splitting, tokenization, part-of-speech tagging, syntactic parsing, and dependency analysis, followed by handcrafted rules or heuristics to identify candidate classes, attributes, operations, and relationships. While such techniques helped automate parts of the transition from requirements to models, they were often tailored to specific notations, input styles, and rule sets. More recently, LLMs have been explored for software modeling tasks [10, 14, 20]. These approaches differ from traditional NLP-based methods because they rely less on explicit linguistic rules and more on the generative capabilities of pretrained models. However, they still face related challenges: generated models must conform to the target modeling language, remain semantically aligned with the domain, and often require human or automated checks to detect invalid, incomplete, or redundant elements.

Although most related work focuses on full model generation, our work targets interactive model completion from partial models. This distinction is important. In full generation, the model is usually produced from an initial textual specification and then inspected, corrected, or regenerated. In model completion, the model already exists and evolves through incremental suggestions that must remain consistent with the current modeling context. Consequently, Table 9 compares LLM-assisted domain modeling approaches along six dimensions that are directly related to the challenges addressed in this work.

WorkYearTarget languageLLMGenerationTool integrationSyntax inj.Semantic inj.
Chen et al. [14]2023UML Class DiagramsGPT-3.5, GPT-4 (Comm)Non-iterative, acceptance-loopNo editor integration; offline pipelineImplicit format constraintsNL descriptions and examples
Cámara et al. [11]2023UML Class DiagramsChatGPT (Comm)Iterative, HITLNo editor integration; PlantUML/USE outputsOCL constraintsNone
Chen et al. [13]2023Goal ModelsGPT-4 (Comm)Iterative, HITLNo editor integration; interactive ChatGPT promptingNoneNatural-language descriptions
Ben Chaaben et al. [6]2024UML Class DiagramsGPT-3 (Comm)Iterative, HITLMAGDA tool; Eclipse/Sirius-based environmentImplicit constraintsFew-shot examples
Ferrari et al. [19]2024UML Sequence DiagramsChatGPT (GPT-3.5/4, Comm)Non-iterative, acceptance-loopNo editor integration; PlantUML output in PlantTextNoneNatural-language requirements
Apvrille and Sultan [3]2024SysML DiagramsChatGPT (GPT-3.5, Comm)Iterative, automated feedbackTTool-AI modeling and verification environmentSysML rules and tool checksNatural-language specifications
Pan et al. [36]2025Ecore-based DSLsGPT-4o, o1-preview (Comm), Llama 3.1 (8B, 70B) (OSS)Non-iterative, automatedPrototype integration with EMF toolchainExplicit metamodelScenario descriptions in NL
RAFiCThis workAny language with a metamodelLlama 3.1-70B (OSS)Iterative, HITLPrototype Sirius Web integrationExplicit metamodelSemantic-role-guided prompting

Table 9. Comparison of LLM-assisted domain modeling approaches.

We first report the target modeling language, indicating whether an approach is tied to a specific notation, such as UML class diagrams, goal models, or SysML diagrams, or whether it can be applied to several languages when a metamodel is available, as in Ecore-based DSLs [36].

The LLM column indicates whether an approach relies on proprietary cloud-based models as in many ChatGPT- or GPT-based studies [11, 14], or considers open-source models (OSS) that can be executed locally.

The generation strategy indicates whether models are produced in a single LLM invocation and subsequently inspected or accepted by a human, or through an iterative process involving multiple LLM interactions for refinement, with human and/or automated feedback.

Tool integration captures whether the LLM support is embedded within a modeling environment or used externally, for example through a chat interface, an offline pipeline, or a separate textual notation such as PlantUML.

Finally, syntax injection indicates how an approach helps ensure that the generated or accepted modeling elements are valid with respect to the target modeling language. This may rely on explicit metamodel information, tool-supported checks, language rules, or additional constraints such

ends_mid=1 Comm. = commercial; OSS = open-source; HITL = human-in-the-loop.

as OCL. In contrast, semantic injection indicates how domain meaning is provided to guide the relevance of these elements. This may be done through natural-language requirements, illustrative examples, scenario descriptions, or, in our case, semantic-role prompting that relates domain concepts to possible modeling elements.

Among these works, Cámara et al. [11] is particularly relevant to our experimental design. Their work focuses on UML class diagrams and studies LLM-based model completion in an interactive, human-in-the-loop setting, where the LLM proposes modeling elements and the user progressively validates or rejects them. They identify significant limitations in semantic accuracy, particularly for larger diagrams, noting serious errors for models larger than 10–12 classes. We use this interaction style as inspiration for our chat-based baseline configurations described in Section 4.2.5.

Our work differs from prior approaches by targeting language-agnostic, iterative model completion using an open-source LLM. Rather than focusing on a specific DSL or diagram type, RAFiC supports any modeling language for which a metamodel is provided. The LLM is guided by both explicit metamodel information and semantic role guidance, enabling suggestions that are syntactically valid and semantically aligned across heterogeneous languages. Furthermore, unlike most related approaches that generate models in a text-based format (e.g., PlantUML), RAFiC produces suggestions as actionable editing operations within a graphical model editor, ensuring that accepted recommendations are directly integrated into the model under construction without requiring manual transcription or format conversion.

Beyond the approaches compared above, other aspects of model completion have also been studied. Logic-based encodings of metamodel knowledge and constraints have been used to support completion and correctness, enabling automated reasoning about properties of class models [7]. More recently, Welter et al. [48] propose NextFocus, a predictor that recommends where to continue editing by ranking candidate focus nodes for multi-location model completion from evolution history. Our work is complementary to NextFocus: rather than predicting where the modeler should focus next, it addresses what to add, generating domain-relevant elements and connections and assessing their semantic adequacy via metamodel knowledge and role-metamodel mappings.

Conclusion

In this paper, we presented RAFiC, an LLM-based approach for iterative domain model completion that generalizes across DSLs. The approach combines metamodel-based structural constraints with semantic-role-guided enrichment, and uses the evolving partial model as context to produce incremental, context-aware suggestions during model construction. We assess the approach through a comparative ablation study on three DSLs (UML-CD, SCM, and SysML-v2), each with two scenarios. The evaluation yielded three main findings. First, within the three DSLs and six scenarios evaluated, iterative guidance, which adapts prompts to the current model state, outperforms minimal prompting in 4 of the 6 scenarios and matches or outperforms one-shot upfront provision of DSL knowledge in 4 of the 6 scenarios, with the largest gains observed for DSLs less represented in LLM training data. Second, semantic role guidance improves contribution rate across all scenarios by providing modeling role information that the metamodel alone does not convey. Third, these results are achieved with an open-source LLM (LLaMA 3.1-70B), showing that clear structural and semantic guidance can help open-source models perform well even when they have less prior knowledge than commercial models.

These findings support a broader principle for LLM-based modeling tools: combining generative capabilities with explicit, modeling-specific knowledge produces more relevant suggestions than relying on the LLM’s implicit knowledge alone. The approach is not tied to a specific language or notation, and can be applied to any DSL for which a metamodel and role-metamodel mapping are provided.

Future work will build on these results in three directions. First, evaluating RAFiC on additional DSLs and with larger or commercial LLMs would test whether the observed patterns hold across a broader range of modeling languages and model capabilities. Second, user studies with modelers of varying expertise would assess how the coverage gains observed in our experiments translate into perceived usefulness and productivity during real modeling sessions. Third, providing semi-automated support for the role-metamodel mapping, for example by using the LLM itself to propose initial alignments, would reduce the preparation effort and facilitate adoption of RAFiC for new DSLs.

References

  1. [1]Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. 2023. Gpt-4 technical report. arXiv preprint arXiv:2303.08774 (2023).arxiv.org/abs/2303.08774
  2. [2]Aakash Ahmad, Muhammad Waseem, Peng Liang, Mahdi Fahmideh, Mst Shamima Aktar, and Tommi Mikkonen. 2023. Towards Human-Bot Collaborative Software Architecting with ChatGPT. In Proceedings of the 27th International Conference on Evaluation and Assessment in Software Engineering (EASE ’23). Association for Computing Machinery, New York, NY, USA, 279–285. https://doi.org/10.1145/3593434.3593468.
  3. [3]Ludovic Avrille and Bastien Sultan. 2024. System Architects Are not Alone Anymore: Automatic System Modeling with AI. In International Conference on Model-Driven Engineering and Software Development. https://api.semanticscholar.org/CorpusID:268023872
  4. [4]Nauman Bashir, Muhammad Bilal, Misbah Liaqat, Mohsen Marjani, Nadia Malik, and Mohsin Ali. 2021. Modeling class diagram using nlp in object-oriented designing. In 2021 National Computing Colleges Conference (NCCC). IEEE, 1–6.DOI
  5. [5]Meriem Ben Chaaben, Oussama Ben Sghaïer, Mouna Dhaouadi, Nafisa Elrasheed, Ikram Darif, Imen Jaoua, Bentley Oakes, Eugene Syriani, and Mohammad Hamdaqa. 2024. Toward Intelligent Generation of Tailored Graphical Concrete Syntax. In Proceedings of the ACM/IEEE 27th International Conference on Model Driven Engineering Languages and Systems. 160–171.
  6. [6]Meriem Ben Chaaben, Lola Burgueño, Istvan David, and Houari Sahraoui. 2025. On the Utility of Domain Modeling Assistance with Large Language Models. ACM Trans. Softw. Eng. Methodol. (June 2025). https://doi.org/10.1145/3744920
  7. [7]Daniela Berardi, Diego Calvanese, and Giuseppe De Giacomo. 2005. Reasoning on UML class diagrams. Artificial intelligence 168, 1-2 (2005), 70–118.DOI
  8. [8]Manfred Bröy. 2013. Domain modeling and domain engineering: Key tasks in requirements engineering. In Perspectives on the Future of Software Engineering: Essays in Honor of Dieter Rombach. Springer, 15–30.
  9. [9]Loli Burgueño, Robert Carisó, Sebastián Gérard, Shuai Li, and Jordi Cabot. 2021. An NLP-Based Architecture for the Autocompletion of Partial Domain Models. In Advanced Information Systems Engineering (CAiSE 2021) (Lecture Notes in Computer Science, Vol. 12751). Springer, 91–106.DOI
  10. [10]Kiran Busch, Alexander Rochlitzer, Diana Sola, and Henrik Leopold. 2023. Just tell me: Prompt engineering in business process management. In International Conference on Business Process Modeling, Development and Support. Springer, 3–11.arxiv.org/abs/2304.07183
  11. [11]Javier Cámara, Javier Troya, Lola Burgueño, and Antonio Vallecillo. 2023. On the assessment of generative AI in modeling tasks: an experience report with ChatGPT and UML. Software and Systems Modeling 22, 3 (2023), 781–793.DOI
  12. [12]Meriem Ben Chaaben, Lola Burgueño, and Houari Sahraoui. 2023. Towards using few-shot prompt learning for automating model completion. In 2023 IEEE/ACM 45th International Conference on Software Engineering: New Ideas and Emerging Results (ICSE-NIER). IEEE, 7–12.
  13. [13]Boqi Chen, Kua Chen, Shabnam Hassani, Yujing Yang, Daniel Amyot, Lysanne Lessard, Gunter Mussbacher, Mehrdad Sabzateh, and Dániel Varró. 2023. On the use of GPT-4 for creating goal models: an exploratory study. In 2023 IEEE 31st International Requirements Engineering Conference Workshops (REW). IEEE, 262–271.DOI
  14. [14]Kua Chen, Yujing Yang, Boqi Chen, José Antonio Hernández López, Gunter Mussbacher, and Dániel Varró. 2023. Automated domain modeling with large language models: A comparative study. In 2023 ACM/IEEE 26th International Conference on Model Driven Engineering Languages and Systems (MODELS). IEEE, 162–172.
  15. [15]Benoit Combemale, Robert France, Jean-Marc Jézéquel, Bernhard Rumpe, James Steel, and Didier Vojtisek. 2016. Engineering modeling languages: Turning domain knowledge into tools. CRC Press.
  16. [16]David Delgado, Lola Burgueño, and Robert Clarisó. 2026. How much does an LLM know about my programming language? In Proceedings of the 19th ACM SIGPLAN International Conference on Software Language Engineering. 64–77.DOI
  17. [17]Benjamino Di Martino, Antonio Esposito, Stefania Nacchia, and Salvatore Augusto Maisto. 2015. Semantic annotation of BPMN: current approaches and new methodologies. In Proceedings of the 17th International Conference on Information Integration and Web-based Applications & Services. 1–5.DOI
  18. [18]Qingxiu Dong, Lei Li, Jingjing Xu, and Xuanjing Zhang. 2022. A survey of in-context learning: Methods, applications, and challenges. arXiv preprint arXiv:2201.11903 (2022).
  19. [19]Alessio Ferrari, Salamb Alqahtia, and Chetan Arora. 2024. Model Generation with LLMs: From Requirements to UML Sequence Diagrams. In 2024 IEEE 32nd International Requirements Engineering Conference Workshops (REW). 291–300. https://doi.org/10.1109/REW61692.2024.00044
  20. [20]Hans-Georg Fill, Peter Fettke, and Julius Köpke. 2023. Conceptual modeling and large language models: impressions from first experiments with ChatGPT. Enterprise Modelling and Information Systems Architectures (EMISAf) 18 (2023), 1–15.
  21. [21]Frédéric Fondement. 2007. Concrete syntax definition for modeling languages. Ph. D. Dissertation. Verlag nicht ermittelbar.DOI
  22. [22]Aldo Gangemi, Nicola Guarino, Claudio Masolo, Alessandro Oltramari, and Luc Schneider. 2002. Sweetening Ontologies with DOLCE. In Knowledge Engineering and Knowledge Management: Ontologies and the Semantic Web (EKAW 2002) (LNCS, Vol. 2473). Springer, 223–233. https://doi.org/10.1007/3-540-45810-7_18
  23. [23]Théo Giraudet, Mélanie Bats, Arnaud Blouin, Benoît Combemale, and Pierre-Charles David. 2024. Sirius Web: Insights in Language Workbenches-An Experience Report. The Journal of Object Technology (2024).
  24. [24]Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al. 2024. The llama 3 herd of models. arXiv preprint arXiv:2407.21783 (2024).
  25. [25]Vitor Guilherme and Auri Vincenzi. 2023. An initial investigation of ChatGPT unit test generation capability. In Proceedings of the 8th Brazilian Symposium on Systematic and Automated Software Testing (<conf-loc>, <city>Campo Grande, MS</city>, <country>Brazil</country>, </conf-loc>) (SAST ’23). Association for Computing Machinery, New York, NY, USA, 15–24. https://doi.org/10.1145/3624032.3624035
  26. [26]Giancarlo Guizzardi. 2005. Ontological foundations for structural conceptual models. (2005).
  27. [27]Giancarlo Guizzardi, Allexander Botti Benevides, Claudienr M Fonseca, Daniele Porello, João Paulo A Almeida, and Tiago Prince Sales. 2022. UFO: Unified foundational ontology. Applied ontology 17, 1 (2022), 167–210.DOI
  28. [28]David Harel and Bernhard Rumpe. 2004. Meaningful modeling: what’s the semantics of “semantics”? Computer 37, 10 (2004), 64–72.
  29. [29]Abram Hindle, Earl T. Barr, Zhendong Su, Mark Gabel, and Premkumar Devanbu. 2012. On the naturalness of software. In 2012 34th International Conference on Software Engineering (ICSE). IEEE Press, Zurich Switzerland, 837–847. https://doi.org/10.1109/ICSE.2012.6227135
  30. [30]C Maria Keet and Pablo Rubén Fillottrani. 2015. An ontology-driven unifying metamodel of UML Class Diagrams, EER, and ORM2. Data & Knowledge Engineering 98 (2015), 30–53.
  31. [31]Tobias Kuschke, Patrick Mäder, and Patrick Rempel. 2013. Recommending Auto-completions for Software Modeling Activities. In Model-Driven Engineering Languages and Systems (MODELS 2013) (Lecture Notes in Computer Science, Vol. 8107). Springer, 170–186.DOI
  32. [32]Florian Lautenbacher, Bernhard Bauer, and Christian Seitz. 2008. Semantic business process modeling-benefits and capability. In AAAI 2008 Stanford Spring Symposium-AI Meets Business Rules and Process Management, Friday, March 26–28, 2008, Palo Alto, CA, USA. AAAI Press.
  33. [33]Bonan Min, Hayley Ross, Elior Sulev, Amir Pouran Ben Veyseh, Thien Huu Nguyen, Oscar Sainz, Eneko Agirre, Ilana Heinz, and Dan Roth. 2023. Recent advances in natural language processing via large pre-trained language models: A survey. Comput. Surveys 56, 2 (2023), 1–40.
  34. [34]Priynka More and Rashmi Phalnikar. 2012. Generating UML diagrams from natural language specifications. International Journal of Applied Information Systems 1, 8 (2012), 19–23.DOI
  35. [35]Ipek Ozkaya. 2023. Application of Large Language Models to Software Engineering Tasks: Opportunities, Risks, and Implications. IEEE Software 40, 3 (2023), 4–8. https://doi.org/10.1109/MS.2023.3248401
  36. [36]Fengjunjie Pan, Nenad Petrovic, Wahid Zolfaghari, Long Wen, and Alois Knoll. 2025. LLM-enabled Instance Model Generation. https://doi.org/10.1109/MODELS-C68889.2025.00082
  37. [37]Fernando Silva Parreiras and Steffen Staab. 2010. Using ontologies with UML class-based modeling: The TwoUse approach. Data & Knowledge Engineering 69, 11 (2010), 1194–1207.
  38. [38]István Ráth, András Ökrös, and Dániel Varró. 2010. Synchronization of abstract and concrete syntax in domain-specific modeling languages: By mapping models and live transformations. Software & Systems Modeling 9 (2010), 453–471.
  39. [39]Mark Richters and Martin Gogolla. 2002. OCL: Syntax, semantics, and tools. In Object Modeling with the OCL: The Rationale behind the Object Constraint Language. Springer, 42–68.DOI
  40. [40]Krishna Ronanki, Christian Berger, and Jennifer Hofrock. 2023. Investigating ChatGPT’s Potential to Assist in Requirements Elicitation Processes. In 2023 49th Euromicro Conference on Software Engineering and Advanced Applications (SEAA). IEEE Computer Society, Durres, Albania, 354–361. https://doi.org/10.1109/SEAA60479.2023.00061
  41. [41]Sagar Sen, Benoit Baudry, and Hans Vangheluwe. 2007. Domain-specific model editors with model completion. In International Conference on Model Driven Engineering Languages and Systems. Springer, 259–270.DOI
  42. [42]Sagar Sen, Benoit Baudry, and Hans Vangheluwe. 2010. Towards domain-specific model editors with automatic model completion. Simulation 86, 2 (2010), 109–126.DOI
  43. [43]Haoran Shi, Shijun Liu, and Li Pan. 2025. How LLMs Aid in Domain Modeling: Opportunities and Challenges. In 2025 IEEE International Conference on Software Services Engineering (SSE). IEEE, 202–210.DOI
  44. [44]Eugenе Syriani, Istvan David, and Gauransh Kumar. 2024. Screening Articles for Systematic Reviews with ChatGPT. (2024).DOI
  45. [45]Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. Advances in neural information processing systems 30 (2017).arxiv.org/abs/1706.03762
  46. [46]Eelco Visser. 2008. WebDSL: A Case Study in Domain-Specific Language Engineering. In Generative and Transformational Techniques in Software Engineering II (GTTSE 2007) (Lecture Notes in Computer Science, Vol. 5235). Springer, 291–373.
  47. [47]Yair Wand and Ron Weber. 1990. An ontological model of an information system. IEEE Transactions on Software Engineering 16, 11 (1990), 1282–1292.DOI
  48. [48]Alisa Welter, Christof Tinnes, and Sven Apel. 2026. Multi-Location Software Model Completion. https://www.se.cs.uni-saarland.de/publications/docs/WTA26.pdfarxiv.org/abs/2601.13894
  49. [49]Jules White, Quchen Fu, Sam Hays, Michael Sandborn, Carlos Olea, Henry Gilbert, Ashraf Elashar, Jesse Spencer-Smith, and Douglas C. Schmidt. 2023. A Prompt Pattern Catalog to Enhance Prompt Engineering with ChatGPT. Report 2302.11382. arXiv.arxiv.org/abs/2302.11382
  50. [50]Christoph Wienands and Michael Golm. 2009. Anatomy of a Visual Domain-Specific Language Project in an Industrial Context. In Model Driven Engineering Languages and Systems (MODELS 2009) (Lecture Notes in Computer Science, Vol. 5795). Springer, 453–467.
  51. [51]An Yang, Feng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengeng Huang, Chenxu Lv, et al. 2025. Qwen3 technical report. arXiv preprint arXiv:2505.09388 (2025).arxiv.org/abs/2505.09388
  52. [52]Shengyu Zhang, Linfeng Dong, Xiaoya Li, Sen Zhang, Xiaofei Sun, Shuhe Wang, Jiwei Li, Runyi Hu, Tianwei Zhang, Fei Wu, and Guoyin Wang. 2023. Instruction Tuning for Large Language Models: A Survey. arXiv:2308.10792 [cs.CL]arxiv.org/abs/2308.10792

Paper details

vlnc:W_29kqsuwk
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 4

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents