An Autonomy Aware Metamodel for Human AI Collaboration in Software Engineering

arXiv:2609.06720v1 [cs.SE] 6 Sep 2026

An Autonomy-Aware Metamodel for Human–AI Collaboration in Software Engineering Md Mahade Hasan

Md Toufique Hasan

Zheying Zhang

mdmahade.hasan@tuni.fi Tampere University Finland

mdtoufique.hasan@tuni.fi Tampere University Finland

zheying.zhang@tuni.fi Tampere University Finland

Kalle Kulonen

Konsta Kalliokoski

François Christophe

kalle.kulonen@tuni.fi Tampere University Finland

konsta.m.kalliokoski@jyu.fi University of Jyväskylä Finland

francois.m.christophe@jyu.fi University of Jyväskylä Finland

Tommi Mikkonen

Pekka Abrahamsson

tommi.j.mikkonen@jyu.fi University of Jyväskylä Finland

pekka.abrahamsson@tuni.fi Tampere University Finland

Abstract Artificial Intelligence (AI) is shifting software engineering from tool-supported processes towards AI-first collaboration, where authority is dynamically distributed across human and artificial actors. However, existing method engineering approaches assume static, human-centric control and provide limited support explicitly capturing evolving autonomy. This paper presents a vision for autonomy-aware method engineering by proposing a metamodel that treats autonomy not as a fixed property of an actor, but as a derived, situation-dependent authority assignment determined by task, context, and collaboration pattern. The metamodel formalizes autonomy through four authority dimensions: task execution, task decomposition, task initiation, and collaboration reconfiguration. Through an analytical instantiation with a multi-agent requirements analysis tool, we illustrate how the metamodel supports dynamic authority assignment. This work provides a conceptual foundation for governance-aware, adaptable, and AI-first software engineering methods.

CCS Concepts • Software and its engineering → Software design engineering; Software development methods; Collaboration in software development; • Computing methodologies → Multi-agent systems.

Keywords Software engineering methods, Human-AI collaboration, multiagent system, Method engineering, Metamodel, Autonomy-aware

1

Introduction

Software engineering (SE) has evolved through successive waves of abstraction, transitioning from informal coordination and manual artifact production towards increasingly formalized and toolsupported practices. From Computer-Aided Software Engineering (CASE) environments to method engineering approaches based on

process metamodels, such as the Software and Systems Process Engineering Metamodel (SPEM), these advances established modeling backbones that made roles, activities, and artifacts governable, and enabled systematic construction and tailoring of SE methods to project contexts [8, 29, 23, 6, 13]. The growing integration of AI in SE marks a new transition. Development practices are shifting toward increasingly human–AI collaborative teams, where AI agents not only generate artifacts but also execute tasks, decompose work, and coordinate activities. In contrast to earlier tool-assisted environments with stable human-centered authority, contemporary AI systems increasingly participate in task allocation, workflow configuration, and decisionmaking [12, 21]. This shift introduces dynamic and distributed authority, where control varies across human and artificial actors, tasks, and contexts, and evolves with advancing AI capabilities. However, existing method engineering approaches largely assume static authority assignments and provide limited support for representing dynamic autonomy and situational authority redistribution. While they effectively capture process structure, they do not explicitly model how autonomy varies across collaboration settings or adapts to context and governance constraints. Consequently, the transition from tool-assisted workflows toward AI-first SE teams remains conceptually under-specified and methodologically unguided. Recent work on multi-agent tools [1, 2, 17] explores autonomous workflows but typically treats autonomy as implicit within execution models rather than as an explicit modeling dimension. To address this gap in method engineering, this study proposes an autonomy-aware metamodel for modeling dynamic collaboration in AI-first SE teams. The metamodel defines seven core constructs – Actor, Task, Capability, Artifact, Collaboration Pattern, Constraint, and Context – and treats autonomy as a derived, situation-dependent property of Actors instances. Specifically, an actor’s autonomy level is determined by the interplay of task, context, and collaboration pattern. This enables flexible authority assignment while preserving a stable process structure, and makes

