Multi-Agent Requirement Generation

• Multi-agent requirement generation is a collaborative process where specialized AI agents transform project goals into structured, verifiable requirement artifacts.
• It employs explicit agent roles, artifact-centric coordination, and formal verification techniques to ensure requirement completeness and consistency.
• Iterative, data-driven feedback and error-handling mechanisms enhance scalability and precision in automated requirement engineering systems.

Multi-agent requirement generation refers to the systematic, collaborative process by which a set of coordinated AI agents (often powered by LLMs) transform initial project goals or high-level intent into well-structured, actionable, and verifiable requirements artifacts. These artifacts range from stakeholder needs to formal models, user stories, database schemas, or specification documents. Multi-agent requirement generation frameworks are distinguished by the division of labor into specialized agent roles, explicit inter-agent communication protocols, artifact-centric collaboration mechanisms, and—frequently—iterative refinement via feedback or formal verification. Such frameworks are at the foundation of advanced, automated requirement engineering systems, and are widely used in modern software engineering, database design, distributed control, and intelligent task allocation.

1. Agent Specialization, Collaboration, and Architecture

Contemporary frameworks decompose the requirements generation workflow into specialized agent roles, with each agent simulating a distinct human or technical expertise. Examples include Interviewer, EndUser, Deployer, Analyst, Archivist, and Reviewer agents (Jin et al., 17 Jul 2025, Huang et al., 27 Jun 2025); Stakeholder, Collector, Modeler, Checker, and Documenter (Jin et al., 6 May 2024); or crews such as Alpha Captain, Intelligence Officer, Delivery Coordinator, and Tactical Officer in the Impact Mapping approach (Zou et al., 17 Mar 2025).

A typical architecture implements a central artifact pool or workspace (functioning as a blackboard) that acts as a shared memory and coordination nexus (Huang et al., 27 Jun 2025, Jin et al., 17 Jul 2025, Jin et al., 6 May 2024). Agents monitor changes, trigger new actions based on artifact state, and decouple their decision mechanisms from fixed pipelines via event-driven communication. Some frameworks also couple modular, hierarchical, or supervisory layers (e.g., Hierarchy Agent, Feedback and Iteration Agent) to manage escalation, validation, or optimization phases (Harper, 25 Apr 2024).

A general model for agent action selection is:

$a^* = \arg\max_{a \in A} Q(a \mid s, K)$

where $Q$ is the utility of action $a$ for the current pool state $s$ and agent knowledge $K$ (Huang et al., 27 Jun 2025). Roles are instantiated based on task type, with extensibility via embedding–based retrieval over agent profiles for adaptable systems (Li et al., 24 Jul 2025).

2. Formal Specification, Verification, and Modeling

A key advancement in multi-agent requirement generation is the integration of formal methods to ensure completeness, consistency, and verifiability. Methodologies such as Gaia (Akhtar, 2015), formal model transformation via finite state process algebra/LTS analysis (Akhtar, 2015), and coupling of formal and natural language artifacts via intermediate representations (e.g., use case diagrams, Design-State Graphs) are characteristic.

Safety and liveness properties are routinely formalized; for instance, safety invariants using LaTeX-representable formulas (is_Full(c) ∧ can_movetoNext(sn)), and liveness properties as sequence operators or temporal logic (e.g., Move_full = Move . (readUnloadSign . waitForUnloading . unloadCarrier)) (Akhtar, 2015). Verification is conducted via translation to finite automata and exhaustive exploration to preclude deadlock, ensure invariants (e.g., “NOLOSS”), and exhaustively check concurrent execution paths. Labelled Transition System Analyzer (LTSA) is employed for automatic reachability analysis in agent workflows (Akhtar, 2015).

Formal knowledge is also injected by formalizing the requirements in logics such as LTL and ACSL, enabling model checking and deductive verification (NuSMV, Frama-C) (Lu et al., 26 Aug 2025), bridging the gap between ambiguous NLRs and executable, correctness-guaranteed code.

3. Iterative, Data-centric, and Learning-based Generation

Many frameworks operate via multi-stage, iterative refinement leveraging both agent interaction and data-driven feedback. For example, learning agent capabilities and task requirements from performance data yields linear constraints for allocation:

$A y_i \geq b_i$

where $A$ is a learned capability matrix for agent types and $b_i$ represents minimal requirements for task $i$ (Fu et al., 2022). Optimization is framed as maximizing threshold values subject to satisfaction of all observed positives and normalization constraints:

$$\max \sum_{i \in M} \|b_i\|_1 \qquad \text{s.t.} \quad A y_i^l \geq b_i, \quad \|a^c\|_1 = 1$$

(Fu et al., 2022). These learned constraints can be embedded in MILP for downstream planning, route, and schedule optimization.

Sequential and autoregressive approaches construct agent topologies, agent role selection, and communication links from scratch, conditioning on task type (Li et al., 24 Jul 2025). This is formalized as:

$$P(\mathcal{G} \mid \mathcal{Q}, \mathcal{R}) = \prod_{i=1}^{|\mathcal{V}|} P(v_i \mid \mathcal{G}_{<i}, \mathcal{Q}, \mathcal{R}) \prod_{j=1}^{i-1} P(e_{ji} \mid v_i, \mathcal{G}_{<i}, \mathcal{Q})$$

