WorksComputer Science
Discovering the Relation Between Architectural Models and Reference Architectures
Abstract
Assessing whether concrete software architectures are consistent with their reference architecture (RA) is essential to ensure that architectural decisions scale coherently across projects, preserving the quality attributes the RA was designed to guarantee. In the absence of dedicated techniques, mapping the components of an architectural model onto a predefined RA can be addressed only with general-purpose model-comparison algorithms. Our experiments show that these algorithms are inaccurate when applied to RAs. To address this gap, we propose Reference Architecture Mapping Discovery (RAMD), an LLM-based workflow that combines model analysis with structured prompting, and refines results through an iterative RA compliance-checking mechanism. We evaluate RAMD on 64 open-source architectural models spanning three RAs from the IoT, self-driving, and smart parking domains. With domain knowledge and GPT-4o, RAMD reaches 85.8% mapping accuracy and outperforms the strongest baseline by 44.6 percentage points, while ensuring structural consistency with the RA.
Introduction
A Reference Architecture (RA) is a domain-specific, generic architectural blueprint that codifies the structural and functional principles shared by systems belonging to the same family of applications [1, 2, 3]. It captures design knowledge that has been validated and refined across multiple projects, providing a stable foundation for developing consistent and interoperable system architectures.
Exploiting RAs to guide the definition of concrete architectural models is crucial for ensuring that systems remain compliant with established domain knowledge and proven design principles, meet key quality attributes (e.g., reliability, security, modifiability) and organization-wide objectives, and reduce integration and evolution risks by preventing uncontrolled architectural drift [4]. Major cloud providers actively endorse the use of RAs to disseminate consolidated design knowledge. Amazon Web Services and Google Cloud maintain a catalog of reference architectures grounded in their Well-Architected Frameworks [5, 6]. Microsoft likewise stresses its importance, publishing hundreds of reference architectures in the Azure Architecture Center and supports them as proven best practices and patterns [7].
Once compliance with RAs is established, organizations can exploit it in several ways. At the project level, it supports automated impact analysis when a model evolves [8] and enables the systematic reuse of conforming architectural assets [9]. At the organizational level, it underpins architectural governance [10] and the continuous monitoring of architectural technical debt [11]. In this way, reference architectures become not only design blueprints but operational instruments for ensuring consistency, predictability, and long-term sustainability of software systems.
Many architectural models are now available across domains and repositories [12, 13, 14], yet very little is known about whether these models are actually compliant with their intended reference architectures, leaving organizations with a growing collection of artifacts whose architectural validity is uncertain. This gap is problematic: without explicit compliance knowledge, models cannot reliably support reuse and governance, and they risk drifting away from the quality attributes and constraints encoded in the reference architecture. Automatically determining compliance, however, remains a significant challenge because it requires discovering semantic correspondences between heterogeneous modeling constructs and interpreting architectural intent. In fact, models and RAs are typically authored by different stakeholders, each using their own vocabulary. The same architectural role may appear under different names, granularities, or decompositions, producing both semantic and structural mismatches that lexical or local reasoning cannot resolve. As a result, organizations possess many models, but lack the means to understand how these models relate to the available architectural standards.
Architecture conformance techniques, such as reflection models [15, 16], presuppose that the mapping between models has already been declared. Lexical matching techniques can exploit TF-IDF representation of components [17, 18], as well as generic schema [19] to discover relations between models and reference architectures, but cannot enforce the structural and mandatory constraints of an RA. Similarly, Sentence Embedding can abstract from specific identifiers to discover mappings between components, but fails to address the conformance constraints deriving from reference architectures [20, 21]. Alternatively, models and reference architectures can be compared as graphs, to discover possible matching components and relations [22], [23]. Yet graphs can hardly capture the semantic relation between models and RAs. To address these limitations, we propose Reference Architecture Mapping Discovery (RAMD), an LLM-assisted mapping pipeline that combines model analysis, the retrieval of domain knowledge from previously discovered mappings, structured LLM prompting, and a compliance-guided iterative refinement loop to automatically reconstruct the conformance relation between a model and its reference architecture. Our key insight is that LLMs can bridge vocabulary and granularity gaps when reasoning about individual component pairs, but they cannot easily enforce the global RA constraints that a valid mapping must satisfy. We therefore couple the LLM with an external compliance checker in a closed iterative loop: the LLM proposes a candidate mapping, and the checker validates the candidate against the RA constraints, returning any violation to the LLM as feedback for the next iteration.
We further equip RAMD with domain knowledge about mappings between models and reference architectures, exploiting a retrieval-augmented generation (RAG) mechanism [24]. We implemented RAMD for the Architecture Analysis & Design Language (AADL) model, which is an SAE International standard [25] for the model-based design of safety- and performance-critical embedded systems. It is widely adopted in avionics, automotive, and IoT [26], where it supports early architectural analysis, verification, and code generation [27], [28].
We evaluate RAMD on 64 open-source AADL models spanning three RAs: IoT Device System, Smart Parking System, and Self-driving Car System. We compare RAMD against three baselines based on lexical [17], [18], embedding [20], [21], and graph [22] comparison. Results show that, with domain knowledge and GPT-4o, RAMD achieves 85.8% overall mapping accuracy, outperforming the strongest baseline by 44.6 percentage points. RAMD is also the only evaluated approach that enforces the structural constraints of the RA. The presence of domain knowledge increases accuracy by +8.6 pp on average, while adding negligible token overhead.
In a nutshell, this paper makes the following contributions:
We characterize model-to-RA component mapping as a constrained matching problem,
We propose RAMD, a novel LLM-based compliance-guided iterative refinement loop that corrects RA-level violations, ultimately producing high-quality model-to-RA mappings,
We design a RAG mechanism that combines RA-catalog similarity with similarity over historical mappings to improve the quality of the discovered mappings,
We empirically evaluate RAMD on 64 AADL models across three RAs against three baselines. All replication artifacts, including code, data, prompts, and ground truth, are publicly available [29].
Background and Problem Definition
This section introduces AADL models, rigorously defines the mapping problem with Reference Architectures, and presents a running example used throughout the paper.
AADL Models
AADL [25] targets real-time, safety-critical embedded systems and provides specific support for validation and verification [27], [28], [30]. The language combines textual and graphical syntax with execution semantics and uses the XMI interchange format for model persistence and tool interoperability. AADL describes a system as a hierarchical assembly of strongly typed components [31]. The left side of Figure 1 shows an abstract visual representation of an AADL model.
Figure 1. Running example. Left: A Smart Home AADL model with nine components. Right: the IoT Device System RA with seven components.
More rigorously, an AADL model , where is the set of AADL component instances and is the set of connectors. Each component has a type that defines its externally visible interface. The language distinguishes software components (e.g., system, process, thread, data) from execution platform components (e.g., processor, memory, bus, device). Components interact through features, primarily ports with directions (in, out, or in/out). Connections link components typically wiring an outgoing port to an incoming port.
Reference Architectures
A Reference Architecture (RA) is a generic, domain-specific architecture that codifies the structural and functional expectations shared by systems within a class [1]–[3]. It captures design knowledge validated across multiple projects and supports standardization, reuse, and compliance checking [9]. We consider RAs composed of two elements: a textual specification and a structural model . These two elements are commonly present in many RAs, such as the diagrammatic representations offered by AWS [5], and Azure [7]. The Textual specification is a natural-language description that specifies the intended functional role of the components in the . The Structural model represents the essential structure and relationships that characterize systems within a given domain. To represent these models, we refer to the GRAMM metamodel [32], which is a well-known language to represent . More rigorously, ,
is the set of components in the RA. Each component has a set of attributes that include its name and type;
is the set of connectors among RA components. Each connector has mandatoryness (mandatory or optional), directionality (unidirectional or bidirectional), and multiplicity attributes;
associates each RA component with its natural-language description in .
Problem Definition
RAs are used to ensure adherence to established guidelines and principles. Conformance checking is assured by using the concept of incarnation mapping [33], which is a formal specification defining how elements in a reference model correspond to elements in the concrete model.
More rigorously, a mapping from to is a function that assigns to each model component either an RA component or the special symbol . The symbol is used when no RA component faithfully represents the role of the AADL component.
The mapping , by replacing each component type with the corresponding component type , generates a version of the model where concepts are expressed according to the vocabulary of the RA. We refer to this model as .
A mapping is plausible for if it is structurally complete and structurally compliant.
Structurally complete: There exists no such that .
Structurally compliant. must satisfy the required conformance relation (i.e., incarnation mapping) that enforces the constraints, rules, and characteristics in . We refer to the definition in [32] for a formal definition of the conformance relation. Note that in case engineers want to use a different conformance relation (e.g., one that allows for the violation of a subset of the constraints), any relation can be transparently plugged in RAMD.
Given a model and a reference architecture , the model-to-RA mapping problem consists of either discovering that is not consistent with , or discovering the correct mapping between and . Note that a correct mapping is necessarily plausible, but not all plausible mappings are correct. In fact, usually, there exist mappings of the elements in the model into elements of the RA that are logically wrong, that is, they contradict . Thus, the challenge is not only finding a plausible mapping, but discovering correct mappings.
Running Example
Figure 1 shows a Smart Home AADL model (left) and the IoT Device System RA (right) drawn from the A3D dataset [34]. The challenge lies in automatically reconstructing the mapping between them, shown in Figure 3 (c).
Figure 3. Compliance-guided iterative refinement on the running example.
The example exposes some of the difficulties in discovering correct mappings. First, the AADL category alone is not sufficient to solve the problem. Six of the nine components share the same category (process), yet they are mapped to three different RA components: Application, IoTIM, and Gateway. The correct assignment requires understanding the functional role of each component, considering the AADL component names and the RA descriptions ( not shown in the figure). A categorical or lexical matcher cannot resolve this gap, as also shown by our empirical results. An effective approach has to reason about each component in its broader context. Second, the correct assignment must respect the RA conformance relation. The pair zigbee_device_controller and zigbee_devices is connected in the AADL model. Their RA targets must therefore be linked by a relation that the RA permits, either a containment or a connection. Mapping the controller to Application and the device to Device would violate the RA constraints, since Application is neither contained in nor connected to Device. Such structural violations emerge only when the candidate mapping is validated as a whole against the RA. This is the role of our compliance check step that drives the iterative refinement loop of our pipeline.
Reference Architecture Mapping Discovery
RAMD takes an AADL model and a target reference architecture as input, and produces a final mapping that shows how the model can conform to the RA. Optionally, RAMD can leverage a set of known mappings between models and RAs. Figure 2 illustrates how RAMD works.
Figure 2. Overview of RAMD.
RAMD defines a Preprocessing stage that prepares the AADL architectural model, the RA, and the known mappings for the analysis, followed by the RA-driven refinement loop that iteratively improves the mapping, checking its compliance with the RA until obtaining the final mapping.
The process begins by cleaning the input architectural model (Model Preprocessing) to retain only semantically meaningful elements, and by uploading both reference-architecture components and any available historical domain knowledge into a vector database so they can be semantically retrieved during mapping (RA and Known Mappings Embedding). This ensures that the LLM operates on a concise, information-rich representation of the model and can draw on both RA definitions and prior mappings (Component Retrieval). Using this semantic context, the LLM generates candidate mappings (Mapping Generation), either component-by-component or for the entire model, and these hypotheses are iteratively refined through compliance validation (RA Compliance Validation). To avoid oscillations, the system periodically reconstructs a stable mapping by combining insights from the most recent hypotheses (Mapping Reconstruction).
We discuss below how each step is defined.
Model Preprocessing
The Model Preprocessing step removes the irrelevant or potentially noisy details from the model to focus on the elements that carry the most relevant semantic information. For this reason, this step extracts the name, category, features, and connections of each component, discarding the rest of the information, such as timing annotations and platform-specific clauses, not contributing to the definition of the role and responsibilities of a component.
The result, namely the Cleaned Model, is serialized into a compact JSON format that is much shorter than the raw model representation, making it more suitable for LLM-based analysis. Listing 1 shows an excerpt of the Cleaned Model for the zigbee_device_controller component of the running example.
Listing 1. Cleaned Model for the zigbee_device_controller.
"name": "zigbee_device_controller",
"category": "process",
"features": [
{"name": "dev_data_receiver", "dir": "in"},
{"name": "dev_data_sender", "dir": "out"},
...
],
"connections": [
"zigbee_devices.out_zd_mcr->
zigbee_device_controller.dev_data_receiver",
...
]
Model Preprocessing is the only AADL-specific step of RAMD, since all the following steps operate on the Cleaned Model. Therefore, RAMD can be adapted to another ADL or modeling notation, such as SysML or UML, by replacing this extractor with one that maps the target notation onto the same JSON schema.
RA and Known Mappings Embeddings
To create an RA whose components can be semantically retrieved, for each RA component, RAMD creates a chunk with the component name, declared features, and description, and embeds it in the RA vector database with a sentence-transformer model [20]. Similarly, if the knowledge about some correct mappings between models and RAs is available, RAMD creates a chunk with every known pair, where is the component that incarnates the component in the RA. This chunk is embedded in the Known Mappings vector database and used to inform the mapping procedure.
Mapping Generation
Mapping Generation uses an LLM to analyze the semantic information available and produce a candidate mapping according to two strategies: the all-at-once strategy (), which produces a candidate mapping from the cleaned model all at once; and the per-component strategy (), which produces a candidate mapping by analyzing one component at a time.
The all-at-once strategy embeds both the whole cleaned model and the full RA description in a single prompt. The models are represented textually by first listing component information, then the edges, and finally the textual descriptions.
The per-component strategy maps each component of the cleaned model independently. Each prompt includes information about the component to be mapped together with its direct neighbors to provide the LLM with a minimal degree of structural awareness, even though all components are processed one at a time. When no prior knowledge about correct mappings is available, the prompt is simply enriched with the top candidate RA components identified through Component Retrieval (see next section), which searches the RA database for the most semantically similar components to the one under analysis. When historical knowledge is available, Component Retrieval also exploits it to refine the set of retrieved components. Finally, RAMD aggregates the per-component predictions into a complete mapping that includes all components of the model.
The all-at-once strategy has the benefit of considering the full model when producing the mapping, thereby leveraging the full contextual information. On the negative side, considering the full model may overwhelm the LLM. The per-component strategy has the benefit of analyzing a component in depth, but the amount of contextual information considered is limited to the neighbors of the analyzed component.
In both cases, each prompt has four blocks.
A task description that states the mapping goal and the output that must consist of a list of (component, RA component) pairs in a machine-readable format.
The components to map. In , it lists every component that must be mapped. In , it lists a single component and its neighbors.
The RA context, namely the relevant RA components, their containment relations, and their descriptions. In , it includes the full RA. In , the relevant components are the ones returned by Component Retrieval (see next section).
An optional set of canonical few-shot examples drawn from a held-out part of the dataset.
Listing 2 shows an excerpt of a prompt for the zigbee_device_controller component of the running example. The labels in brackets mark the four blocks. The RA descriptions and the few-shot examples are shortened for space. The rest of the prompts used in the evaluation are part of our reproduction package.