coordination and governance explicit through collaboration patterns and interaction rules. This work is visionary in its nature. Through analytical instantiation with multi-agent requirements analysis tool [26], we illustrate how the metamodel can support variation in autonomy assignments and authority redistribution. By making autonomy and collaboration explicit at the metamodel level, the paper contributes a foundation for future research on adaptable SE methods in AI-first teams. The remainder of this paper is organized as follows. Section 2 reviews related work. Section 3 presents the proposed metamodel. Section 4 illustrates its use through an analytical instantiation. Section 5 discusses implications and future work, and Section 6 concludes the paper.

2

SE systems further illustrate this shift by distributing responsibilities among specialized AI agents that collaboratively analyze code, perform refactoring tasks, and iteratively improve software artifacts [28]. Empirical studies show that developers increasingly perceive these systems as collaborative teams operating across a spectrum from AI-assisted to more autonomous workflows [21]. This transformation introduces challenges for coordination, transparency, and governance. Interacting agents can cause error propagation, non-deterministic behavior, and limited interpretability, motivating layered transparency and structured communication for debugging and control [21, 9]. Recent work on automated governance for human-agent collaboration in software projects argues that joint decision-making by humans and AI-powered agents requires explicit mechanisms for assigning roles and responsibilities, as well as for establishing consensus among heterogeneous participants [2]. Complementing this perspective, agent design patterns further highlight the importance of making planning, cooperation, team structure, and decision mechanisms explicit in agentic systems [18]. Hybrid human-AI teams also redistribute effort across the lifecycle, where the actual and perceived autonomy influence communication, coordination, and shared mental models, while task decomposition and role allocation improve collaboration and situational awareness [20, 16]. Toward Autonomy-Aware Method Models. Together, these research streams motivate autonomy-aware method modeling, but they remain fragmented. Method engineering structures development methods, ontology and agent-oriented work models system semantics and interaction, and AI-driven SE studies collaboration. None provides a unified process metamodel for authority redistribution under varying autonomy conditions. From a governance perspective, Domain Specific Language (DSL) for human-agent collaboration treats autonomy as an explicit AI-agent characteristic, but does not define autonomy levels or explain how different degrees of autonomy redistribute authority across development [2]. Prior work has examined autonomy levels in human-autonomy teaming [22], and AI-SEAL [7] uses automation level to classify AI applications in SE and reason about risk. Recent BPMN work also supports human-agentic workflow representation [1]. Overall, these works view autonomy mainly through interaction, workflow, governance, or risk-analysis lenses, rather than as a methodmodeling construct for explaining authority redistribution across actors, tasks, constraints, contexts, and collaboration patterns. As a result, there remains a lack of a SE process metamodel that captures both method engineering structure and dynamic autonomy redistribution in human-AI collaboration. This gap motivates an autonomy-aware metamodel that models autonomy as a first-class dimension for human-AI SE, allowing authority distribution to vary across human and artificial actors without redesigning the underlying process structure. Unlike workflow-level views, this approach treats autonomy as a methodengineering concern for specifying and adapting responsibility and authority.

Background and Related Work

Method engineering provides the foundation for constructing, adapting, and analyzing SE methods. Within method engineering, process metamodeling provides a formal foundation for representing methods as explicit, analyzable, and reusable structures. Established frameworks such as SPEM 2.0 [23], ISO/IEC 24744 [10], and the SEMAT Essence kernel [15] define abstractions for roles, tasks, activities, work products, and their relationships. They enable reuse, configuration, consistency checking, and reasoning over method structures [6, 11, 13]. Yet these method engineering approaches largely assume static, human-centered method structures and provide limited support for modeling how authority, coordination, and decision-making are distributed across human and AI actors. Ontology and Agent-Oriented Approaches. Ontology-based and agent-oriented approaches complement process metamodeling by formally representing systems, artifacts, and interactions. Unified design and agent-oriented ontologies capture goals, tasks, behaviors, and commitments for semantic interoperability and automated reasoning across heterogeneous systems [19, 5, 3]. Processoriented agent engineering has also used BPMN to model high-level agent behavior and communication in multi-agent systems [17]. LLM-based ontology engineering uses agent-based architectures combining structured metadata (symbolic) and text embeddings (vector) of ontology entities to improve semantic matching and reasoning [25]. Foundation-model-based agents have also been studied through design patterns for planning, reflection, multi-agent cooperation, and guardrail mechanisms [18]. However, these approaches mainly model predefined system behavior and interaction patterns, rather than the construction and adaptation of SE methods. Consequently, they enrich semantic rigor and provide useful architectural and process-oriented guidance, but do not provide a process metamodel in which methodological structure and authority distribution are modeled together. Human-AI Collaboration in Software Engineering. Advances in AI are transforming SE into human-AI collaboration, where AI systems participate in task execution, decomposition, and coordination. Emerging multi-agent development frameworks [12, 14, 9] conceptualize development as coordinated systems of human and artificial agents, where specialized AI agents assume roles, exchange artifacts, and iteratively refine outputs. Recent multi-agent 2

