From Chat to Interview: Agentic Requirements Elicitation with an Experience Ontology Dongming Jin1,2 , Zhi Jin*1,2 , Yaotian Yang3 , Linyu Li1,2 , Zheng Fang1,2 , Yuanpeng He1,2 , Wenchun Jing1,2 , Xiaohong Chen4
arXiv:2605.05828v1 [cs.SE] 7 May 2026
1
Key Laboratory of High Confidence Software Technologies (Peking University), Ministry of Education, China 2 School of Computer Science, Peking University, China 3 Beijing Forestry University, China 4 East China Normal University, China correspondence to: [email protected]
Abstract—Requirements elicitation interviews are crucial and time-consuming in requirements engineering, but heavily rely on the experience of requirements analysts. Although recent advancements in large language models (LLMs) have created new opportunities to automate this process, existing approaches rely solely on LLMs for free-form chat without taking into account the interview and development experience. That leads to the omission of implicit requirements and redundant questions. Practically, experienced analysts implicitly follow a structured cognitive framework when conducting requirements elicitation. Inspired by this observation, this paper proposes an interview agent named OntoAgent for the elicitation of requirements guided by an experience ontology. ❶ OntoAgent automatically analyzes domain-specific requirements descriptions to construct an experience ontology, which organizes requirements concerns into an ontology to support systematic and explainable interviews. ❷ During the interview, OntoAgent first performs four operations (i.e., ParseUser, ScoreOnto, ReRankOnto, GatePrune) guided by the ontology to identify the relevant requirement concerns. The selected concern is then combined with the current dialogue context to generate the elicitation question. To validate OntoAgent, we conduct comprehensive quantitative experiments using the widely adopted website application domain. The results show that OntoAgent significantly outperforms existing baselines in both elicitation effectiveness and questioning efficiency, achieving a 33% improvement in IRE and a 21% improvement in TKQR. Ablation studies further validate the contribution of each key design component. In addition, a qualitative user study demonstrates its practical advantages in real-world scenarios. We believe that OntoAgent can also be extended to requirements interview tasks in other domain1 . Index Terms—Requirements Elicitation Interview, Requirements Agent, Large Language Model, Ontology Engineering
I. I NTRODUCTION Requirements elicitation is one of the core activities in requirements engineering, laying the foundation for accurately capturing stakeholders’ needs [1]. Among various methodologies, interviews remain the most widely adopted elicitation technique [2] [3]. However, effective interviews heavily rely on experienced requirements analysts. This not only requires substantial time investment but also incurs significant training and *Corresponding authors 1 To support reproducibility, we publicly release our code, dataset, and a lightweight tool at https://anonymous.4open.science/r/TypoAgent-RE2026.
Fig. 1. Motivation of this work. Left: Free-form LLM chat produces adhoc questions, resulting in redundancy and incomplete coverage of implicit requirements; Right: Experienced analysts implicitly follow a structured interview experience to systematically explore requirement dimensions
labor costs [3] [4]. Moreover, interviews are inherently vulnerable to human bias and communication misunderstandings, which may lead to incomplete or ambiguous requirements [5]. These challenges become even more pronounced in the era of rapidly evolving AI-assisted software development. Therefore, automating or intelligently supporting requirements elicitation interviews has become an urgent and important research problem in requirements engineering. With the rapid advancement of large language models (LLMs) in dialogue generation [6] [7] and role-playing capabilities [8] [9], researchers have begun to explore using LLMs to automate requirements elicitation interviews [5] [10], i.e., as shown in the left part of Figure 1, an LLM is prompted to act as an interviewer and rely on its generative ability to ask free-form questions. In this paper, we refer to this approach as the free-form elicitation approach. Although it offers a straightforward solution, an empirical study [10] reveals that it suffers from two major limitations, i.e., struggle to uncover implicit requirements and generate generic questions in earlystage dialogues. In addition, the generated interview questions lack interpretability and controllability, making it difficult
to incorporate effective human-in-the-loop supervision. These limitations negatively affect the effectiveness and efficiency of requirements elicitation. In contrast to the free-form elicitation approach, experienced requirements analysts implicitly follow a structured cognitive framework that is formed from long-term interview experience. This framework organizes requirement concerns into a hierarchical structure, thereby guiding systematic questioning to explore requirements. We refer to such structured knowledge as the experience ontology. The right panel of Figure 1 illustrates the process of systematic interviews by experienced analysts. When facing an underspecified initial requirement such as “I want a website that allows users to search stocks and generate reports”, experienced analysts first reason from high-level aspects of a Web application (e.g., Interaction and Content). Then they narrow the interview to specific functional dimensions (e.g., Search and Display), and finally identify missing implementation slots within each dimension (e.g., search mechanisms and report formats). Through this hierarchical expansion, the interview process forms a coherent and progressive questioning flow, improving coverage while reducing redundancy. Inspired by the above structured interviewing process, we propose OntoAgent, an interview agent for requirements elicitation guided by an experience ontology. Unlike the freeform elicitation, OntoAgent explicitly models the interview experience as an ontology. This ontology serves as a structured questioning space to guide dynamic decision-making and question generation during interviews by decoupling what to ask from how to ask. The ontology determines which requirement slots should be explored, while the LLM generates natural language questions conditioned on dialogue context. Specifically, OntoAgent consists of two core stages:
21%, indicating higher questioning efficiency and quality. (2) We perform ablation studies by incrementally adding four key design modules (i.e., Experience Ontology, ScoreOnto, ReRankOnto, and GatePrune) to a base LLM. Results prove the independent contributions of each component. (3) We evaluate the sensitivity by switching six different base LLMs of OntoAgent, showing strong generalization capability. (4) We conduct a human evaluation to evaluate the generated interview process in three aspects, including elicitation effectiveness, efficiency, and adaptability. Results show that OntoAgent outperforms baselines in all three aspects. (5) We conduct a case study to qualitatively compare the interview processes of OntoAgent and baseline approaches. Results show OntoAgent achieves more structured elicitation interviews in practical scenarios. We summarize our contributions in this paper as follows. • We propose OntoAgent, an interview agent for requirements elicitation. It explicitly models the interview experience using ontology and integrates the experience ontology with LLMs to facilitate the generation of interview questions. • We introduce and develop the interview experience ontology, a three-level hierarchical tree consisting of requirements aspects, dimensions, and slots, which serves as a structured and interpretable questioning space. • We design an ontology-guided interviewing mechanism with four decision-making operations to dynamically select requirement slots and conduct the generation of the context-aware elicitation questions. • We conduct extensive experiments on 101 requirements elicitation scenarios. Qualitative and quantitative analyses show the effectiveness and practical applicability of our OntoAgent.
Experience Ontology Induction. Given a collection of domain-specific requirements texts, OntoAgent automatically analyzes them to construct an experience ontology. The ontology is designed as a three-level hierarchical tree consisting of aspects, dimensions, and slots. • Ontology-Guided Interviewing. OntoAgent conducts four key operations (i.e., ParseUser, ScoreOnto, ReRankOnto, and GatePrune) over the experience ontology to dynamically prioritize and select the most relevant yet insufficiently explored requirement slots. According to the selected slots and the current dialogue context, it generates context-aware and targeted elicitation questions.
II. BACKGROUND AND RELATED WORKS
•
We conduct extensive experiments to evaluate OntoAgent. (1) we evaluate OntoAgent on 101 website requirements elicitation scenarios in ReqElicitGym [10]. We employ two complementary metrics, i.e., Implicit Requirements Elicitation Ratio (IRE) [10] and Turn-discounted Key Question Rate (TKQR) [11]. Results show that OntoAgent significantly outperforms previous baselines. OntoAgent improves IRE by up to 33%, demonstrating enhanced effectiveness in uncovering implicit requirements. OntoAgent also improves TKQR by
Requirements elicitation is widely recognized as a pivotal yet challenging phase in requirements engineering, as inadequate understanding of stakeholder needs remains a major cause of project failure [12]. Among various elicitation approaches, interviews are one of the most traditional and commonly used techniques [2] [13]. It enables analysts to directly engage with stakeholders and ask questions to understand their needs, preferences, and expectations about a product or service [14] [15]. During interviews, interviewers can ask questions to elicit stakeholder preferences, resolve possible ambiguities around multifaceted and conflicting viewpoints [16], and gain insight into tacit knowledge the interviewees might harbor [13], ultimately obtaining a list of requirements [17]. Despite the variety of interview formats, conducting interviews involves numerous challenges. In particular, stakeholder preferences are often tacit knowledge that requires significant effort to extract [13]. The existing literature has described various criteria in the appropriate conduct of interviews. The introduction to them is as follows. Before the emergence of LLMs, research primarily focused on supporting human analysts, including criteria for
the appropriate opening and closing of interviews [18], the right atmosphere and flow [19], the question framing [20], the question content [18], and the avoidance of common mistakes [21]. For example, Zaremba et al. [20] proposed a set of systematic questions to improve interview preparation. Other studies investigated pedagogical strategies to enhance interview skills of humans, such as learning from common elicitation mistakes [22] and employing role-based training methods including role-playing, peer review, and self-assessment [23], [24]. Additionally, Debnath et al. [25] developed AnnoteREI to facilitate transcription and annotation of interview data. Thus, these studies primarily aim to assist or enhance human-conducted interviews. In contrast, our work focuses on automating the requirements elicitation interview process with LLMs. With the rapid advancement of LLMs, recent research has begun exploring intelligent support for requirements elicitation interviews. One line of work investigates using LLMs to generate interview scripts or question templates [26]. Another line leverages LLMs to extract or synthesize requirements directly from dialogue transcripts, aiming to reduce the manual effort required in requirements consolidation [27]. These studies demonstrate the strong capabilities of LLMs in supporting the preparation and recording. More recently, researchers have explored conducting interview directly using LLMs. KornGV et al. [5] investigated the feasibility of LLM-driven conversational elicitation and introduced two prompt-based interview chatbots named LLMREI-long and LLMREI-short. Similarly, Shen et al. [3] investigate LLM-based follow-up question generation for requirements elicitation and propose mistakeguided prompting to improve question quality. Additionally, Jin et al. [10] proposed an evaluation environment named ReqElicitGym for assessing interview competence in multiturn dialogue settings, and conducted an empirical study on six mainstream LLMs. The results reveal that relying solely on free-form LLM chat often struggles to systematically uncover implicit requirements and generate generic questions in earlystage dialogues. Our work follows this direction, attempting to alleviate the aforementioned limitations and improve the effectiveness and interpretability of automated requirements interviews by explicitly integrating the structured interview experience with LLM-based question generation. III. A PPROACH This section presents OntoAgent, the interview agent for requirements elicitation . We describe the overview of OntoAgent approach in the first subsection and describe the details in the following subsections. A. Overview The design principle of OntoAgent is explicitly modeling structured interview experience as an ontology and integrating it with LLM-based question generation. Thus, OntoAgent consists of two interrelated stages: experience ontology induction and ontology-guide interview. The two stages work in a pipeline manner as shown in Figure 2.
Experience Ontology Induction. Given domain-specific requirement texts R, OntoAgent automatically analyzes them to induce a hierarchical tree to represent the experience ontology T , which captures recurring requirement aspects, dimensions, and fine-grained clarification slots. • Ontology-Guide Interview Process. Given the induced ontology T , OntoAgent conducts a multi-turn dialogue with the stakeholder until no eligible slots remain in T or a predefined maximum number of turns is reached. At each turn, OntoAgent performs four key operations (i.e., ParseUser, ScoreOnto, ReRankOnto, and GatePrune) to dynamically select the most relevant yet insufficiently explored requirement slot S. It then combines the current dialogue context C with the selected slot S to generate an elicitation question Q for follow-up interaction. •
B. Experience Ontology Induction This stage aims to automatically construct an experience ontology from domain-specific requirement texts. To achieve this, we first define the schema of the experience ontology. Then we design an automated construction pipeline. Ontology Schema. OntoAgent formulates requirements elicitation experience ontology into a three-layer tree structure. The first layer represents the requirement aspect, which is the highest-level abstraction of system requirements and provides a macro-level partition of the requirement space. For example, this layer for the domain of web applications includes interaction, content, and style. To ensure the stability of the ontology, the aspect layer is provided by domain experts. The second layer represents the requirements dimension, which captures the core functional points and serves as a coherent category of requirements. For example, this layer for the web application domain may include login, search, and display. The third layer represents the requirements slot, which corresponds to a clarifiable requirement detail under each dimension. For example, under the search dimension, slots may include filtering options and sorting rules. Formally, the experience ontology is a threelevel tree T = (A, D, S, πD , πS ), where A, D, and S denote the set of aspects, dimensions, and slots, πD is a mapping that assigns each dimension to one aspect, πS is a mapping that assigns each slot to one dimension. Dimension Induction. The goal of dimension induction is to automatically construct a set of requirement dimensions from domain-specific requirement texts under predefined requirement aspects. Considering that traditional clustering methods suffer from unstable granularity and limited interpretability, OntoAgent adopts a gradual expansion approach and employs an LLM to automate this process. Specifically, OntoAgent first initializes the ontology using manually defined requirement aspects, with no dimensions assigned under each aspect. Given a requirement description, OntoAgent leverages an LLM with a carefully designed prompt Pd to extract its underlying functional dimensions and associate them with the corresponding requirement aspect. The LLM is instructed to either (1) merge the extracted dimensions into an existing dimension when semantic overlap is detected, or (2) introduce
Ontology-Guided Interview Initial requirements description Support
Aspect A Aspect B ··· Aspect A Aspect B
Aspect C
Dim 1
Dim 2
Dim 3
Dim 1
Dim 2
Dim 3
Dimension Induction
Dim 1
Dim 2
Dim 3
Slot 2
Slot 3
LLM Domain-Specific Requirements Text
Slot Induction
Slot 1
ScoreTypo
Experience Ontology T Slot 1
Slot 2
Slot 3
Current dialogue context
QuestionGen
Online
GatePrune
Offline
T = {Aspect, Dimension, Slot }
ParseUser
Experience Ontology Induction
ReRankTypo Selected slot to elicit
Fig. 2. Overview of OntoAgent framework.
a new dimension only when no suitable abstraction exists. Importantly, OntoAgent adopts a conservative expansion strategy that prioritizes semantic merging over introducing new dimensions. This strategy prevents uncontrolled growth of the tree and maintains consistent granularity across dimensions. User Prompt Pd for Dimension Induction Current Ontology Tree: {ontology} New Requirements Text: {requirements} Task: 1) Extract requirement points from the requirements text into the aspect level. 2) Integrate them into the current tree using the policy (merge > expand > add). Prefer merging into existing 3) Output the strict JSON specified in the system instructions. Slot Induction. Slot induction aims to construct finegrained and directly clarifiable requirement details under each induced dimension. Given the current two-layer ontology tree (i.e., aspect–dimension), OntoAgent further employs an LLM guided by a carefully designed prompt Ps to extract concrete requirement slots from domain requirement texts and incrementally associate them with their corresponding dimensions. Formally, a slot is defined as a tuple S = ⟨k, q⟩, where k denotes a normalized clarifiable requirement item, and q represents a candidate clarification question associated with that key. During slot induction, semantic conflicts may arise when multiple extracted keys refer to overlapping or highly similar requirement semantics. To resolve such conflicts, OntoAgent applies a heuristic disambiguation rule: when multiple keys exhibit semantic overlap, we retain the shorter and more general formulation. This strategy enhances reusability and maintains consistent granularity. OntoAgent further regulates the linguistic form of clarification questions to align with different levels of specification. Specifically, when a dimension is merely mentioned without sufficient detail in an analyzed requirements text, clarification questions adopt a binary confirmation form (e.g., “Do you need ...?”). When partial constraints have already been provided, questions
shift to an open-ended refinement form (e.g., “What ...?”). This controlled differentiation improves naturalness and avoids premature over-specification during interviews. User Prompt Ps for Slot Induction Two-level Ontology: {current ontology} New Requirements Text: {instruction} Task: 1) Identify which dimensions the requirements text touches. 2) If the text describes in detail, please output a clarifying question; If only mentions, please output "Do you need [X]?" question. 3) Return the strict JSON specified in the system instructions. 4) Omit topics the instruction does not mention. C. Ontology-Guide Interview To integrate the experience ontology with LLM-based dialogue generation, OntoAgent formulates the interview process as an ontology-constrained iterative decision loop. For each turn in the multi-turn dialogue process, OntoAgent first performs four operations (i.e., ParseUser, ScoreOnto, ReRankOnto, and GatePrune) over the experience ontology to determine the most appropriate requirement slot to be clarified. Subsequently, a QuestionGen operation generates the followup elicitation question by combining the selected slot with the current dialogue context. Algorithm 1 summarizes the overall process of the ontology-guide interview. The five core operations are detailed below2 . ParseUser: This operation interprets stakeholder responses to support pruning and confirmation decisions. It consists of two variants. At the aspect level, it analyzes responses to macro-level confirmation questions (e.g., whether additional concerns remain under a specific aspect), which enables aspect-level GatePrune. At the dimension level, it determines whether a specific requirement dimension is explicitly con2 All operations are implemented through prompting with rule-based constraints. Detailed prompts are provided in our replication package.
Algorithm 1 Ontology-Guided Interview Process 1: Input: Initial description u0 , experience ontology T , max turns
T , aspect pruning threshold N 2: Output: Elicited requirement set R 3: H ← {u0 } 4: R ← ∅ 5: aspect_no_need_count ← 0 6: t ← 0 7: Mark all slots in T as U NEXPLORED 8: T ← S CORE O NTO(u0 , T ) ▷ ScoreOnto 9: while t < T do ▷ Aspect GatePrune 10: if aspect_no_need_count ≥ N then 11: Q ← C HECK A SPECT P RUNING(current_aspect) 12: A ← await stakeholder’s response 13: H ← H ∪ {Q, A} 14: is_pruned ← PARSE U SER(A) 15: if is_pruned then 16: T ← A SPECT P RUNING(current_aspect, T ) 17: end if 18: aspect_no_need_count ← 0 19: end if 20: S ← R E R ANKO NTO(H, T ) ▷ ReRankOnto 21: if S = ∅ then 22: break 23: end if 24: Q ← Q UESTION G EN(H, S) ▷ QuestionGen 25: A ← await stakeholder’s response 26: H ← H ∪ {Q, A} 27: is_needed ← PARSE U SER(A) ▷ Dimension GatePrune 28: if is_needed then 29: Mark S as C ONFIRMED 30: R ← R ∪ {S} 31: else 32: Mark S as R EJECTED 33: aspect_no_need_count ← aspect_no_need_count + 1 34: T ← A PPLY D IMENSIONA ND S LOT P RUNING(S, T ) 35: end if 36: t←t+1 37: end while
firmed or rejected (e.g., Login is not required), which supports dimension-level GatePrune. ScoreOnto. Before the dialogue begins, ScoreOnto assigns initial priority scores to nodes in the ontology based on the initial requirement description. This is necessary because early dialogue lacks contextual feedback. If the agent simply follows a fixed tree traversal order, the questions in the early stage may deviate from the stakeholder’s primary concerns. By estimating semantic relevance between the initial description and the ontology nodes, ScoreOnto determines an exploration order, ensuring that the interview begins from branches most likely related to the user’s intent. ReRankOnto. During the interview, user responses continuously introduce new context. Therefore, prior priority scores may become outdated. Before each turn, ReRankOnto dynamically re-evaluates and reorders candidate slots under the currently active branch based on the updated dialogue history. This operation guarantees that the agent always selects the slot most likely to uncover implicit requirements. GatePrune. To reduce redundant questioning and accelerate convergence, OntoAgent introduces two gate-controlled prun-
ing mechanisms. Aspect-level GatePrune is triggered when no new requirements are elicited after N consecutive inquiries under the same aspect. In this case, OntoAgent issues a macro-level confirmation question (e.g., “Are there any other requirements related to interaction?”). If the stakeholder explicitly indicates that there are no further concerns, the entire aspect branch is pruned. Dimension-level GatePrune operates at a finer granularity. If the stakeholder explicitly rejects a requirement dimension (e.g., stating that registration/login is unnecessary), the corresponding slots in this dimension are immediately pruned. These pruning strategies progressively shrink the search space while preserving systematic coverage. QuestionGen. Given the selected slot and the current dialogue history, QuestionGen synthesizes a natural and contextaware interview question. By grounding question generation in structured ontology, OntoAgent avoids ad-hoc questioning and maintains interpretability. IV. S TUDY D ESIGN To evaluate the performance of the OntoAgent framework, we conduct a multi-aspect study to answer five research questions (RQs). This section describes the details of our study, including research questions, baselines, datasets, and metrics. A. Research Questions RQ1 (Effectiveness): How effective is OntoAgent in conducting requirements elicitation interviews compared with existing baselines? This RQ aims to evaluate the effectiveness of our proposed framework, i.e., improving implicit requirement elicitation and questioning efficiency. In experiments, we select GPT-5.1 as the base LLM for our framework. We sample 5 scenarios for each application type from the WenGen-Bench to construct an ontology. The generalization capability across different LLMs and scenarios number will be further examined in RQ3 and RQ5. RQ2 (Ablation Study): What is the contribution of each component in OntoAgent? This RQ examines how each module contributes to elicitation coverage and questioning efficiency. OntoAgent consists of four core components that enhance requirements elicitation interview performance: (1) Experience Ontology, (2) ScoreOnto, (3) ReRankOnto, and (4) GatedPrune3 . Based on the experimental setup in RQ1, we conduct ablation studies by incrementally adding these components to a GPT-5.1 base model to analyze their individual contributions. RQ3 (Sensitivity): How robust is OntoAgent across different large language models? This RQ focuses on the robustness and generalization ability of OntoAgent with respect to different underlying LLMs. We evaluate whether OntoAgent remains effective when substituting GPT-5.1 with other LLMs, validating the model-agnostic design of our framework. Specifically, we follow the prior work [10] and select six other LLMs as shown in Table I. 3 ParseUser and QuestionGen are not ablated as they are necessary within the pipeline.
TABLE I T HE S ELECTED LLM S FOR RQ3. A LL MODELS WERE ACCESSED VIA OFFICIAL API S .
LLM
Type
Creator
Release
Used
Claude Opus 4.5 Gemini 3 Flash DeepSeek V3.2 Kimi K2.5 GLM-4.7 Qwen3 235B
Closed Closed Open Open Closed Open
Anthropic Google DeepSeek Moonshot AI Zhipu AI Alibaba
2025.11 2025.12 2025.12 2026.01 2025.11 2025.07
2026.02 2026.02 2026.02 2026.02 2026.02 2026.02
RQ4 (Type-wise Analysis): How does OntoAgent perform in eliciting different types of implicit requirements? Implicit requirements may belong to different aspects. Each type may exhibit distinct elicitation characteristics and difficulty levels. This RQ investigates whether OntoAgent provides balanced coverage across different requirement types. Specifically, we conduct aspect-level analysis to examine whether OntoAgent improves elicitation effectiveness uniformly or exhibits biases toward specific aspects. RQ5 (Scalability): How does the size of induction data affect the performance of OntoAgent? Since the experience ontology is constructed from domain requirements text, its quality may depend on the amount of available induction data. This RQ studies the sensitivity of OntoAgent to the scale of requirements instructions used for ontology induction. By varying the proportion of the full training data used, we evaluate the scalability and data efficiency of the proposed framework. B. Baselines We compare OntoAgent against five representative LLM-based elicitation baselines from three recent studies [5] [3] [10]. These five baselines all use freeform elicitation approach. Their introductions are provided as follows. Non-CoT. It follows the standard inference setting adopted in the ReqElicitGym [10]. Specifically, an LLM conducts multi-turn dialogue without explicit reasoning instructions. At each turn, the LLM directly generates a clarification or probing question. CoT. It incorporates Chain-of-Thought (CoT) prompting adopted in the ReqElicitGym [10]. Specifically, an LLM is instructed to explicitly reason about the dialogue context before generating each question. LLMREI-short. It is derived from the zero-shot prompting strategy proposed in LLMREI [5]. Specifically, it employs a concise system prompt that instructs the LLM to behave as a professional interviewer and ask one focused question. LLMREI-long. It corresponds to the least-to-most prompting strategy proposed in LLMREI [5]. Specifically, it adopts a substantially longer and more structured system prompt that embeds explicit interview guidelines, role definitions, and procedural instructions.
Mistake-guided Prompting. This baseline is derived from the mistake-guided question generation framework [3]. At each turn, the LLM is provided with the interviewee’s utterance together with a predefined interviewer mistake criterion and is instructed to generate a follow-up question. C. Datasets Evaluation Dataset for Interview. We evaluate OntoAgent and all five baselines using the ReqElicitGym [10], an interactive and automatic evaluation environment designed for interviews. ReqElicitGym contains 101 web application scenarios spanning 10 application types. Each scenario consists of an underspecified initial requirement description, a complete final specification, and a set of manually annotated implicit requirements categorized by requirements aspects. In addition, the evaluation environment contains a simulated interactive oracle user and a task evaluator to interact and evaluate an interviewer. Thus, any automated interviewer’s approach can be evaluated through interaction with the environment. Training Dataset for ontology Induction. To construct the experience ontology, OntoAgent requires a corpus of domain-specific requirements descriptions to analyze recurring requirements concerns. In this work, we utilize the train set of WebGen-Bench [28] as the data source for ontology induction. Notably, all evaluation scenarios in ReqElicitGym are derived from the test set of WebGen-Bench. Therefore, by restricting ontology construction to the WebGen-Bench training data, we ensure strict separation between ontology induction and interview evaluation. This design effectively prevents data leakage and guarantees that the induced ontology reflects generalizable elicitation experience rather than memorization of evaluation scenarios. D. Evaluation Metrics We evaluate the performance using two complementary measures: Implicit Requirements Elicitation Ratio (IRE) [10] and Turn-discounted Key Question Rate (TKQR) [11]. IRE measures overall coverage of implicit requirements, while TKQR evaluates questioning efficiency by emphasizing the ordering. These metrics capture both the effectiveness and efficiency of elicitation interviews. Implicit Requirements Elicitation Ratio (IRE). Let R denote the set of ground-truth implicit requirements for a scenario, and let R̂≤T denote the set of implicit requirements elicited by the interviewer when the interaction ends at turn T . The metric is computed as: IRE =
|R̂≤T | . |R|
(1)
To enable fine-grained analysis, aspect-level IRE is computed by restricting R and R̂≤T to implicit requirements within each requirement aspect. This aspect-wise breakdown facilitates examining whether an elicitation approach achieves balanced coverage across different requirement aspects. Turn-discounted Key Question Rate (TKQR). TKQR evaluates questioning efficiency by rewarding early elicitation
of key implicit requirements and penalizing delayed or redundant questioning. Let n denote the number of dialogue turns before the interviewer stops asking questions, and let K = |R| denote the total number of annotated implicit requirements for the scenario. A hit indicator sequence H = (h1 , . . . , hn ) is constructed, where hi = 1 if the interviewer elicits a previously unelicited implicit requirement at turn i, and hi = 0 otherwise. The discounted cumulative gain is computed as: DCGn =
n X
hi . log (i 2 + 1) i=1
(2)
To normalize across scenarios with different numbers of implicit requirements, the ideal discounted cumulative gain is computed as: min(n,K)
IDCGn =
X i=1
1 . log2 (i + 1)
(3)
TKQR is then calculated as: TKQR =
DCGn . IDCGn
(4)
TKQR ranges in [0, 1], where higher values indicate earlier prioritization of key elicitation questions during the interaction. V. R ESULTS AND A NALYSIS RQ1 (Effectiveness): How effective is OntoAgent in conducting requirements elicitation interviews compared with existing baselines? Setup. We evaluate five baselines and our OntoAgent on 101 website requirements elicitation scenarios in ReqElicitGym. The evaluation metrics are described in Section IV-D, i.e., IRE and TKQR. For all metrics, higher scores represent better performance. Results. Table II shows the experimental results on ReqElicitGym. Analyses. (1) OntoAgent improves implicit requirement elicitation coverage. Table II shows that OntoAgent achieves an IRE of 0.69, outperforming all baselines. The strongest baseline (i.e., Mistake-guided Prompting) reaches 0.52. Compared with it, OntoAgent gain a relative improvement by 33%, demonstrating its ability to systematically uncover missing implicit requirements. The performance gap between free-form baselines and OntoAgent indicates that relying solely on LLMs to chat is insufficient for structured interviews. Instead, it is essential to explicitly model interview experience and integrate it with LLMs for achieving higher elicitation coverage. (2) OntoAgent also achieves the highest questioning efficiency. In terms of TKQR, OntoAgent achieves 0.59, outperforming all baselines. It gains a 21% relative improvement over the best baseline (i.e., LLMREI-short). This improvement indicates that OntoAgent not only elicits more implicit requirements but also identifies them earlier in the interaction. Since TKQR penalizes delayed discovery, the higher score demonstrates
TABLE II OVERALL EFFECTIVENESS COMPARISON ON R EQ E LICIT G YM . R ELATIVE IMPROVEMENT IS COMPUTED AGAINST THE BEST- PERFORMING BASELINE . Approach
IRE
TKQR
Non-CoT CoT LLMREI-short (RE’25) LLMREI-long (RE’25) Mistake-guided Prompt (RE’25)
0.13 0.08 0.39 0.38 0.52
0.09 0.19 0.49 0.09 0.48
0.69 (↑ 33%)
0.59 (↑ 21%)
OntoAgent (Ours)
that OntoAgent can elicit high-value requirement dimensions in early dialogue turns. x Answer to RQ1: OntoAgent significantly outperforms the baselines in both implicit requirement elicitation effectiveness and questioning efficiency. In particular, it gains a relative improvement by 33% in IRE and 21% in TKQR. The significant improvements prove our ontology-enhanced approach is more promising.
RQ2 (Ablation Study): What is the contribution of each component in OntoAgent? Setup. Starting from a base LLM (i.e., GPT-5.1), we progressively add the four core components of OntoAgent, i.e., Experience Ontology, ScoreOnto, ReRankOnto, and GatedPrune. All variants are evaluated using the same ReqElicitGym environment. We report the same two metrics as in RQ1, i.e., IRE and TKQR. Results. The experimental results of the ablation study are shown in Table III. Analyses. (1) Experience Ontology provides the largest performance improvement. Adding the experience ontology dramatically improves IRE from 0.13 to 0.41 and TKQR from 0.09 to 0.34. This substantial improvement indicates that explicitly modeling the requirements interview experience to guide the LLM is far more effective than relying solely on free-form generation. The ontology can effectively transform the elicitation process from LLM-based chat into structured interviews. (2) ScoreOnto and ReRankOnto further improve early-stage alignment and efficiency. Introducing ScoreOnto further increases IRE to 0.58 and TKQR to 0.37. These indicate that this component enables the agent to focus on more relevant requirement dimensions at early dialogue turns. Adding ReRankOnto yields additional gains, improving IRE to 0.64 and TKQR to 0.62. Although the improvement is relatively small, it also demonstrates the necessity of dynamically adjusting questioning direction based on the accumulated dialogue context. (3) Gated Pruning improves efficiency while maintaining coverage. Incorporating Gated Pruning further improves IRE to 0.69 and TKQR to 0.59. The increase in TKQR indicates that pruning reduces redundant questions, enabling earlier elicitation of key requirements. Importantly, the pruning does not harm coverage. Instead, it improves IRE, suggesting that eliminating ineffective questioning paths helps concentrate the exploration on valid dimensions.
TABLE III A BLATION STUDY OF OntoAgent ON R EQ E LICIT G YM . E ACH ROW INCREMENTALLY ADDS ONE COMPONENT TO THE BASE LLM. Approach
IRE
TKQR
Base LLM (GPT-5.1) + Experience Ontology + ScoreOnto + ReRankOnto + GatePrune
0.13 0.41 0.58 0.64 0.69
0.09 0.34 0.37 0.52 0.59
TABLE IV P ERFORMANCE OF OntoAgent ON DIFFERENT LLM BACKBONES . Backbone LLM
IRE
TKQR
Claude Opus 4.5 + OntoAgent Gemini 3 Flash + OntoAgent DeepSeek V3.2 + OntoAgent Kimi K2.5 + OntoAgent GLM-4.7 + OntoAgent Qwen3 235B + OntoAgent
0.63 0.64 0.55 0.64 0.63 0.68
0.74 0.48 0.71 0.59 0.47 0.52
x Answer to RQ2: Four modules are essential for the performance of our approach. Experience Ontology provides the largest gain both in coverage and efficiency. ScoreOnto and Re-ranking improve alignment and efficiency during early-stage interaction. Gated Pruning further enhances efficiency by reducing redundant questions without harming coverage.
RQ3 (Robustness): How robust is OntoAgent across different large language models? Setup. To evaluate the robustness of OntoAgent with respect to different backbone LLMs, we substitute GPT-5.1 with several representative LLMs in Table I. We report IRE and TKQR under the same evaluation environment as in RQ1. Results. Table IV summarizes the overall performance of OntoAgent under different backbone LLMs. Analyse. (1) OntoAgent maintains competitive performance across diverse backbones. Across six representative LLMs, OntoAgent consistently achieves IRE between 0.55 and 0.68, and TKQR between 0.47 and 0.74. Despite variations in model scale and training paradigms, all backbones demonstrate effective implicit requirement elicitation when integrated with OntoAgent. This indicates that the OntoAgent generalizes across heterogeneous LLM capabilities rather than relying on a single specific backbone. (2) Backbone quality affects performance, but does not solely determine outcomes. Models with stronger reasoning and planning capabilities (e.g., Claude Opus 4.5) tend to achieve higher IRE or TKQR scores. However, the gap between the highest and lowest IRE remains moderate (i.e., 0.13), suggesting that backbone differences do not fundamentally alter elicitation effectiveness. This indicates that OntoAgent reduces dependence on purely implicit reasoning ability of LLMs.
TABLE V A SPECT- LEVEL IMPLICIT REQUIREMENT ELICITATION PERFORMANCE . IRE_ INT, IRE_ CON , AND IRE_ STY DENOTE THE ELICITATION RATIOS FOR interaction, content, AND style REQUIREMENTS , RESPECTIVELY. Methods Non-CoT CoT LLMREI-long LLMREI-short Mistake-guided Prompt OntoAgent
IRE_int
IRE_con
IRE_sty
0.19 0.12 0.56 0.59 0.70 0.74
0.13 0.09 0.50 0.51 0.65 0.64
< 0.01 < 0.01 0.05 0.09 0.17 0.55
x Answer to RQ3: OntoAgent exhibits strong robustness across different backbone LLMs. Although backbone quality leads to moderate variation, overall elicitation effectiveness and efficiency remain stable. This indicates that OntoAgent plays the primary role in determining performance rather than specific model capability.
RQ4 (Requirement-Type-wise Analysis): How does OntoAgent perform in eliciting different types of implicit requirements? Setup. Following the ReqElicitGym [10], the implicit requirements are categorized into three dimensions: interaction, content, and style. For all baselines and OntoAgent, we compute aspect-level IRE by restricting the ground-truth and elicited requirement sets to each requirement type. Results. Table V presents the aspect-level elicitation performance of five baselines and OntoAgent. Analyse. (1) OntoAgent consistently outperforms all baselines across all requirement types. OntoAgent achieves the highest IRE in interaction (i.e., 0.74), content (i.e., 0.64), and style (i.e., 0.55), demonstrating its ability to provide balanced coverage across heterogeneous requirement dimensions. In contrast, baseline methods exhibit uneven performance, particularly struggling with style requirements. (2) Style requirements are particularly challenging for baseline methods. Both Non-CoT and CoT achieve near-zero performance on style requirements (< 0.01), indicating that freeform conversational generation rarely explores aesthetic or presentation-related aspects without explicit structural guidance. Even structured prompt-based baselines only achieve 0.05, 0.09, and 0.17, respectively, suggesting that prompt engineering alone is insufficient for eliciting stylistic or nonfunctional preferences. By contrast, OntoAgent improves stylerelated IRE dramatically to 0.55. x Answer to RQ4: OntoAgent achieves balanced and substantial improvements across all requirement types. The most significant gain is observed for style requirements, which are largely neglected by baseline methods.
RQ5 (Scalability): How does the size of induction data affect the performance of OntoAgent? Setup. For each application type in the WenGen-Bench training set, we randomly sample 5, 10, 15, and 20 scenarios to induce the ontology, respectively. All induced ontologies are then fixed and evaluated under the same ReqElicitGym
TABLE VI H UMAN EVALUATION RESULTS ( MEAN L IKERT SCORES , 1–7 SCALE ).
IRE TKQR
0.75
Score
0.70 0.65
Approach
Effectiveness
Efficiency
Adaptability
0.60
LLMREI-Short LLMREI-Long Mistake-guided Prompt OntoAgent
4.58 4.47 5.11 5.87 (↑ 15%)
4.92 3.26 5.26 5.79 (↑ 10%)
5.14 4.74 5.08 6.12 (↑ 19%)
0.55 5
10
15
Number of Samples per Application Type
20
Fig. 3. Impact of ontology induction data size on the performance.
In this section, we complement our quantitative results in Section V with a human evaluation study and cross-case analysis. We aim to examine the practical effectiveness and behavioral characteristics of OntoAgent beyond metrics.
hair and nail salon seeking a digital solution for managing appointments and employee scheduling. (2) Ski Resort Scenario. A ski resort requiring a digital booking and business management platform for its three locations. Before each session, participants received a description outlining their role as a stakeholder and instructions on what to do after the interview. Then the chatbot, based on the above approaches, conducted the interview separately. Each participant completed the interview session with them. Each interview session lasted around 20 minutes. Upon completion, participants were asked to fill out a questionnaire evaluating the effectiveness of the approach. Participants rated the effectiveness on a 7-point Likert scale4 across three dimensions, i.e., Elicitation Effectiveness, Questioning Efficiency, and Questioning Adaptability. Result and Analysis. The results of the human evaluation are shown in Table VI. Our OntoAgent is better than all baselines in three aspects. Specifically, OntoAgent outperforms the SOTA baselines by 15% in elicitation effectiveness, 10% in questioning efficiency, and 19% in questioning adaptability. All the p-values are substantially smaller than 0.05, which shows the improvements are statistically significant. The improvements prove the superiority of our OntoAgent in assisting requirements elicitation interviews. Besides, we acknowledge the number of participants is relatively limited. The human evaluation is intended to complement the large-scale quantitative results in Section V, and the consistent trends across both evaluations further demonstrate the effectiveness of OntoAgent.
A. Human Evaluation
B. Case Analysis
The experiments presented in Section V were conducted within the ReqElicitGym simulated environment. To further examine the practical effectiveness of OntoAgent, we conducted a complementary human evaluation study. Participants. We recruited 6 participants (4 graduate students and 2 senior undergraduate students) with software engineering backgrounds. All participants had prior coursework or project experience in requirements analysis. None of them were involved in the development of OntoAgent. Study Design. We designed an experiment involving real interviews and adopted a within-subject design [29]. Specifically, each participant acted as a stakeholder in predefined scenarios and interacted with four approaches (i.e., LLMREI-short, LLMREI-long, Mistake-guide Prompting and OntoAgent). The predefined scenarios come from a previous study [24] and have been used in multiple requirements-related studies [5] [24] [30]. They include: (1)Salon Scenario. A
To better understand how OntoAgent and compared baselines behave, we conduct a cross-case analysis on six representative scenarios in ReqElicitGym. Figure 4 presents the turnlevel IRE progression for three baselines and our OntoAgent. From the examples, we obtain the following findings. (1) Faster Early Convergence. OntoAgent demonstrates substantially faster early-stage IRE growth, often eliciting key implicit requirements within the first 3–5 turns, while freeform baselines typically exhibit prolonged stagnation in the initial dialogue phase. This suggests that OntoAgent enables OntoAgent to immediately focus on high-impact requirements dimensions rather than spending early turns on surface-level clarification. (2) Higher Final Coverage. OntoAgent consistently achieves the highest final IRE, frequently approaching near-complete implicit requirement coverage. In contrast, free-
environment as in RQ1. For each data size setting, we report IRE and TKQR. Results. Figure 3 shows the performance of OntoAgent under different induction data sizes. Analyse. (1) Increasing induction data moderately further improves elicitation coverage. As the number of induction scenarios increases from 5 to 15, IRE improves from 0.69 to 0.73, indicating that richer domain data helps construct a more comprehensive ontology and improves coverage of implicit requirements. (2) Excessive induction data may reduce questioning efficiency. When the data size further increases to 20 scenarios, TKQR decreases from 0.60 to 0.57. This suggests that an overly large ontology expands the search space and introduces more candidate slots, making early-stage question selection less focused. x Answer to RQ5: Increasing induction data improves elicitation coverage, showing that OntoAgent benefits from richer ontology construction. However, overly large induction data may negatively affect questioning efficiency due to an expanded search space.
VI. H UMAN E VALUATION AND C ASE A NALYSIS
4 1 = strongly disagree, 7 = strongly agree
Agricultural Information Management Portal
Question and Answer Management System
Insurance Business Management System
Discussion Forum and User Center System
Internship Matching Portal
Regulatory Policy Visualization Dashboard
Fig. 4. Turn-level IRE progression across six representative scenarios.
form baselines often plateau at moderate coverage levels, indicating omission of less salient but critical requirements aspects. This highlights the advantage of explicitly modeling the requirement space as a structured, hierarchical ontology to prevent systematic blind spots. (3) Reduced Mid-Turn Stagnation. The progression curves of OntoAgent exhibit steady, step-wise improvements with fewer long plateaus, reflecting systematic traversal of requirements dimensions. In comparison, the baselines display ad-hoc jumps and extended stagnation phases, suggesting unsystematic exploration and redundant questioning. VII. T HREATS TO VALIDITY Construct Validity. Construct validity concerns the relationship between treatment and outcome. Potential threats arise from the metrics adopted and the datasets involved in ontology induction and evaluation. The first threat is that these metrics may not fully capture all qualitative aspects of interview performance. To mitigate this concern, we employ two complementary quantitative metrics (i.e., IRE and TKQR), which measure elicitation effectiveness and turn-level efficiency from different perspectives, and further complement them with a human evaluation study that assesses elicitation quality across multiple dimensions using Likert-scale ratings. The second threat relates to the evaluation benchmark and the data used for ontology induction. Although ReqElicitGym is a simulated requirements elicitation environment, it has been validated in prior work [10] as a reliable benchmark for assessing conversational requirements interview competence. The data used for ontology construction may also influence the performance of OntoAgent. To address this concern, we enforce strict separation between ontology induction data and interview evaluation data, ensuring that the induced ontology is constructed without exposure to any evaluation instances. In
addition, we conduct an empirical study to examine the impact of induction data size on the performance of OntoAgent, which further strengthens confidence that the observed improvements are not attributable to data leakage or memorization. Internal Validity. Internal validity addresses potential threats to the way the study was conducted. First, model configuration and evaluation settings may influence performance. To ensure stability and reproducibility, all LLMs are evaluated using greedy decoding. In addition, the maximum number of dialogue turns is uniformly set to 20 across all approaches to guarantee fair comparison under identical interaction budgets. Second, the re-implementation of baseline methods may introduce bias. To mitigate this threat, we strictly follow the original prompt designs and experimental protocols described in the corresponding papers without modification. No additional tuning or optimization is applied to favor OntoAgent. Third, the human evaluation process may be affected by participant bias or learning effects when interacting with multiple systems sequentially. To reduce this influence, we adopt a withinsubject design and ensure that all participants read the scenario descriptions beforehand. We acknowledge that residual subjective bias may still exist. However, combining quantitative metrics with human evaluation helps reduce the impact of any single evaluation source. External Validity. External validity considers the generalizability of our findings. A primary threat is that our evaluation relies on ReqElicitGym as the experimental environment. Although ReqElicitGym covers diverse application types, it is still confined to the web application domain. To mitigate this concern, we complement the benchmark-based evaluation with a human evaluation study conducted on two additional widely used real-world scenarios outside the ReqElicitGym setting. This helps validate the effectiveness of OntoAgent under more
natural and varied interaction contexts. VIII. C ONCLUSION We propose OntoAgent, an ontology-enhanced requirements elicitation agent that transforms free-form LLM interviews into structured and interpretable inquiry processes. By explicitly modeling interview experience as a hierarchical ontology and guiding question selection through dynamic prioritization and pruning, OntoAgent enables systematic exploration of implicit requirements. Experiments on 101 scenarios demonstrate significant improvements over strong LLM baselines in both elicitation coverage and questioning efficiency. Human evaluation further validates its practical effectiveness. OntoAgent also demonstrate the importance of ontology-guided LLM agents for advancing automated requirements development. IX. DATA AVAILABILITY Our source code, dataset, and a lightweight tool are available at https://anonymous.4open.science/r/TypoAgent-RE2026. R EFERENCES [1] J. A. Goguen and C. Linde, “Techniques for requirements elicitation,” in [1993] Proceedings of the IEEE International Symposium on Requirements Engineering. IEEE, 1993, pp. 152–164. [2] K. Wiegers and J. Beatty, Software requirements. Pearson Education, 2013. [3] Y. Shen, A. Singhal, and T. Breaux, “Requirements elicitation followup question generation,” in 2025 IEEE 33rd International Requirements Engineering Conference (RE). IEEE, 2025, pp. 117–129. [4] H. Meth, M. Brhel, and A. Maedche, “The state of the art in automated requirements elicitation,” Information and Software Technology, vol. 55, no. 10, pp. 1695–1709, 2013. [5] A. Korn, S. Gorsch, and A. Vogelsang, “LLMREI: automating requirements elicitation interviews with llms,” in 33rd International Requirements Engineering Conference. IEEE, 2025, pp. 19–30. [6] V. Srinivas, X. Xu, X. Liu, A. Kumar, I. Galatzer-Levy, S. Patel, D. McDuff, and T. Althoff, “Substance over style: Evaluating proactive conversational coaching agents,” in Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 2025, pp. 20 848–20 880. [7] Z. Zhao, C. Vania, S. Kayal, N. Khan, S. B. Cohen, and E. Yilmaz, “Personalens: A benchmark for personalization evaluation in conversational ai assistants,” in Findings of the Association for Computational Linguistics: ACL 2025, 2025, pp. 18 023–18 055. [8] D. Jin, W. Sun, J. Huang, P. Liang, J. Xuan, Y. Liu, and Z. Jin, “iredev: A knowledge-driven multi-agent framework for intelligent requirements development,” arXiv preprint arXiv:2507.13081, 2025. [9] M. Ataei, H. Cheong, D. Grandi, Y. Wang, N. Morris, and A. Tessier, “Elicitron: A large language model agent-based simulation framework for design requirements elicitation,” Journal of Computing and Information Science in Engineering, vol. 25, no. 2, p. 021012, 2025. [10] D. Jin, Z. Jin, Z. Fang, L. Li, Y. Yang, Y. He, and X. Chen, “Reqelicitgym: An evaluation environment for interview competence in conversational requirements elicitation,” arXiv preprint arXiv:2602.18306, 2026. [11] fangz cs, “Cognicode: Evaluation metrics for multi-turn code generation,” GitHub repository, 2026, last updated Feb 22, 2026. Accessed 2026-02-22. [Online]. Available: https://github.com/fangz-cs/ CogniCode [12] C. Jones, “Software project management practices: Failure versus success,” CrossTalk: The Journal of Defense Software Engineering, vol. 17, no. 10, pp. 5–9, 2004.
[13] A. Ferrari, P. Spoletini, and S. Gnesi, “Ambiguity and tacit knowledge in requirements elicitation interviews,” Requirements Engineering, vol. 21, no. 3, pp. 333–355, 2016. [14] A. M. Hickey and A. M. Davis, “Elicitation technique selection: how do experts do it?” in Proceedings. 11th IEEE International Requirements Engineering Conference, 2003. IEEE, 2003, pp. 169–178. [15] C. Palomares, X. Franch, C. Quer, P. Chatzipetrou, L. López, and T. Gorschek, “The state-of-practice in requirements elicitation: an extended interview study at 12 companies,” Requirements engineering, vol. 26, no. 2, pp. 273–299, 2021. [16] D. Zowghi and C. Coulin, “Requirements elicitation: A survey of techniques, approaches, and tools,” in Engineering and managing software requirements. Springer, 2005, pp. 19–46. [17] A. Ferrari, P. Spoletini, and S. Debnath, “How do requirements evolve during elicitation? an empirical study combining interviews and app store analysis,” Requirements Engineering, vol. 27, no. 4, pp. 489–519, 2022. [18] M. Bano, D. Zowghi, A. Ferrari, P. Spoletini, and B. Donati, “Learning from mistakes: An empirical study of elicitation interviews performed by novices,” in 2018 ieee 26th international requirements engineering conference (re). IEEE, 2018, pp. 182–193. [19] B. Donati, A. Ferrari, P. Spoletini, and S. Gnesi, “Common mistakes of student analysts in requirements elicitation interviews,” in International Working Conference on Requirements Engineering: Foundation for Software Quality. Springer, 2017, pp. 148–164. [20] O. Zaremba and S. Liaskos, “Towards a typology of questions for requirements elicitation interviews,” in 2021 IEEE 29th International Requirements Engineering Conference (RE). IEEE, 2021, pp. 384– 389. [21] X. Han, M. Zhou, M. J. Turner, and T. Yeh, “Designing effective interview chatbots: Automatic chatbot profiling and design suggestion generation for chatbot debugging,” in Proceedings of the 2021 CHI Conference on Human Factors in Computing Systems, 2021, pp. 1–15. [22] M. Bano, D. Zowghi, A. Ferrari, P. Spoletini, and B. Donati, “Teaching requirements elicitation interviews: an empirical study of learning from mistakes,” Requirements Engineering, vol. 24, no. 3, pp. 259–289, 2019. [23] A. Ferrari, P. Spoletini, M. Bano, and D. Zowghi, “Learning requirements elicitation interviews with role-playing, self-assessment and peerreview,” in 2019 IEEE 27th international requirements engineering conference (RE). IEEE, 2019, pp. 28–39. [24] ——, “Sapeer and reversesapeer: teaching requirements elicitation interviews with role-playing and role reversal,” Requirements Engineering, vol. 25, no. 4, pp. 417–438, 2020. [25] S. Debnath and S. Subramanian, “Annoterei! a tool for transcribing and annotating requirements elicitation interviews,” in 2022 IEEE 30th International Requirements Engineering Conference (RE). IEEE, 2022, pp. 255–256. [26] B. Görer and F. B. Aydemir, “Generating requirements elicitation interview scripts with large language models,” in 2023 ieee 31st international requirements engineering conference workshops (rew). IEEE, 2023, pp. 44–51. [27] C. Almeida, I. Copque, A. Oliveira, M. Arouca, A. Barbosa, S. Freire, M. Mendonça, and J. C. Leite, “From elicitation interviews to software requirements: Evaluating llm performance in requirement generation,” in Workshop on Requirements Engineering (WER), 2025. [28] Z. Lu, Y. Yang, H. Ren, H. Hou, H. Xiao, K. Wang, W. Shi, A. Zhou, M. Zhan, and H. Li, “Webgen-bench: Evaluating llms on generating interactive and functional websites from scratch,” Advances in Neural Information Processing Systems, vol. 37, pp. 46 653–46 679, 2025. [29] G. Charness, U. Gneezy, and M. A. Kuhn, “Experimental methods: Between-subject and within-subject design,” Journal of economic behavior & organization, vol. 81, no. 1, pp. 1–8, 2012. [30] G. Voria, F. Casillo, C. Gravino, G. Catolino, and F. Palomba, “Recover: Toward requirements generation from stakeholders’ conversations,” IEEE Transactions on Software Engineering, 2025.