Figure 2 (PDF p. 5). Excerpt of a prompt for the running example.
[Task description]
Select EXACTLY ONE best label (component name) for the
target node. All labels MUST be chosen from the RA component
names below.
...
[Components to map]
Target node name: zigbee_device_controller
Neighbor node names:
- zigbee_devices
- main_controller
[RA context]
Reference Architecture component labels (name: description):
- Gateway: Handles communication between devices and higher-
level layers when direct connectivity is not possible ...
...
[Few-shot examples]
...
The mapping generated by the LLM is automatically converted into the XMI format required by the RA compliance checking tool [32].
When the refinement loop is active, the mapping generation is also executed to improve a non-compliant mapping. In such a case, the prompt changes in two blocks: (i) the task description also includes the list of detected violations and incorporates the recommendation to keep unchanged the mappings that do not cause violations, and to revise only the mappings that cause a violation, and (ii) the structured components to be mapped include the current mapping, and not only a list of components to be mapped.
Component Retrieval
When the per-component strategy is used, the Component Retrieval step automatically retrieves the RA components that must be considered for mapping the given component from the RA DB and from the Known Mappings DB. From the RA DB, RAMD retrieves the semantically closest RA components to and embeds them in the Mapping Generation prompt. For instance, for the zigbee_device_controller component in the running example, the retrieved candidates are Gateway, IoTLM, and Device, as shown in Listing 2.
If the Known Mappings DB is also available, RAMD first retrieves the most similar model components to , then reads their ground-truth RA assignments and returns the retrieved RA component as additional candidate suggestions. In particular, RAMD combines the similarity scores of the items retrieved from the RA db and the Known Mappings db into a single list of RA candidates, and the top entries are finally selected.
Iterative RA Compliance-Validation
The compliance check decides whether a candidate mapping for a model is structurally compliant with the available RA. RAMD uses the rule-based RA validator presented in [32] to identify a possibly empty list of violations between and .
If the set of violations is empty, the candidate is compliant, and the loop stops. Otherwise, the list of violations, each consisting of an error message and a list of components causing the error, is used by the Mapping Generation to produce a new candidate solution.
The loop terminates when one of these conditions holds: (i) the current mapping is compliant with ; (ii) the iteration count reaches the maximum ; or (iii) the candidate stays unchanged for consecutive iterations.
Figure 3 shows how the iterative refinement of a candidate mapping works for the running example. In the first attempt of producing a mapping, RAMD maps architectural components to RA components as shown in Figure 3(a). An architectural component drawn inside an RA component indicates that is mapped to . In this case, the validator reports two relationType violations. Each one states that the RA allows no connection from Application to Gateway. The validator lists the four offending components, namely client control unit, client controller, remote msg control, and router controller. They appear with a red outline in the figure. Based on this feedback, the Mapping Generation revises the mapping. It moves client controller from Gateway to Application, shown in the green dashed box. This change removes one of the two forbidden Application-to-Gateway connections. It leaves the compliant assignments untouched, as shown in Figure 3(b). When checked for violations, the violation count drops to 1. This triggers another refinement round. The Mapping Generation then moves remote msg control to IoTLM, which removes the second forbidden connection. The final result is shown in Figure 3(c). The final candidate passes all constraints, and RAMD returns it.
Mapping Reconstruction
We observed that the computed solution may sometimes oscillate across iterations, with successive candidates trading one violation for another without converging. To break this pattern, RAMD runs a reconstruction step every iterations. The reconstruction prompt receives the last mapping candidates that have been generated and the corresponding feedback from the validator, and queries the LLM to synthesize a new candidate that merges the correct part of each mapping. The reconstructed mapping replaces the current candidate, and the next iteration starts.
Experimental Setup
Research Questions
We organize our evaluation around six research questions.
RQ1 (Strategy) How do the all-at-once and per-component strategies perform?
RQ2 (Ablation) How do the individual components of RAMD affect its effectiveness?
RQ3 (Domain Knowledge) How does the domain knowledge given by the Known Mappings affect the results?
RQ4 (Architectural Complexity) How do the characteristics of the AADL models and of the RAs affect the accuracy of RAMD?
RQ5 (Comparison with baselines) How does RAMD compare to baseline approaches?
RQ6 (Model capacity) How does the capacity of the underlying LLM influence results?
Dataset
We use a public curated dataset with three RAs of different sizes and domains, paired with a collection of open-source AADL models [34]. To our knowledge, it is currently the only public dataset that pairs architectural models with an explicit RA specification and component-level ground-truth mappings across multiple domains. Other public model collections do not meet this requirement. The benchmark by Fuchß et al. [12] offers traceability links between architecture documentation and models, while ModelSet [13] and the extended EA ModelSet [14] provide only model-level labels. None of them relates individual components to RA elements, which is the information needed to evaluate a model-to-RA mapping.
| RA | # Comp. | # Conn. | # Models | # Comp. | # Conn. |
| IoT Device | 7 | 6 | 25 | 7.6 | 7.8 |
| Self-driving Car | 10 | 16 | 10 | 18.1 | 22.4 |
| Smart Parking | 21 | 22 | 29 | 8.3 | 4.2 |
| Average | 12.7 | 14.7 | 64* | 9.6 | 8.4 |
Table 1. Overview of the dataset: three RAs and the corresponding AADL models.
*Total number of models.
Table I shows the structure of each RA and the characteristics of the corresponding models used in our experiments. Columns #Comp. and #Conn. report the number of components and connectors [35] of each RA and the average number per AADL model. Column #Models reports the number of compliant models for each RA. The last row reports averages, except for #Models, which reports the total. The mappings in the dataset have all been produced after the cutoff dates of the models we used in the evaluation.
The RAs span heterogeneous domains. The IoT Device System RA captures the typical decomposition of an IoT deployment, illustrated by the running example of Section II-D. The Smart Parking System RA models the components of a smart-parking infrastructure, such as parking spots, vehicle detectors, controllers, and user-facing services. The Self-driving Car System RA captures the functional modules of an autonomous vehicle, including perception, localization, planning, control, and the associated sensor and actuator interfaces. All three RAs are provided as Ecore metamodels [32], [36] with natural-language descriptions of each component.
The AADL models are open-source instances of systems whose architecture falls into one of the three target domains. The dataset reports the ground-truth mapping between each model and its RA.
Baselines
We considered various classes of techniques as baseline approaches.
We first considered architecture conformance approaches [15], [32], [37], [38]. However, they cannot serve as baselines because they all assume the model-to-RA mapping is given rather than discovered.
We also examined the 67 matching systems named or cited in multiple relevant survey papers [19], [22], [39, 40, 41], but only 10 of them still provide publicly available source code. Among these, AgreementMaker [42] and LogMap [43] are the closest to our setting. However, both operate on OWL and RDF ontologies and rely mainly on lexical matching. As a result, they cannot represent AADL component categories, port directions, or the distinction between containment and connection. Adapting them would require substantial extensions that would bias the comparison.
To answer RQ5, we instead used as baselines those reference algorithms underlying these matching systems that are applicable to the AADL-to-RA mapping problem. In particular, we identified three baselines operating at the lexical, semantic, and structural level. All the baselines are included in our replication package [29]. We describe the three selected baselines below.
TF-IDF lexical matching: It computes the TF-IDF representation [17], [18] of each AADL component (using its name, features, and category) and of each RA component (using its name and textual description), and associates AADL components with RA components based on their cosine similarity. This baseline captures lexical overlap without semantic generalization.
Sentence-embedding similarity: It projects each component into a 384-dimensional semantic space using the pre-trained all-MiniLM-L6-v2 [21] model. The cosine similarity is again used to establish the mapping between components. This baseline captures semantic overlap.
Graph-based structural similarity: This baseline computes mappings by comparing the architectural characteristics of AADL components and RA elements [22]. Each component is represented by structural attributes, including its type, hierarchical parent, neighboring connections, communication interfaces, and connectivity degree. The similarity between components guides the creation of the mapping.
Evaluation Metrics
To answer RQ1-RQ3, RQ5, and RQ6, we use three metrics to characterize the cost-quality trade-offs of the evaluated approaches.
a) Accuracy: We adopt the standard accuracy metric to measure the quality of the mapping, defined as the proportion of AADL components on which the produced mapping agrees with the ground truth. For each RA, we compute the accuracy averaged across all AADL models. For the overall comparison, we report average values across the three RAs.
b) Runtime: Runtime is the wall-clock time, in seconds, required to produce the final mapping for a given AADL model. It includes all LLM calls, retrieval operations, and compliance-checking steps. We report the average over the AADL models of each RA.
c) LLM cost: LLM cost is the total number of input and output tokens consumed by the LLM during the mapping of a single AADL model. The cost includes the tokens introduced by iterative refinement and mapping reconstruction.
Experimental Methodology
RQ1 (Strategy): This RQ compares the all-at-once and per-component strategies described in Section III-C. To directly measure the effect of the strategies, we measure the quality of the mapping as outputted by these two strategies without any iterative refinement or mapping reconstruction.
RQ2 (Ablation): In this research question, we evaluate RAMD considering all its components enabled, with the exception of the Known Mappings, which represent an external domain knowledge that is not always available, and it is thus assessed independently in RQ3. To study the impact of each component of the solution, we also assess RAMD by selectively removing one element at a time. In particular, for compliance check, we run RAMD with and without the iterative loop presented in Section III-E; for few-shot learning, we compare zero-shot prompting against a setting with two basic examples covering the case of a process-to-functional and a device-to-physical mapping; for iteration stability, we compare RAMD with and without the Mapping Reconstruction step; and for RA representation, we compare RAMD using the RA DB fed only with RA component names or fed also with RA component descriptions.
RQ3 (Domain Knowledge): This RQ investigates the impact of the Component Retrieval step when domain knowledge is available. The domain knowledge is a set of known mappings stored in the Known Mappings DB. In our experiment, we upload the ground-truth mappings in our dataset, excluding every time the ones about the model under analysis. We compare RAMD with and without access to this DB.
RQ4 (Architectural Complexity): This RQ investigates whether the complexity of the AADL models and of the RAs affects the accuracy of RAMD. For each AADL model, we measure four complexity dimensions, namely size (number of components), connectivity (graph density), hierarchy (maximum containment depth in the AADL instance model), and naming ambiguity (mean entropy of the TF-IDF similarity between each component and the RA components). We compute the Spearman correlation between each dimension and the accuracy on each AADL model, applying the Holm-Bonferroni correction [44] across the four dimensions. For the RAs, we relate accuracy to their number of components and connections.
RQ5 (Comparison with baselines): This RQ compares our approach to the three baselines presented in Section IV-C.
RQ6 (Model Capacity): This RQ investigates the impact of the size of the LLM on the results. It compares the results obtained with GPT-4o-mini, which is the model used in every other RQ, to the ones obtained with GPT-4o, to assess the possible benefit of a larger model of the same family.
Since the outputs of LLMs are non-deterministic, for each configuration, we report average values obtained from five repetitions. We characterize the magnitude of differences between configurations using Cliff’s delta [45], a non-parametric effect-size measure that is robust to small samples and does not assume a specific distribution. Following standard thresholds [46], we interpret as negligible, as small, as medium, and as large.
Tool Implementation and configuration
Our RAMD implementation processes models using the Eclipse Modeling Framework (EMF) [36], and validates them against the RA using the tool implemented in [32]. All LLM calls go through the official OpenAI API1 with the temperature fixed to 0 across all configurations. Based on initial runs, we set the maximum iterations , same-mapping constraint , and the reconstruction window . In the per-component strategy with hybrid retrieval, the top- parameter is set to . The RAMD implementation, the prompts used in each configuration, and the raw experimental logs are released on GitHub [29] and archived on Zenodo [47].
Results and Analysis
RQ1: Strategy
We first discuss the accuracy and cost of the all-at-once strategy () and the per-component strategy (). Table II shows the results. outperforms by +4.3 pp on average (+3.1 pp IoT, +2.4 pp self-driving, +7.4 pp smart parking), with Cliff’s (medium). The improvement is consistent across domains. It shows that decomposing a large AADL model into focused per-component queries is more effective than asking the LLM to solve the entire mapping in one shot. The reason is that a single query forces the LLM to reason about all components at once, which dilutes its attention on each mapping decision. instead keeps each query small and centered on one component and its neighbors. However, incurs a 4 to 10 times token overhead and a 3 to 9 times longer runtime, since each component requires a separate API call.
| RA | acc | tokens | runtime | acc | tokens | runtime |
| IoT | 66.5% | 106K | 564s | 69.6% | 1,049K | 5095s |
| Self-driving Car | 61.2% | 119K | 925s | 63.6% | 583K | 3775s |
| Smart Parking | 59.3% | 193K | 1253s | 66.7% | 802K | 3930s |
| Overall | 62.3% | 135K | 868s | 66.6% | 789K | 4228s |
Table II. Comparison between and across RAs.
Ensuring a high-quality and reliable mapping often takes precedence over reducing runtime or token consumption. This is the case especially when better mapping accuracy translates into less effort and time required from architects to interpret and adopt the results. We therefore use for the remainder of the evaluation, with the caveat that remains a cheaper, albeit less accurate, alternative when needed.
RQ2: Ablation
In this RQ, we measure the effectiveness of RAMD when the full workflow is active, with the only exclusion of the domain knowledge represented by the Known Mappings DB, which is not studied in this RQ but investigated in RQ3. In addition, to assess the impact of each step, we present the results obtained by removing each component: , which is RAMD without the conformance checking loop; , which is RAMD without the few-shot examples; , which is RAMD using the RA component names instead of the full RA specification ; and , which is RAMD without the mapping reconstruction step. Figure 4 reports the accuracy and the token consumption on the two axes. The size of each dot encodes the runtime cost. Configurations on the Pareto front are drawn with a black outline.
Figure 4. Ablation study. Accuracy versus total LLM tokens for each configuration, in each domain and overall. The marker size is proportional to the runtime. The black outline marks the Pareto-optimal configurations.
RAMD reaches the highest accuracy overall, at 74.0%, and it is the most accurate configuration in every domain. Each removed component lowers the accuracy, which confirms that every step contributes to the final accuracy result. The few-shot examples are the single most important component. Removing them () causes the largest accuracy loss, −6.4 pp on average, with the largest effect size, Cliff’s (large). The mapping reconstruction follows with −5.7 pp (Cliff’s , medium). The RA specification causes a smaller average loss of −4.1 pp, but its effect size is large (Cliff’s ), which means that removing the full produces a difference that is smaller on average yet more consistent across runs. The conformance checking loop has the smallest accuracy impact, −3.7 pp (Cliff’s , medium), but it plays a relevant role on cost and on the guarantee the mapping delivers a technically plausible solution, as discussed below.
Removing a component does not consistently reduce the cost, since its effect varies across domains. A special case is the removal of the conformance checking loop, which causes an increase in cost with 944K tokens consumed and a comparable runtime. Without the compliance feedback, the loop loses its convergence signal and keeps refining until the mapping reconstruction produces a final mapping. The conformance check thus improves accuracy and makes the search more efficient.
RQ3: Domain Knowledge
This RQ considers the impact of the domain knowledge stored in the Known Mappings DB (Section III). Table III compares RAMD with RAMD+KM, the variant that retrieves from the Known Mappings DB.
| RA | RAMD acc | RAMD tokens | RAMD runtime | RAMD+KM acc | RAMD+KM tokens | RAMD+KM runtime |
| IoT | 74.4% | 643K | 1132s | 83.7% | 868K | 1833s |
| Self-driving Car | 73.0% | 178K | 1056s | 82.6% | 158K | 458s |
| Smart Parking | 74.7% | 187K | 2995s | 81.6% | 174K | 725s |
| Overall | 74.0% | 278K | 1529s | 82.6% | 287K | 848s |
Table III. COMPARISON BETWEEN RAMD AND RAMD+KM ACROSS RAs.
Domain knowledge has a positive impact on accuracy across all domains. The gain is +9.3 pp on IoT, +9.6 pp on self-driving, and +6.9 pp on smart parking, for an average of +8.6 pp. RAMD+KM reaches an overall accuracy of 82.6%, with Cliff’s (large). Retrieving from the Known Mappings DB provides the LLM with high-quality in-context examples. These examples are selected at runtime for the component under analysis, so the prompt carries evidence of how similar components were mapped in the past.
The token overhead of this gain is small, 1.04× on average. On self-driving and smart parking, the domain knowledge even lowers the token cost to 0.89× and 0.93×. The retrieved examples let the compliance loop converge in fewer iterations, which reduces the number of LLM calls. IoT is the only exception. Its larger component vocabulary inflates the retrieval context to 1.35×.
The runtime follows the same pattern as the token cost. RAMD+KM is faster on self-driving (458s against 1056s) and on smart parking (725s against 2995s), because the loop converges sooner. The overall runtime drops from 1529s to 848s. IoT is again the exception, with the runtime growing from 1132s to 1833s, in line with its larger retrieval context.
In a nutshell, domain knowledge significantly improves accuracy. Its effect on cost is small, and in two of the three domains, it is even beneficial.
Architectural Complexity
Model size is the only dimension with a significant effect. The accuracy of RAMD+KM decreases as AADL models grow larger (, ), while RAMD shows the same trend without reaching significance (, ). In contrast, connectivity, hierarchy, and naming ambiguity show no significant correlation for either approach (, ). As for the RAs, which are too few to support a statistical analysis, accuracy shows no visible trend with respect to their number of components and connections.
In a nutshell, results obtained with large models may require more careful validation than those obtained with smaller ones.
Comparison with Baselines
Figure 5 compares RAMD and RAMD+KM to the three baselines.
Figure 5. Accuracy (%) per domain and overall (left), and geometric-mean runtime with per-domain points overlaid (right, log scale).
RAMD+KM outperforms every baseline by a large margin in all three domains. The gap over the strongest baseline of each domain ranges from +15.4 pp to +50.6 pp. On self-driving car and smart parking, no baseline exceeds 40.9%, while RAMD achieves 73.0% accuracy at minimum. The advantage is consistent also without domain knowledge: RAMD alone overall reaches 74.0% accuracy. The effect size is large in every pairwise comparison, with Cliff’s .
The baselines are domain-dependent and often brittle. Sentence-embedding is the best baseline on IoT and smart parking, but it collapses to 14.4% on self-driving, where it fails to capture the domain-specific semantics of the RA. TF-IDF and graph similarity are the weakest methods overall, at 27.5% and 24.2%. This confirms that surface lexical overlap and structural heuristics alone are insufficient for reliable mapping.
The accuracy of our approach comes with a higher runtime. RAMD+KM needs 848 s on average, while the baselines need at most 19 s. The extra time is due to the LLM calls, the RA compliance validation step, and the multiple refinement iterations that identify a high-quality mapping. Given the accuracy gap of +41.4 pp, this trade-off is worthwhile, especially in offline settings without strict timing requirements. Beyond accuracy, our approach is the only one that guarantees conformance with the RA. None of the three baselines can enforce this property.
Model Capacity
This RQ studies the impact of the underlying LLM. We upgrade the model from GPT-4o-mini to GPT-4o, keeping every other component of RAMD+KM unchanged. Both models belong to the same family, allowing us to isolate the effect of model capacity. Table IV reports the results.
| RA | RAMD+KM (GPT-4o-mini) | RAMD+KM (GPT-4o) | ||||
| acc | tokens | runtime | acc | tokens | runtime | |
| IoT | 83.7% | 868K | 1833s | 85.2% | 234K | 470s |
| Self-driving Car | 82.6% | 158K | 458s | 86.8% | 159K | 275s |
| Smart Parking | 81.6% | 174K | 725s | 85.4% | 180K | 425s |
| Overall | 82.6% | 287K | 848s | 85.8% | 188K | 380s |
Table IV. Comparison between RAMD+KM with GPT-4o-mini and GPT-4o.
The larger model improves the accuracy in every domain. The gain is +1.5 pp on IoT, +4.2 pp on self-driving, and +3.8 pp on smart parking, for an overall gain of +3.2 pp. The peak accuracy is 86.8% on self-driving. GPT-4o reaches an overall accuracy of 85.8%, which is the best result of our study and exceeds the strongest baseline by 44.6 pp (RQ5). The effect size is large, with Cliff’s .
More notably, GPT-4o also lowers the cost. The mean token count drops to of the GPT-4o-mini cost, and the overall runtime drops from 848s to 380s. This result may look counterintuitive, since a larger model is usually more expensive per call. The same effect appears for the compliance loop in RQ2. A more capable model produces correct mappings on the first compliance iteration for most components. This avoids the cascading refinement rounds that drive up the token budget for GPT-4o-mini.
The token saving is uneven across domains. It is largest on IoT, where the count drops to (234K against 868K). IoT is the domain where GPT-4o-mini needs the most refinement, as its high token cost in RQ3 shows. A stronger model removes most of these extra iterations, so the saving is concentrated there. On self-driving the token count is almost unchanged (159K against 158K), because GPT-4o-mini already converged quickly on that domain.
In a nutshell, a more capable model raises the overall accuracy to 85.8% while reducing the token and runtime budget.
Threats to Validity
Construct validity: Construct validity depends on the correctness of the ground-truth mappings. We used the ground-truth set publicly released, which covers all 64 AADL models in our dataset and was constructed independently of this study. This separation reduces the risk that the evaluation rewards mappings biased toward our approach.
Internal validity: A key factor that may affect internal validity is LLM stochasticity. To address this concern, we set the temperature to 0, made five repeated runs of each configuration, and reported the Cliff’s delta to characterize the magnitude of differences.
External validity: External validity is limited by the scale and scope of the evaluation. The dataset covers 64 AADL models across three RAs [34], which span heterogeneous domains but cannot represent the full range of architectural styles, sizes, and modeling conventions. However, evidence is consistent across three distinct domains, which increases confidence in the results and their validity. Furthermore, the evaluation is limited to AADL models. While the approach is largely language-agnostic, its effectiveness on other architecture description languages remains to be investigated. Finally, replicating the study with LLMs beyond the GPT-4o family, including open-weight ones, is left to future work.
Discussion
This section discusses the main lessons learned from our experiments.
Domain knowledge can matter more than model capacity: Known mappings improve accuracy by 8.6 pp (RQ3), whereas a larger LLM adds 3.2 pp (RQ6). For this reason, building a repository of validated mappings can be a more effective way to improve accuracy than adopting a larger LLM.
The mapping is a starting point for the architect: The ground truth contains only correct mappings, so accuracy measures the proportion of components that RAMD maps correctly, not only plausibly. Even in the best configuration (RQ6), some components receive a mapping that may satisfy the RA constraints but does not match the role described in RAspec (§ 2-C). Consequently, the output of RAMD still requires manual validation by the architect, especially for large models, whose accuracy is lower (RQ4).
Violations can reveal incompatible models: Our dataset only contains AADL models that comply with their RA, but the problem definition also covers incompatible models (§ 2-C). RAMD signals this case when the compliance loop does not reach zero violations within iterations (§ 3-E), or when the reconstructed mapping leaves some components unassigned. To test these signals, we paired three IoT and Smart Home models with the Smart Parking RA. In all three cases, RAMD returned its best mapping together with unresolved violations involving mandatory components or mandatory connectors. This small experiment gives initial evidence that these violations can reveal an incompatible model.
Related Work
The problem of relating a concrete artifact to a higher-level reference is studied in two adjacent areas. Architecture conformance checking verifies whether an implemented system respects an intended architecture. The reflexion-model technique [15] and subsequent constraint-based and rule-based extensions [16, 48, 49] require the architect to declare the intended architecture and to map source-code elements to it, after which the tool detects deviations. These techniques share with ours the goal of relating a concrete artifact to a higher-level reference, but they assume the mapping is available and concentrate on detecting violations. The problem we tackle is the dual one, namely, producing the mapping itself.
Schema and ontology matching identifies correspondences between heterogeneous structured artifacts using lexical, embedding-based, and structural similarity signals. Classical surveys and the Euzenat–Shvaiko textbook provide a comprehensive account of the area [19, 39, 40, 41]. These techniques are limited by two factors. First, they treat the two artifacts as sets or generic labeled graphs and do not enforce the structural and mandatory-component constraints that an RA imposes. Second, the heterogeneity gap between a model instance and an RA often exceeds the bridging capacity of similarity-based matchers, as confirmed in our empirical evaluation.
A growing body of work investigates LLMs in software engineering [50, 51, 52] and in model-driven engineering in particular. LLMs have been used to generate or repair Ecore instance models from natural language [53], to combine model-based specifications with formal verification in the automotive domain [54], and to translate between informal specifications and domain-specific languages [55]. A particularly active line of research applies LLMs to ontology alignment. He et al. [56] demonstrated the zero-shot capability of GPT and Flan-T5 on OAEI benchmarks. Ciglu et al. [57] proposed LLMS4OM, which combines retrieval-augmented generation with zero-shot prompting. Subsequent work has explored complex alignments [58], LLM-based oracles [59], and retrieval-driven search strategies [60]. These approaches confirm that LLMs are an effective tool for aligning heterogeneous semantic artifacts, but they target unconstrained ontologies rather than RAs. They consequently do not consider the many structural and mandatory-component constraints specific to RAs.
A related line of research is the one on continuous architectural conformance [32, 37, 38]. The MORE approach [32] models RAs as metamodels and checks the conformance of a Software Architecture to an RA through model-driven techniques. The AssistRA tool [37] extends this with a continuous-conformance distance function for incremental, non-blocking validation. The work by Rubei et al. [38] can interact with an LLM-based recommender to suggest a corrected architecture once a violation has been detected.
RAMD shares with this line of work the combination of LLM reasoning with formal RA metamodels. However, RAMD addresses a fundamentally different problem. Continuous architectural conformance assumes that the component-to-RA mapping has already been declared by the architect, and focuses on repairing individual violations. RAMD instead generates compliant model-to-RA mappings without imposing any requirement on the architect. The two classes of approaches can be potentially combined to generate a mapping and then improve it based on the feedback of the architect.
Conclusion
We presented RAMD, an approach that discovers the mapping between an architectural model and its RA by integrating model preprocessing, domain knowledge retrieval, LLM-driven semantic analysis, and iterative constraint-checking refinement. On 64 open-source AADL models across three RAs, RAMD with domain knowledge and GPT-4o reached 85.8% accuracy, improving over the best baseline by 44.6 pp, while meeting the RA structural and mandatory-component constraints by construction. Future work concerns integrating RAMD with continuous-conformance tools so that its output can serve as the starting point for repairing violations as the model evolves. Moreover, we will investigate how to exploit the extensive documentation that often accompanies RAs, such as standards and discussions of architectural patterns, to enrich the contextual information available to the LLM.
References
- [1]S. Angelov, P. Grefen, and D. Gr€eehorst, “A framework for analysis and design of software reference architectures,” Information and Software Technology, vol. 54, no. 4, pp. 417–431, 2012.DOI
- [2]E. Y. Nakagawa, F. Oquendo, and J. C. Maldonado, “Reference architectures,” Software Architecture 1, pp. 55–82, 2014.DOI
- [3]R. Cloutier, G. Muller, D. Verma, R. Nilchiani, E. Hole, and M. Bone, “The concept of reference architectures,” Systems Engineering, vol. 13, no. 1, pp. 14–27, 2010.DOI
- [4]M. R. Ramli and F. Asplund, “Reference architectures as boundary objects in the co-engineering of system properties: An empirical study,” Journal of Systems and Software, vol. 220, p. 112264, 2025. [Online]. Available: https://www.sciencedirect.com/science/article/pii/ S016412122400308XDOI
- [5]Amazon Web Services, “AWS architecture center,” https://aws.amazon.com/architecture/, 2026, accessed: 2026-06-10.
- [6]Google, “Google Cloud architecture center,” https://cloud.google.com/ architecture, 2026, accessed: 2026-06-10.
- [7]Microsoft, “Azure architecture center,” https://learn.microsoft.com/ en-us/azure/architecture, 2026, accessed: 2026-06-10.
- [8]S. Lehnert, “A taxonomy for software change impact analysis,” in Proceedings of the 12th International Workshop on Principles of Software Evolution and the 7th annual ERCIM Workshop on Software Evolution, 2011, pp. 41–50.DOI
- [9]L. Garcés, S. Martínez-Fernández, L. Oliveira, P. Valle, C. Ayala, X. Franch, and E. Y. Nakagawa, “Three decades of software reference architectures: A systematic mapping study,” Journal of Systems and Software, vol. 179, p. 111004, 2021.DOI
- [10]L. De Silva and D. Balasubramaniam, “Controlling software architecture erosion: A survey,” Journal of Systems and Software, vol. 85, no. 1, pp. 132–151, 2012.DOI
- [11]T. Besker, A. Martini, and J. Bosch, “Managing architectural technical debt: A unified model and systematic literature review,” Journal of Systems and Software, vol. 135, pp. 1–16, 2018.
- [12]D. Fuchß, S. Corallo, J. Keim, J. Speit, and A. Koziolek, “Establishing a benchmark dataset for traceability link recovery between software architecture documentation and models,” in European Conference on Software Architecture, 2022.
- [13]J. A. H. López, J. L. C. Izquierdo, and J. S. Cuadrado, “Modelset: A labelled dataset of software models for machine learning,” Science of Computer Programming, vol. 231, p. 103009, 2024.
- [14]P.-L. Glaser, E. Sallinger, and D. Bork, “The extended ea modelset—a fair dataset for researching and reasoning enterprise architecture modelling practices,” Software and Systems Modeling, pp. 1–19, 2025.DOI
- [15]G. C. Murphy, D. Notkin, and K. J. Sullivan, “Software reflexion models: Bridging the gap between design and implementation,” IEEE Transactions on Software Engineering, vol. 27, no. 4, pp. 364–380, 2001.DOI
- [16]L. Passos, R. Terra, M. T. Valente, R. Diniz, and N. Mendonça, “Static architecture-conformance checking: An illustrative overview,” IEEE software, vol. 27, no. 5, pp. 82–89, 2009.DOI
- [17]G. Salton and C. Buckley, “Term-weighting approaches in automatic text retrieval,” Information processing & management, vol. 24, no. 5, pp. 513–523, 1988.DOI
- [18]H. Schütze, C. D. Manning, and P. Raghavan, Introduction to information retrieval. Cambridge University Press, Cambridge, 2008, vol. 39.
- [19]P. Shvaiko and J. Euzenat, “Ontology matching: state of the art and future challenges,” IEEE Transactions on knowledge and data engineering, vol. 25, no. 1, pp. 158–176, 2011.DOI
- [20]N. Reimers and I. Gurevych, “Sentence-bert: Sentence embeddings using siamese bert-networks,” in Proceedings of the 2019 conference on empirical methods in natural language processing and the 9th international joint conference on natural language processing (EMNLP-IJCNLP), 2019, pp. 3982–3992.arxiv.org/abs/1908.10084
- [21]C. Jin and Z. Zhang, “A study of sentence similarity based on the all-minilm-l6-v2 model with “same semantics, different structure” after fine tuning,” in 2024 2nd International Conference on Image, Algorithms and Artificial Intelligence (ICIAAI 2024). Atlantis Press, 2024, pp. 677–684.
- [22]D. Conte, P. Foggia, C. Sansone, and M. Vento, “Thirty years of graph matching in pattern recognition,” International journal of pattern recognition and artificial intelligence, vol. 18, no. 03, pp. 265–298, 2004.DOI
- [23]T. D. Tran, M. T. Rossi, D. Soldati, M. Sonzogni, A. D. Salle, L. Iovino, and L. Mariani, “Structural-semantic clustering for architectural models,” Journal of Object Technology, vol. 25, no. 3, pp. 3:309–322, 2026.
- [24]P. Lewis, E. Perez, A. Piktus, F. Petroni, V. Karpukhin, N. Goyal, H. Küttler, M. Lewis, W.-t. Yih, T. Rocktäschel et al., “Retrieval-augmented generation for knowledge-intensive nlp tasks,” Advances in neural information processing systems, vol. 33, pp. 9459–9474, 2020.arxiv.org/abs/2005.11401
- [25]P. H. Feiler and D. P. Gluch, Model-based engineering with AADL: an introduction to the SAE architecture analysis & design language. Addison-Wesley, 2012.
- [26]Y. Zou, Z. Yang, H. Liu, J. Liang, Y. Zhou, and Z. Gu, “Automated aadl architecture modeling: Leveraging large language models for safety-critical software,” in International Conference on Model Driven Engineering Languages and Systems Companion, 2025.DOI
- [27]A. Johnsen, K. Lundqvist, P. Pettersson, and O. Jaradat, “Automated verification of aadl-specifications using uppaal,” in IEEE International Symposium on High-Assurance Systems Engineering, 2012.DOI
- [28]H. Mkaouar, B. Zalila, J. Hugues, and M. Jamiel, “A formal approach to aadl model-based software engineering,” International Journal on Software Tools for Technology Transfer, vol. 22, no. 2, pp. 219–247, 2020.
- [29]T. D. Tran, M. T. Rossi, L. Iovino, and L. Mariani, “Github replication package,” https://github.com/RAMD2026/RMD.git, 2026.
- [30]P. H. Feiler, D. P. Gluch, and J. Hudak, “The architecture analysis & design language (aadl): An introduction,” 2006.
- [31]J. Hugues and G. Brau, “Analysis as a first-class citizen: an application to architecture description languages,” in IEEE International Symposium on Object/Component/Service-Oriented Real-Time Distributed Computing, 2014.DOI
- [32]A. Bucaioni, A. Di Salle, L. Iovino, I. Malavolta, and P. Pelliccione, “Reference architectures modelling and compliance checking.” Software & Systems Modeling, vol. 22, no. 3, 2023.DOI
- [33]B. Rumpe, M. Stachon, S. Stüber, and V. Voufo, “Tool-assisted conformance checking to reference process models,” arXiv preprint arXiv:2508.00738, 2025.arxiv.org/abs/2508.00738
- [34]T. D. Tran, M. T. Rossi, L. Iovino, and L. Mariani, “Mining architectural models in the wild: A curated dataset of aadl models,” in International Conference on Software Maintenance and Evolution, tool demonstration and data showcase, 2026.DOI
- [35]J. Zhao, “On assessing the complexity of software architectures,” in Proceedings of the third international workshop on Software architecture, 1998, pp. 163–166.DOI
- [36]T. Steinberg, F. Budinsky, E. Merks, and M. Paternostro, EMF: eclipse modeling framework. Pearson Education, 2008.
- [37]A. Bucaioni, A. Di Salle, L. Iovino, L. Mariani, and P. Pelliccione, “Continuous conformance of software architectures,” in 2024 IEEE 21st International Conference on Software Architecture (ICSA). IEEE, 2024, pp. 112–122.DOI
- [38]R. Rubei, A. Di Salle, and A. Bucaioni, “Llm-based recommender systems for violation resolutions in continuous architectural conformance,” in 2025 IEEE 22nd International Conference on Software Architecture Companion (ICSA-C). IEEE, 2025, pp. 404–409.DOI
- [39]P. Shvaiko and J. Euzenat, “A survey of schema-based matching approaches,” in Journal on data semantics IV. Springer, 2005, pp. 146–171.DOI
- [40]L. Otero-Cerdeira, F. J. Rodríguez-Martínez, and A. Gómez-Rodríguez, “Ontology matching: A literature review,” Expert Systems with Applications, vol. 42, no. 2, pp. 949–971, 2015.
- [41]Z. Bellahsene, A. Bonifati, F. Duchateau, and Y. Velegrakis, “On evaluating schema matching and mapping,” in Schema matching and mapping. Springer, 2010, pp. 253–291.DOI
- [42]I. F. Cruz, F. P. Antonelli, and C. Stroе, “Agreementmaker: efficient matching for large real-world schemas and ontologies,” Proceedings of the VLDB Endowment, vol. 2, no. 2, pp. 1586–1589, 2009.
- [43]E. Jiménez-Ruiz and C. Cuenca Grau, “Logmap: Logic-based and scalable ontology matching,” in International Semantic Web Conference. Springer, 2011, pp. 273–288.
- [44]S. Holm, “A simple sequentially rejective multiple test procedure,” Scandinavian journal of statistics, pp. 65–70, 1979.DOI
- [45]N. Cliff, Ordinal methods for behavioral data analysis. Psychology Press, 2014.DOI
- [46]J. Romano, J. D. Kromrey, J. Coraggio, and J. Skowronek, “Appropriate statistics for ordinal level data: Should we really be using t-test and cohen’s d for evaluating group differences on the nsse and other surveys,” in annual meeting of the Florida Association of Institutional Research, vol. 177, no. 34, 2006.
- [47]T. D. Tran, M. T. Rossi, L. Jovino, and I. Mariani, “Zenodo replication package,” https://doi.org/10.5281/zenodo.20829399, 2026.
- [48]J. Knodel and D. Popescu, “A comparison of static architecture compliance checking approaches,” in 2007 Working IEEE/IFIP conference on software architecture (WICSA’07). IEEE, 2007, pp. 12–12.DOI
- [49]R. Terra, M. T. Valente, K. Czarnecki, and R. S. Bigonha, “A recommendation system for repairing violations detected by static architecture conformance checking,” Software: Practice and Experience, vol. 45, no. 3, pp. 315–342, 2015.
- [50]X. Hou, Y. Zhao, Y. Liu, Z. Yang, K. Wang, L. Li, X. Luo, D. Lo, J. Grundy, and H. Wang, “Large language models for software engineering: A systematic literature review,” ACM Transactions on Software Engineering and Methodology, vol. 33, no. 8, pp. 1–79, 2024.arxiv.org/abs/2308.10620
- [51]A. Fan, B. Gokkaya, M. Harman, M. Lybursky, S. Sengupta, S. Yoo, and J. M. Zhang, “Large language models for software engineering: Survey and open problems,” in 2023 IEEE/ACM International Conference on Software Engineering: Future of Software Engineering (ICSE-FoSE). IEEE, 2023, pp. 31–53.arxiv.org/abs/2310.03533
- [52]Q. Zhang, C. Fang, Y. Xie, Y. Zhang, S. Yu, W. Sun, Y. Yang, and Z. Chen, “A survey on large language models for software engineering,” Science China Information Sciences, vol. 69, no. 4, p. 141102, 2026.arxiv.org/abs/2312.15223
- [53]F. Pan, N. Petrovic, V. Zolfaghari, L. Wen, and A. Knoll, “Llm-enabled instance model generation,” in 2025 ACM/IEEE 28th International Conference on Model Driven Engineering Languages and Systems Companion (MODELS-C). IEEE, 2025, pp. 586–595.arxiv.org/abs/2503.22587
- [54]N. Petrovic, F. Pan, K. Lebioda, V. Zolfaghari, S. Kirchner, N. Purschke, M. A. Khan, V. Vorobev, and A. Knoll, “Synergy of large language model and model driven engineering for automated development of centralized vehicular systems,” arXiv preprint arXiv:2404.05508, 2024.arxiv.org/abs/2404.05508
- [55]J. Di Rocco, D. Di Ruscio, C. Di Sipio, P. T. Nguyen, and R. Rubei, “On the use of large language models in model-driven engineering,” Software and Systems Modeling, vol. 24, no. 3, pp. 923–948, 2025.arxiv.org/abs/2410.17370
- [56]Y. He, J. Chen, H. Dong, and I. Horrocks, “Exploring large language models for ontology alignment,” arXiv preprint arXiv:2309.07172, 2023.arxiv.org/abs/2309.07172
- [57]H. Babaei Giglou, J. D’Souza, F. Engel, and S. Auer, “Llms4om: Matching ontologies with large language models,” in European Semantic Web Conference. Springer, 2024, pp. 25–35.arxiv.org/abs/2404.10317
- [58]R. Amini, S. S. Norouzi, P. H. Zierler, and R. Amini, “Towards complex ontology alignment using large language models,” in International Knowledge Graph and Semantic Web Conference. Springer, 2024, pp. 17–31.arxiv.org/abs/2404.10329
- [59]S. Lushnei, D. Shumsky, S. Shykula, E. Jimenez-Ruiz, and A. d. Garcez, “Large language models as oracles for ontology alignment,” in Proceedings of the 19th Conference of the European Chapter of the Association for Computational Linguistics (Volume 1: Long Papers), 2026, pp. 2435–2449.
- [60]M. Taboada, D. Martinez, M. Arideh, and R. Mosquera, “Ontology matching with large language models and prioritized depth-first search,” Information Fusion, vol. 123, p. 103254, 2025.