Figure 1: A metamodel specifying human-AI collaborative software engineering methods

3

Autonomy-Aware Metamodel Definition

abstract class ConstrainableElement serves as a common superclass for Actor, Task, and Artifact. This allows constraints to be uniformly attached to these elements. This section defines each construct and its role in the metamodel. An Actor is a participant in performing a SE task. It can be either a human or an AI agent, as specified by the actorType attribute. Actors are represented uniformly at the metamodel level, while their operational authority is distinguished through the autonomyLevel, a dynamic and context-dependent attribute. This attribute defines the extent to which an actor may execute, decompose, or initiate tasks, or modify collaboration structures. Thus, authority becomes an explicit and configurable modeling parameter rather than an implicit property of the process. Each actor also has a role describing its responsibility in the method and may provide one or more Capability instances. A Task (T) represents a distinct piece of SE work within the method. It may be atomic or decomposed into sub-tasks, thereby supporting the hierarchical structuring of activities. Tasks may also be ordered through the precedes relation, which indicates that one task should occur before another. Tasks are performed by Actors with the required Capability instances and are linked to the Artifacts they use or produce. They are orchestrated through CollaborationPatterns, which specify how work is coordinated across actors. Thus, Task provides an explicit unit for modeling execution, decomposition, coordination, and responsibility allocation. The goal attribute describes the intended outcome of the task.

Building on the limitations identified in the previous section, this study proposes an autonomy-aware metamodel for human-AI collaborative SE. In this work, autonomy-aware denotes that autonomy is modeled as an explicit attribute of actors, capturing the degree of authority they hold over task execution, task decomposition, task initiation, and collaboration reconfiguration. By representing autonomy at the actor level, the metamodel separates the structural definition of a process from the distribution of authority among human and AI actors. As a result, autonomy can vary without changing the core structure of the method. Grounded in method engineering approaches, the metamodel represents human and artificial participants uniformly as actors embedded in a shared socio-technical method structure. This allows the metamodel to represent both the stable structure of a collaborative method and the redistribution of authority as human-AI practices evolve toward higher-autonomy. Figure 1 presents the metamodel as a class diagram specifying its core constructs, attributes, and relationships.

3.1

Core Constructs

The metamodel comprises seven core constructs: Actor, Task, Capability, Artifact, CollaborationPattern, Constraint, and Context. These constructs capture who participates in human-AI collaborative SE practices, what activities are performed, which capabilities and artifacts are involved, under which contextual conditions collaboration occurs, and which constraints govern the process. In addition, the 3

3.2