where $\mathcal{G}$ is the graph, $\mathcal{Q}$ is the task query, and $\mathcal{R}$ is the role pool (Li et al., 24 Jul 2025).

4. Communication, Synchronization, and Safety Requirements

In distributed control settings, communication requirements are generated as a function of system safety properties. The coordination-free controllable predecessor operator IPRE(Z) and its safety-constrained variant SIPRE_S(Z) characterize subsets of the state space where independent agent action is admissible:

$$\text{IPRE}(Z) = \{ x \in X(\text{IND}_C) : \forall u \in \text{IND}_C(x), f(x,u) \neq \emptyset \wedge f(x,u) \subseteq Z \}$$

$\text{SIPRE}_S(Z) = Z \cap \text{IPRE}(Z) \cap S$

(Kim et al., 2018). By iterating these operators, regions of communication-free safety are explicitly mapped, informing scheduling, connection delay bounds, and self-triggered communication strategies. The resulting regions are visualized (e.g., as shrinking invariance sets), aiding designers in calibrating the trade-off between communication overhead and system safety (Kim et al., 2018).

5. Error Detection, Reflection, and Robustness Mechanisms

Error propagation, diagnosis, and correction represent critical concerns in multi-agent requirement generation. Reflective agent roles and nested collaborative groups enable systematic validation and improvement at each design stage, as demonstrated in SchemaAgent, which incorporates error detection/correction experts to prevent the cascading of schema design errors (Wang et al., 31 Mar 2025). ARTIFACT POOL strategies allow event-driven triggers for revisiting, revising, and validating specifications in response to detected anomalies, with reviewer agents enforcing quality gates (e.g., completeness, consistency, SRS standard alignment) (Huang et al., 27 Jun 2025, Jin et al., 17 Jul 2025, Jin et al., 6 May 2024).

Iterative, self-evolving frameworks such as EvoMAC employ a textual backpropagation process for network update:

$$\mathcal{A}_g^{(k+1)} = \mathcal{U}(\mathcal{A}_g^{(k)}, \nabla L^{(k)})$$

where $$\nabla L^{(k)} = \mathcal{G}(\mathcal{A}_g^{(k)}, L^{(k)})$$ encodes environmental feedback from unit-test logs, and $\mathcal{U}$ updates the coding network based on this textual gradient (Hu et al., 22 Oct 2024).

6. Evaluation Metrics, Benchmarks, and Empirical Results

Empirical frameworks evaluate requirement generation using precision, recall, F1 (for correctness and completeness of model extraction), semantic similarity on embeddings (Sami et al., 18 Aug 2024), diversity/convex hull metrics (Jin et al., 17 Jul 2025), factuality hit rates (FHR) and quality/consistency evaluation (QuACE) (Zou et al., 17 Mar 2025). Specialized benchmarks such as rSDE-Bench (with itemized requirements-auto testcase alignment) (Hu et al., 22 Oct 2024), RSchema (schema/attribute/PK matching) (Wang et al., 31 Mar 2025), and SR-Eval (stepwise refinement, graph-based decomposition, and test alignment) (Zhan et al., 23 Sep 2025) provide high-fidelity, requirement-centric validation.

Performance results emphasize the superiority of explicit multi-agent decomposition for requirements generation compared with single-agent or monolithic prompting. For instance, MARE achieved up to 30.2% improvement in use case diagram extraction precision and a 15.4% F1 gain in problem diagram tasks over SOTA (Jin et al., 6 May 2024). Chain-of-Thought and agent profiling strategies yielded additional improvements (up to 6% in FHR) (Zou et al., 17 Mar 2025). Knowledge-driven agent orchestration generated more diverse and accurate requirements lists, as shown by convex hull/diversity metrics (Jin et al., 17 Jul 2025).

7. Future Directions and Research Opportunities

Open research opportunities focus on enhancing knowledge extraction from literature and past projects for agent knowledge modules (Jin et al., 17 Jul 2025), optimizing agent generation and action selection (Huang et al., 27 Jun 2025), dynamic and multi-modal agent networks (Li et al., 24 Jul 2025), integration of formal verification throughout the pipeline (Lu et al., 26 Aug 2025), reinforcement–driven agent orchestration, and explicable, human-in-the-loop methodologies to improve traceability and trust.

Scalability, context window limitations, robustness to hallucination, and propagation of upstream errors are actively addressed via modular memory management, event-driven communication, hybrid human–agent workflows, and advanced toolchain integration (Khanzadeh, 26 Jul 2025, Sami et al., 8 Jun 2024). Dynamic topology optimization (autoregessive graph generation) is advancing the field toward fully adaptive, efficiency-optimized multi-agent ecosystems (Li et al., 24 Jul 2025).

---

This synthesis captures the foundational principles, architectural strategies, formal models, iteration and learning mechanisms, safety and communication requirements, empirical results, error handling protocols, and ongoing research questions that define multi-agent requirement generation in contemporary arXiv-level research.