A Capability (Cap) represents a functional ability needed to perform a task. In the metamodel, Tasks are associated with one or more Capability instances they require, while Actors possess Capability instances that enable task performance. This separates task requirements from performer identity, and allows task allocation to be modeled in terms of required abilities rather than fixed roles. As a result, the metamodel supports substitution and gradual redistribution of responsibilities between human and AI Actors. An Artifact (A) is a work product created, used, modified, or maintained during the execution of a Task. Artifacts include outputs such as requirements documents, design models, source code, test cases, and deployment scripts, as well as intermediate items relevant to the software system or its development. They are versioned and may trace to other Artifact instances. Artifacts provide the basis for tracing, coordination, and evaluation across Tasks and Actors. A CollaborationPattern encapsulates a reusable coordination structure that organizes actors, tasks, and artifacts into a coherent method fragment. It specifies how task is coordinated through interactionRules, how participating actors are organized through teamStructure (e.g., centralized, hierarchical, or decentralized), and how decisions are reached through decisionModel (e.g., Voting, Debating, Consensus, or HumanApproval ). By making coordination, team structures, and decision-making explicit, a CollaborationPattern provides a reusable specification of both collaboration and governance in human–AI SE methods. Each CollaborationPattern is situated within a particular Context, which defines its situational applicability and normative boundaries. A Constraint (C) specifies rules or conditions that restrict or regulate the permissible behavior of elements in a method. Constraints are prescriptive elements of the metamodel: they define what is allowed, required, or prohibited for constrainable elements. They may capture governance policies, validation requirements, compliance obligations, safety conditions, or organizational procedures. For example, a governance rule may require human approval before a deployment task, a safety condition may restrict an AI actor from autonomously executing critical tasks, and a validation rule may require that a generated artifact satisfy predefined quality criteria. Constraints are connected to ConstrainableElements through the constrains relation, allowing the same constraint mechanism to apply to Actors, Tasks, and Artifacts. A Context (Cx) characterizes the situational environment in which a CollaborationPattern is applicable. Unlike Constraints, which prescribe rules or restrictions, Context provides descriptive information about the operating environment. It has the attributes id, developmentPhase, regulatoryEnvironment, organizationalNorm, and systemType, which capture lifecycle, regulatory, organizational, and system-specific conditions. For example, a task in a highly regulated domain may require a different collaboration pattern than the same task in an exploratory prototype setting. By separating situational applicability from collaboration structure, the metamodel supports reuse and adaptation across different environments. Together, the above constructs provide a stable basis for modeling authority redistribution.

Autonomy Levels

Autonomy constitutes the central differentiating dimension of the proposed metamodel. Rather than embedding authority assumptions within Actor types, autonomy is modeled explicitly as a parameter that governs an actor’s authority over tasks and collaboration patterns. This makes authority redistribution analyzable and allows human-AI collaboration to vary without changing the structure of the method. Formally, for a given actor in a specific situation, autonomy can be represented as: AutonomyLevel = 𝑓 (Task, Context, CollaborationPattern) This formulation emphasizes that autonomy is not an inherent or fixed property of an actor. The same actor may receive different autonomy level assignments depending on the authority required by the task, the situational restrictions imposed by the context, and the coordination and decision rules defined by the collaboration. 3.2.1 Rationale for Autonomy Specification. Autonomy is defined in terms of operational authority over four dimensions of process control. These dimensions correspond to the minimal set of authority boundaries that distinguish meaningfully different forms of control in SE practices: executing an assigned task, structuring work independently, initiating further action, and modifying the collaboration itself. These dimensions provide the basis for defining the autonomy levels from AL0 to AL4. Together, they form a complete and non-redundant characterization of operational independence in human-AI collaboration: (1) Task Execution – authority to perform a defined task. (2) Task Decomposition – authority to refine a task into subtasks. (3) Task Initiation – authority to initiate new tasks without an external trigger. (4) Collaboration Reconfiguration – authority to modify participating actors, workflow structure, artifact flow, contextual bindings, or applicable constraints. Across these four dimensions, autonomy captures the extent to which an actor can autonomously sense, decide, and act to achieve task-specific goals [4]. This aligns with prior work that characterizes autonomy as graded decision latitude over information acquisition, decision selection, and action implementation in human-automation and human-autonomy teaming [22]. It also corresponds to established classifications of automation levels in human-machine collaboration [27, 24, 7]. 3.2.2 Autonomy Level Definition. Grounded in the four authority dimensions defined above, we define five autonomy levels (ALs), as summarized in Table 1. These levels characterize progressively broader distributions of control between human and AI actors. • AL0: PassiveTool. The actor has no authority over task execution, task decomposition, task initiation, or collaboration reconfiguration; all such authority remains with human actors. • AL1: SuggestiveAssistant. The actor may generate suggestions or other supportive materials, but it does not execute tasks or produce the primary output artifacts of the task. Human or AI actors remain responsible for producing the 4

Table 1: Autonomy Levels with Operational Authority and Alignment to Related Classifications Level

Description

Task Execution

Task Decomposition

Task Initiation

Modify Collaboration

Human Decision Role

AL0 AL1 AL2 AL3 AL4

PassiveTool SuggestiveAssistant DelegatedExecutor ProactiveActor AutonomousOrchestrator

0 0 (suggestion) 1 1 1

0 0 0 1 1

0 0 0 1 1

0 0 0 0 1

Always LA1 Required LA2–LA4 Context-dependent LA5–LA6 Required for critical decision LA6–LA7 Human oversight LA8–LA10

output artifacts. Any operational use of AL1 outputs requires human confirmation. • AL2: DelegatedExecutor. The actor may execute assigned tasks within predefined boundaries. However, authority over task decomposition, task initiation, and collaboration structure remains with human actors. • AL3: ProactiveActor. The actor may execute tasks, decompose them into sub-tasks, and initiate sub-tasks within the assigned scope of work. Critical decisions remain subject to human approval. • AL4: AutonomousOrchestrator. The actor may execute tasks, decompose work, initiate new tasks, and modify collaboration patterns. Human involvement shifts from direct control to supervisory oversight.

constraint, as well as the attributes of all instances are not shown in the diagram, but publicly accessible in the repository1 . This tool instantiation illustrates how collaboration can be explicitly modeled through the CollaborationPattern construct. Unlike traditional process models that focus primarily on activities and artifacts, the proposed metamodel captures team structures, decision-making mechanisms, and interaction rules. Table 2 summarizes two CollaborationPattern instances derived from the tool. Requirements generation is modeled as a hierarchical collaboration pattern with a HumanApproval decision model: the User delegates the task to the PO agent, which coordinates suggestions from Dev and QA before returning the generated requirements for human approval. Requirements prioritization is modeled as a centralized voting pattern: PO, Dev, and QA agents independently evaluate and generate prioritization lists for user stories, while the Manager agent aggregates the results and resolves conflicts according to the User vote. The instantiation also illustrates the central idea of the metamodel where autonomy is modeled as a dynamic and situationdependent property. As defined in Section 3.2, autonomy is not a fixed attribute of an actor. Instead, it is determined as a function of the task being performed, the surrounding context, and the collaboration pattern. The same actor may therefore operate with different autonomy levels across different situations. For example, both collaboration scenarios shown in Figure 2 occur within the same requirements-engineering context. However, differences in autonomy arise from changes in task responsibilities and collaboration patterns. During requirements generation, the PO agent operates at AL2 because it is delegated responsibility for producing the requirements artifact, while the Dev and QA agents operate at AL1 because they only provide supporting suggestions. On the other hand, during requirements prioritization, the Dev and QA agents independently generate prioritization lists that directly contribute to the final outcome. As a result, their autonomy levels increase from AL1 to AL2. Likewise, human actors may experience varying autonomy depending on organizational policies, regulatory constraints, or safety-critical conditions. This analytical instantiation demonstrates that the proposed metamodel not only captures the structural elements of human–AI SE methods, but also provides explicit mechanisms for modeling collaboration structures, decision-making processes, and dynamic authority redistribution. As a result, the same SE method can evolve from human-governed collaboration toward increasingly autonomous AI-first teamwork without requiring changes to its underlying process structure.

Taken together, these levels provide a structured basis for modeling gradual authority redistribution from human-centered methods to AI-first orchestration. To situate them with respect to prior work, Table 1 relates each autonomy level to indicative ranges in the Levels of Automation (LA) scale, originally proposed by Sheridan and Verplank [27]. The LA scale ranges from LA1, where the human makes and implements all decisions, to LA10, where the computer acts fully autonomously and informs the human only if it decides to do so. The LA scale was extended by Parasuraman et al. [24] across four functional types of human-machine interaction, and later adopted in the AI-SEAL framework [7] to characterize AI support in SE . The LA scale values in Table 1 describe the LA intervals in which concrete systems operating at a given ALi are likely to fall, as an interpretive reference point.

4

LA scale [27, 24, 7]

Illustrative Instantiation of the Metamodel

To illustrate the applicability of the proposed metamodel, we instantiate it using a multi-agent requirements analysis tool [26]. The tool supports user story generation and prioritization through collaboration between a human user and multiple AI agents, including Product Owner (PO), Developer (Dev), Quality Assurance specialist (QA), and Manager agents. The system therefore provides an example of a human–AI collaboration team conducting requirements analysis tasks. As shown in Figure 2, the sequence diagram captures the interactions among the actors in tasks (T*), as well as the artifacts (A*) they use and produce. The workflow is organized into two collaboration scenarios highlighted in the figure: Requirements Generation and Requirements Prioritization. Both scenarios operate within the Context of requirements engineering and are governed by Constraints such as prioritization rules. To keep the presentation clear and simplified, the instantiations of context and

1 https://zenodo.org/records/20748480

5

Table 2: CollaborationPattern instances identified in the requirements analysis tool id

name

teamStructure

decisionModel

interactionRules

1

Requirements Generation

Hierarchical {User, PO, Dev, QA}

HumanApproval

User delegates requirements generation to PO; PO requests suggestions from Dev and QA; Dev and QA return suggestions; PO synthesizes requirements; User approves or requests revisions.

2

Requirements Pri- Centralized oritization {User, PO, Dev, QA, Manager}

Voting

User provides the prioritization technique; PO, Dev, and QA independently prioritize requirements; Manager aggregates prioritization result based on User vote.

Figure 2: A sequence diagram for the requirements analysis tool

5

Discussion and Future Plans

This vision paper opens four directions for further research. First, we will refine the semantics of the autonomy function by identifying the concrete task, context, constraint, and collaborationpattern parameters that influence autonomy assignment. This includes clarifying how team structures, decision models, interaction rules, task criticality, and governance constraints affect the permissible autonomy level of each actor. Second, we will conduct comparative case studies across SE activities such as requirements analysis, architecture design, coding, testing, and maintenance. These studies will examine whether the same metamodel constructs can represent diverse human–AI collaboration settings and whether additional constructs or relationships are needed. Third, we will develop AI-assisted tool support for automated method modeling. Such support could extract candidate

The proposed metamodel is intended as an initial step toward autonomy-aware method engineering for human–AI collaboration in AI-first SE teams. Its primary contribution is the separation of method structure from authority assignment. Actors, tasks, artifacts, capabilities, contexts, constraints, and collaboration patterns provide a stable representation of a SE method, while autonomy levels vary according to the task, context, and collaboration pattern. The illustrative instantiation further highlights that autonomy should be treated as a situation-dependent property rather than as a fixed characteristic of an actor. Differences in autonomy emerge from task responsibilities, collaboration patterns, governance conditions, and decision-making arrangements, rather than from technical capability alone. This distinction is important for designing AIfirst methods that remain adaptable while preserving appropriate human oversight and governance. 6

actors, tasks, artifacts, capabilities, constraints, contexts, and collaboration patterns from process descriptions, workflow traces, or natural-language scenarios, suggest autonomy levels by analyzing task responsibilities, decision models, interaction rules, and governance constraints, and check consistency with governance constraints under human review. Fourth, we will investigate runtime adaptation and governance. In future AI-first teams, autonomy may need to change dynamically based on task criticality, uncertainty, regulatory conditions, observed performance, or human trust. We therefore plan to explore how the metamodel can be connected to monitoring mechanisms that support adaptive authority allocation, extending it from a design-time specification instrument into a governance mechanism for evolving human–AI SE teams. Together, these steps aim to turn the metamodel from a conceptual proposal into an empirically grounded and tool-supported approach for modeling and governing AI-first SE teams.

6

[6]

[7]

[8] [9] [10]

[11] [12]

[13] [14]

Conclusion

[15]

This paper proposed an autonomy-aware metamodel for human–AI collaboration in AI-first teams. The metamodel treats autonomy as a situation-dependent property derived from the task, context, and collaboration pattern, and formalizes it through authority over task execution, task decomposition, task initiation, and collaboration reconfiguration. By separating method structure from authority assignment, it enables method engineers to model stable collaboration structures while analyzing how authority is distributed across human and AI actors. The illustrative instantiation with a multi-agent requirements analysis tool shows how autonomy levels may vary across requirements generation and prioritization according to task responsibilities, team structure, decision model, and interaction rules. As a vision paper, this work points toward a new generation of software engineering methods that are not only AI-enabled, but also governable, adaptable, and explicit about authority distribution in human–AI collaboration.

[22]

Acknowledgments

[23]

[16]

[17]

[18]

[19]

[20]

[21]

This research was partially supported by the ANSE (AI Native Software Engineering) project funded by Business Finland and by FAST (Finnish Software Engineering Doctoral Research Network). The authors gratefully acknowledge this support.

[24]

References

[26]

[1]

[2]

[3] [4]

[5]

[25]

Adem Ait, Javier Luis Cánovas Izquierdo, and Jordi Cabot. 2026. Towards modeling human-agentic collaborative workflows: a bpmn extension. In Software Engineering and Advanced Applications. Davide Taibi and Darja Smite, (Eds.) Springer Nature Switzerland, Cham, 367–382. Adem Ait, Gwendal Jouneaux, Javier Luis Cánovas Izquierdo, and Jordi Cabot. 2025. Towards automated governance: a dsl for human-agent collaboration in software projects. In 2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE), 3891–3895. doi:10.1109/ASE63991.2025.00337. Bernhard Bauer and Jörg P Müller. 2004. Methodologies and modeling languages. Agent-Based Software Development, 77–131. Jenay M. Beer, Arthur D. Fisk, and Wendy A. Rogers. 2014. Toward a framework for levels of robot autonomy in human-robot interaction. J. Hum.-Robot Interact., 3, 2, (July 2014), 74–99. doi:10.5898/JHRI.3.2.Beer. Giampaolo Bella, Domenico Cantone, Carmelo Fabio Longo, Marianna NicolosiAsmundo, and Daniele Francesco Santamaria. 2023. The ontology for agents, systems and integration of services: oasis version 2. Intelligenza Artificiale, 17, 1, 51–62.

[27] [28]

[29]

7

Sjaak Brinkkemper. 1996. Method engineering: engineering of information systems development methods and tools. Information and software technology, 38, 4, 275–280. Robert Feldt, Francisco G. de Oliveira Neto, and Richard Torkar. 2018. Ways of applying artificial intelligence in software engineering. In Proceedings of the 6th International Workshop on Realizing Artificial Intelligence Synergies in Software Engineering (RAISE ’18). Association for Computing Machinery, Gothenburg, Sweden, 35–41. isbn: 9781450357234. doi:10.1145/3194104.3194109. Alfonso Fuggetta. 2002. A classification of case technology. Computer, 26, 12, 25–38. Yuyao Ge et al. 2025. A survey of vibe coding with large language models. arXiv preprint arXiv:2510.12399. Cesar Gonzalez-Perez. 2007. Supporting situational method engineering with iso/iec 24744 and the work product pool approach. In Working conference on method engineering. Springer, 7–18. Frank Harmsen, Sjaak Brinkkemper, and J. Oei. 1994. Situational method engineering for information system project approaches. In (Jan. 1994), 169–194. Ahmed E Hassan, Gustavo A Oliva, Dayi Lin, Boyuan Chen, Zhen Ming, et al. 2024. Towards ai-native software engineering (se 3.0): a vision and a challenge roadmap. arXiv preprint arXiv:2410.06107. Brian Henderson-Sellers and Jolita Ralyté. 2010. Situational method engineering: state-of-the-art review. Journal of Universal Computer Science. Sirui Hong et al. 2023. Metagpt: meta programming for a multi-agent collaborative framework. In The twelfth international conference on learning representations. Ivar Jacobson, Pan-Wei Ng, Paul E McMahon, Ian Spence, and Svante Lidman. 2012. The essence of software engineering: the semat kernel. Communications of the ACM, 55, 12, 42–49. Sotaro Karakama, Natsuki Matsunami, and Masayuki Ito. 2021. Task decomposition and role sharing for real-time human-ai swarm collaboration. International Journal of Smart Computing and Artificial Intelligence, 5, 1, 33–50. Tobias Küster, Marco Lützenberger, Axel Heßler, and Benjamin Hirsch. 2012. Integrating process modelling into multi-agent system engineering. 8, 1, (Jan. 2012), 105–124. doi:10.3233/MGS-2012-0182. Yue Liu, Sin Kit Lo, Qinghua Lu, Liming Zhu, Dehai Zhao, Xiwei Xu, Stefan Harrer, and Jon Whittle. 2025. Agent design pattern catalogue: a collection of architectural patterns for foundation model based agents. Journal of Systems and Software, 220, 112278. Jinzhi Lu, Junda Ma, Xiaochen Zheng, Guoxin Wang, Han Li, and Dimitris Kiritsis. 2021. Design ontology supporting model-based systems engineering formalisms. IEEE Systems Journal, 16, 4, 5465–5476. Geoff Musick, Thomas A O’Neill, Beau G Schelble, Nathan J McNeese, and Jonn B Henke. 2021. What happens when humans believe their teammate is an ai? an investigation into humans teaming with autonomy. Computers in Human Behavior, 122, 106852. Suchismita Naik, Austin L Toombs, Amanda Snellinger, Scott Saponas, and Amanda K Hall. 2025. Exploring human-ai collaboration using mental models of early adopters of multi-agent generative ai tools. arXiv preprint arXiv:2510.06224. Thomas A. O’Neill, Nathan J. McNeese, Ashley Barron, and Brandon Schelble. 2022. Human–autonomy teaming: a review and analysis of the empirical literature. Human Factors, 64, 5, 904–938. doi:10.1177/0018720820960865. OMG. 2008. Software & systems process engineering metamodel specification (spem) version 2.0. Tech. rep. R. Parasuraman, T.B. Sheridan, and C.D. Wickens. 2000. A model for types and levels of human interaction with automation. IEEE Transactions on Systems, Man, and Cybernetics - Part A: Systems and Humans, 30, 3, 286–297. doi:10.1109 /3468.844354. Zhangcheng Qiang, Weiqing Wang, and Kerry Taylor. 2023. Agent-om: leveraging llm agents for ontology matching. arXiv preprint arXiv:2312.00326. Malik Abdul Sami, Zheying Zhang, Muhammad Waseem, Kai-Kristian Kemell, Zeeshan Rasheed, Tomas Herda, Md. Toufique Hasan, Jussi Rasku, and Pekka Abrahamsson. 2026. A multi-agent llm system for automated requirements analysis: a study on user story generation and prioritization. In Software Engineering and Advanced Applications. Davide Taibi and Darja Smite, (Eds.) Springer Nature Switzerland, Cham, 178–187. isbn: 978-3-032-04200-2. Thomas Sheridan, W. Verplank, and T. Brooks. 1978. Human and computer control of undersea teleoperators, (Dec. 1978). Shahbaz Siddeeq et al. 2026. Llm-based multi-agent system for intelligent refactoring of haskell code. In Product-Focused Software Process Improvement. Springer Nature Switzerland, 408–418. I Sommerville. 2016. Software engineering 10th edition (international computer science). Essex, UK: Pearson Education, 1–808.

Related documents

• AI Harness Engineering: A Runtime Substrate for Foundation-Model Software Agents#180720
• AI Autonomous Evolution X: Structural Foundations of Emergent Autonomous Reasoning in Large-Scale AI Systems#72495
• Developing a Roadmap to an AI-first Organization: A Case Study in Embedded Software Development#1105422
• Collaborative Agent Reasoning Engineering (CARE): A Three-Party Design Methodology for Systematically Engineering AI Agents with Subject Matter Experts, Developers, and Helper Agents#149105
• AI Autonomous Evolution X: Collective Reason and the Structural Shift of Intelligence Beyond the Individual#714496