Towards Modeling Human-Agentic Collaborative Workflows: A BPMN Extension

Adem Ait; Javier Luis C\'anovas Izquierdo; Jordi Cabot

REVIEW 3 major objections 3 minor 1 cited by

Towards Modeling Human-Agentic Collaborative Workflows: A BPMN Extension

T0 review · 3 major / 3 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper argues that standard BPMN cannot precisely specify human-agentic workflows and proposes a lightweight BPMN extension—agent lanes with trust scores, reflection-tagged tasks, and collaboration/merging gateways—to enable their…

desk verdict A clean, honest BPMN extension proposal for human-agentic workflows; the syntax is useful, but the 'precise specification' claim outruns the semantics actually provided. read the letter →

arxiv 2412.05958 v3 pith:LXQ25VGR submitted 2024-12-08 cs.SE

Adem Ait , Javier Luis Cánovas Izquierdo , Jordi Cabot This is my paper · ORCID

classification cs.SE

keywords BPMNextensionhuman-agenticworkflowsmulti-agentsystemsLLMagentstrustscorereflectionstrategiescollaboration

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

LLM-based agents now work alongside humans in mixed workflows, but standard process modeling languages give no way to state who is responsible for a task, how reliable an agent's output is, which reflection strategy the agent should use, or how competing proposals are merged. The paper argues that standard BPMN can express these aspects only through informal text annotations, which invites ambiguity and misreading. It proposes a lightweight BPMN extension that adds an agentic lane carrying a role and a 0-100 trust score, an agentic task tagged with self-, cross-, or human-reflection, and agentic gateways and message flows tagged with cooperation and merging strategies. The extension is defined through the official BPMN extension mechanism and is implemented in an open-source graphical editor. If the proposal works as claimed, mixed human-agent processes could be specified at design time rather than improvised at run time.

What carries the argument

The load-bearing mechanism is a set of four BPMN elements built by extension-by-addition: AgenticLane (a lane extended with role and trust score), AgenticTask (a task extended with self-, cross-, or human-reflection), AgenticOR and AgenticAND gateways and AgenticMessageFlow (diverging and merging points carrying a collaboration mode and a merging strategy). The semantics are carried by a consistent agent marker plus letter modifiers—'m'/'w' for manager/worker, 's'/'c'/'h' for reflection, 'v-ma', 'r-l', 'c-f' and similar codes for merging strategies—so a diagram states who decides and under what rule without natural-language side notes. The same metamodel is re-expressed as a UML profile following the BPMN extension mechanism, which keeps it compatible with standard BPMN tooling.

What would settle it

Take the bug-report model from the paper and have two independent BPMN execution engines run the exported extended diagram without any extra natural-language guidance; if the engines produce different agent assignments, reflection loops, or merging decisions, then the extension alone does not determine the workflow's behavior.

Watch

Extended reading notes

Core claim

The paper's central claim is that the concepts that matter in human-agentic collaboration can be added to BPMN without abandoning the standard: agent identity and reliability, reflection modes for non-deterministic LLM behavior, cooperation modes (voting, role-based, debate, and competition), and merging rules such as majority, leader-driven, fastest, or most complete. To that end it introduces four new metamodel elements: AgenticLane, which adds a Profile (manager or worker role) and an Uncertainty trust score; AgenticTask, which adds a ReflectionMode; AgenticOR and AgenticAND gateways and AgenticMessageFlow, which carry a CollaborationMode and a MergingStrategy. The argument is supported by comparing a bug-report workflow modeled twice: once in standard BPMN, where strategies and trust appear only as natural-language annotations and reflection is simulated with loops, and once with the extension, where those aspects appear as structured markers on familiar BPMN shapes.

Load-bearing premise

The load-bearing premise is that adding lightweight metamodel elements and letter-marked notation is enough to make human-agentic workflows precisely specified, even though no formal semantics are given for reflection, cooperation, or merging strategies; if that premise fails, the extension offers syntax without the claimed precision.

Editorial extensions

If this is right

Practitioners can model human-agent collaborations in BPMN without learning a new language, since the extension keeps the shapes of standard BPMN and adds markers.
Agent reliability becomes a model element: a trust score on lanes, tasks, gateways, and message flows can be recorded at design time and consulted when deciding which agent's output to accept.
Reflection strategies become explicit choices rather than ad hoc loops, so modelers can distinguish self-, cross-, and human-reflection directly in the diagram.
Collaboration and merging strategies (voting, role, debate, competition; majority, leader-driven, fastest, most complete) are attached to the diverging and merging gateways, making the decision rule part of the process definition.
Because the extension follows the standard BPMN extension mechanism and ships with an editor, the models can be exchanged and opened in compliant tooling, a step beyond agent-orchestration frameworks that treat humans as mere triggers.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Beyond the paper: the conceptual elements are largely notation-independent, so the same extension pattern could be ported to UML Activity Diagrams, YAWL, or other process languages that already have lanes, tasks, and gateways.
Beyond the paper: a direct test of the precision claim would be to have two modelers encode the same human-agent scenario, once with standard BPMN and once with the extension, and compare how much their diagrams disagree; the paper does not report such a test.
Beyond the paper: the trust scores invite an arithmetic uncertainty-propagation rule so a workflow's overall reliability can be computed from agent-level scores; the paper explicitly defers this to future work.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

The paper does something straightforward and useful: it identifies a real modeling gap and proposes a concrete, well-structured BPMN extension for human-LLM-agent workflows. The new elements—agentic lanes with role and trust score, agentic tasks with reflection modes, and agentic gateways/message flows with collaboration and merging strategy markers—are a legitimate combination not present in the cited prior work. The authors also ship an open-source editor and follow the BPMN+X method to package the extension, which gives the contribution a reproducible core. The running example is helpful and the notation choices are reasoned with Moody's principles rather than asserted. Credit where due: this is a competent piece of modeling-language engineering.

The soft spots are real but proportionate. The main one is the gap between the abstract's claim of "precise specification" and what is actually delivered. The new constructs are syntactically defined, but their semantics are informal. A trust score of 0-100 has no stated interpretation, update rule, or decision rule; reflection modes have no iteration bounds or stopping conditions; and merging strategy labels like 'v-ma' or 'r-l' are labels, not rules, so two implementations could carry the same diagram and behave differently. Section VIII explicitly defers governance sublanguage, uncertainty propagation, and code generators. So the paper is best read as a syntax/notation proposal with a roadmap, not as a way to precisely specify executable human-agentic workflows. That is an overclaim, but a modest one: the authors are candid about the future work, and the structural contribution stands on its own.

Two smaller points. First, the paper argues that standard BPMN falls short, but the supporting evidence is largely a single running example and a plausible mapping table; there is no systematic baseline comparison or user study. That is fine for an exploratory paper, but the inadequacy claim is asserted more strongly than demonstrated. Second, the trust score's meaningfulness is assumed rather than examined—a percentage attached to an agent without a calibration mechanism could mislead modelers into false precision. The authors note future empirical evaluation, which is the right place to address this.

Who is this for? Researchers and practitioners working on BPMN-centric process modeling for agent orchestration, and tool builders looking for a starting point. It is not a breakthrough, but it is a solid, citable extension proposal with working tooling. My assessment matches the reader's conditional verdict: the syntax is publishable now, the semantics need the promised follow-up. I would send this to peer review; a good referee can push the authors to soften the precision claim and sharpen the roadmap for operational semantics.

Recommendation: engage with it. It deserves serious referee time, and with revision it becomes a useful reference point for the BPMN-agent community.

Referee Report

3 major / 3 minor

Summary. The paper proposes an extension of BPMN for modeling human-agentic collaborative workflows. The authors argue that standard BPMN cannot precisely capture key properties of LLM-based agents—such as role and trust score, reflection strategies, and collaboration/merging strategies—and they introduce new metamodel elements (AgenticLane, AgenticTask, AgenticOR/AND, AgenticMessageFlow) together with a BPMN-like notation using an agent marker and letter codes. The extension is packaged as a standard BPMN extension following the BPMN+X approach, and a proof-of-concept editor is implemented with Sirius/Aconite and made available as open source. The paper also presents a running example of a bug-report resolution process to illustrate both the limitations of standard BPMN and the proposed extension.

Significance. The topic is timely: the orchestration of human-agentic workflows is an active problem, and there is a real gap in process modeling languages for specifying agent roles, trust, reflection, and cooperation strategies. The paper's strengths are its systematic analysis of how agentic concepts map (or fail to map) to BPMN, the relatively disciplined use of the BPMN extension mechanism via BPMN+X, and the open-source implementation with a worked example, which supports reproducibility. If the extension were complemented with precise semantics for the new constructs, it could serve as a practical blueprint for extending workflow languages to mixed human-agent settings. As it stands, the contribution is best described as a syntax and notation proposal whose claimed 'precise specification' is not yet supported by the evidence in the manuscript.

major comments (3)

[Abstract, Section I, Section VIII] The central claim that the extension enables 'precise definition' of human-agentic workflows is not supported by the semantics actually provided. Section IV defines new element types and attributes, but no operational semantics are given for trust scores, reflection modes, or merging strategies; Section VIII explicitly defers the governance sublanguage, uncertainty propagation, and code generators to future work. The current contribution is a structural and notational extension. This is not an internal inconsistency, but it is an overclaim relative to the evidence. The authors should either provide at least a core operational semantics (e.g., for trust-score update and merging) or temper the precision claim and present the work as an exploratory notation proposal.
[Section IV.A, Figure 3] The trust score is defined only as a percentage value (0–100) attached to an agent or task. No meaning, update rule, or decision rule is specified, despite Section IV.B claiming that the trust score 'can be further used in the workflow to decide the next steps.' Without such semantics, the trust score is an uninterpreted attribute and cannot carry the governance information that the motivation promises.
[Section IV.C, Table II] The merging strategies (e.g., 'v-ma', 'r-l', 'c-f') are presented as labels rather than as rules. For instance, 'r-l' for leader-driven and 'v-ma' for majority voting are not defined in terms of how agents' outputs are compared, aggregated, or selected, and the same notation can represent different behaviors. The paper's own Section VIII admits that the governance sublanguage is future work. The manuscript needs either to provide the missing semantics for these strategies or to clearly limit the scope to syntax.

minor comments (3)

[Section IV.D] The sentence 'Note that the notation shown in Table II the 'x' is used as a placeholder' is grammatically incomplete and confusing; the role of the 'x' placeholder in the table should be stated precisely.
[Section VI, Figure 8] The proof-of-concept is described as a graphical editor, which demonstrates that the notation can be drawn but does not demonstrate that the modeled workflows can be enacted or checked. A sentence clarifying this distinction would be helpful.
[Section IV.D] The claim that the notation conforms to Moody's principles (e.g., semiotic clarity, semantic transparency) is asserted rather than evaluated. The paper itself defers empirical evaluation to future work, so the current wording should be softened accordingly.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the paper is a design proposal for a BPMN extension, with no fitted quantities or predictions that reduce to inputs.

full rationale

The paper makes no empirical predictions and fits no parameters, so the central circularity patterns (fitted input called prediction, self-definitional equivalence) do not apply. Its contribution is a language extension: Section III identifies limitations of standard BPMN for human-agentic workflows, and Section IV introduces new metamodel elements (AgenticLane, AgenticTask, AgenticOR/AND, AgenticMessageFlow) with attributes for role, trust score, reflection mode, and collaboration/merging strategies. The claimed 'precise specification' is supported by a formalized metamodel and a BPMN+X profile (Section V), plus an implemented open-source editor (Section VI). The concepts are grounded in external literature (Guo et al. [6], Liu et al. [9], Shinn et al. [13], Moody [10]) rather than in the authors' prior work. The only author self-citation is [1], used in the future-work paragraph about empirically evaluating the notation; it is not load-bearing for the central claim. Section VIII explicitly defers governance sublanguages, uncertainty propagation, and code generators to future work, which is an acknowledged scope limitation, not a circular step. The proof-of-concept implementation via Sirius and Aconite is implementation support, not circular reasoning. No derivation chain, equation identity, or self-citation chain forces the paper's conclusions.

Assumptions & free parameters 1 free parameters · 3 assumptions · 3 invented entities

The central claim rests on the completeness of the cited agentic taxonomy, the sufficiency of a lightweight syntactic extension, and the meaningfulness of a simple percentage trust score. None of these premises is proven in the paper, and several are explicitly deferred to future work in Section VIII.

free parameters (1)

Trust score scale (0-100)
Section IV.A defines the trust score as a percentage value with no empirical backing for the scale or what value corresponds to reliable; it is a designer-supplied input the workflow semantics depend on.

assumptions (3)

domain assumption The taxonomy of reflection strategies (self, cross, human) and cooperation modes (voting, role, debate, competition) from Guo et al. and Shinn et al. is taken as the complete set for modeling human-agentic workflows.
Section II.B defines these as the core ones and Section IV builds the metamodel exclusively on them; no independent validation that real workflows fit this taxonomy.
domain assumption A lightweight BPMN extension by addition (UML profile via BPMN+X by Stroppi et al.) can carry the intended semantics of the new agentic constructs while keeping the original BPMN behavior unchanged.
Section V adopts BPMN+X and relies on the claim that the extension is semantics-neutral; the paper offers no proof that existing BPMN engines would interpret the extended elements as intended.
domain assumption Uncertainty about agent output can be captured by a single participant-level percentage trust score.
Section IV.A fixes the trust score as a 0-100 percentage, although Section II.C notes it could be derived from the LLM; no measurement protocol is given, and Section VIII defers uncertainty propagation.

invented entities (3)

AgenticLane
purpose: BPMN lane extension carrying agent role (manager or worker) and trust score for participant-level profiling.
Implemented in the GitHub editor, but no falsifiable empirical claim exists; effectiveness is not tested.
AgenticTask with ReflectionMode
purpose: Task extension tagging self-, cross-, or human-reflection strategy to agent tasks.
No semantics for how reflection is executed; the notation is a marker plus a letter with no executable definition.
Agentic gateway and message flow collaboration markers
purpose: Gateways (OR and AND) and message flows annotated with cooperation mode and merging strategy.
Merging strategies are ink tokens (such as v-ma or r-l) without executable definitions; authors defer a governance sublanguage to future work.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Towards Modeling Human-Agentic Collaborative Workflows: A BPMN Extension." pith.science (2026). https://pith.science/paper/LXQ25VGR

@misc{pith2026241205958,
  author       = {Pith},
  title        = {Pith review of: Towards Modeling Human-Agentic Collaborative Workflows: A BPMN Extension},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/LXQ25VGR}},
  note         = {Machine review of arXiv:2412.05958}
}

read the original abstract

Large Language Models (LLMs) have facilitated the definition of autonomous intelligent agents. Such agents have already demonstrated their potential in solving complex tasks in different domains. And they can further increase their performance when collaborating with other agents in a multi-agent system. However, the orchestration and coordination of these agents is still challenging, especially when they need to interact with humans as part of human-agentic collaborative workflows. These kinds of workflows need to be precisely specified so that it is clear whose responsible for each task, what strategies agents can follow to complete individual tasks or how decisions will be taken when different alternatives are proposed, among others. Current business process modeling languages fall short when it comes to specifying these new mixed collaborative scenarios. In this exploratory paper, we extend a well-known process modeling language (i.e., BPMN) to enable the definition of this new type of workflow. Our extension covers both the formalization of the new metamodeling concepts required and the proposal of a BPMN-like graphical notation to facilitate the definition of these workflows. Our extension has been implemented and is available as an open-source human-agentic workflow modeling editor on GitHub.

Figures

Figures reproduced from arXiv: 2412.05958 by the authors.

**Figure 2.** Running example with standard BPMN. transition from conceptual models to implementation easier; and (5) integration with existing processes, many organizations already use BPMN, making it easier to incorporate agent-based elements into existing business processes. Therefore, despite the identified limitations, we believe that BPMN still provides a good starting point compared to alternative modeling languages. While… view at source ↗

**Figure 4.** Domain model of the AgenticTask [PITH_FULL_IMAGE:figures/full_fig_p005_4.png] view at source ↗

Figures from the paper (4 more)

**Figure 5.** Figure 5: Domain model of the AgenticOR, AgenticAND and AgenticMessageFlow. Although standard BPMN can model loops and decision points, it lacks the constructs to formally define and enforce self-reflection, cross-reflection, or human-reflection processes [PITH_FULL_IMAGE:figur…

**Figure 6.** Figure 6: Running example with our extension notation. [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]

**Figure 7.** Figure 7: Extension model. VI. PROOF OF CONCEPT As a proof-of-concept of the proposal, we have implemented a modeling editor that enables any developer to use our extended BPMN language and notation. The extension has been implemented using Sirius 3 , an Eclipse project which al…

**Figure 8.** Figure 8: Platform-independent implementation. palette contains the basic representation of BPMN, plus the extension elements proposed in this paper. Furthermore, the repository also includes several examples from the literature to illustrate the use of the extension [PITH_FULL…

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

Rethinking Query Optimization for Multi-Agent Systems [Vision]
cs.DB 2025-12 conditional novelty 6.0 of 10

Agentic data pipelines are built by hand today; this paper sets a research agenda for automatically optimizing their structure, model choices, and execution engines jointly as a new query-optimization problem.

Reference graph

Works this paper leans on

17 extracted references · 15 canonical work pages · cited by 1 Pith paper

[1]

Brambilla, M., Cabot, J., Izquierdo, J.L.C., Mauri, A.: Better call the crowd: using crowdsourcing to shape the notation of domain-specific languages. In: Int. Conf. on Software Language Engineering. pp. 129– 138 (2017)

work page 2017
[2]

Ceballos, H.G., Flores-Solorio, V ., García-Vázquez, J.: A probabilistic BPMN normal form to model and advise human activities. In: Int. Workshop on Engineering Multi-Agent Systems. vol. 9318, pp. 51–69 (2015)

work page 2015
[3]

Springer (2013)

Dumas, M., Rosa, M.L., Mendling, J., Reijers, H.A.: Fundamentals of Business Process Management. Springer (2013)

2013
[4]

Agents, Web-Services, and Ontologies Integrated Methodologies pp

Endert, H., Küster, T., Hirsch, B., Albayrak, S.: Mapping BPMN to agents: An analysis. Agents, Web-Services, and Ontologies Integrated Methodologies pp. 43–58 (2007)

work page 2007
[5]

Cambridge University Press (1999)

Engeström, Y ., Miettinen, R., Punamäki-Gitai, R.L.: Perspectives on activity theory. Cambridge University Press (1999)

work page 1999
[6]

Guo, T., Chen, X., Wang, Y ., Chang, R., Pei, S., Chawla, N.V ., Wiest, O., Zhang, X.: Large language model based multi-agents: A survey of progress and challenges. In: Int. Joint Conf. on Artificial Intelligence. pp. 8048–8057 (2024)

work page 2024
[7]

Herbert, L., Sharp, R.: Precise quantitative analysis of probabilistic business process model and notation workflows. J. Comput. Inf. Sci. Eng. 13(1) (2013)

work page 2013
[8]

Multiagent Grid Syst

Küster, T., Lützenberger, M., Heßler, A., Hirsch, B.: Integrating process modelling into multi-agent system engineering. Multiagent Grid Syst. 8(1), 105–124 (2012)

work page 2012

Show all 17 references

[9]

Liu, Y ., Lo, S.K., Lu, Q., Zhu, L., Zhao, D., Xu, X., Harrer, S., Whittle, J.: Agent design pattern catalogue: A collection of architectural patterns for foundation model based agents. J. Syst. Softw. 220, 112278 (2025)

2025
[10]

IEEE Transactions on software engineering 35(6), 756–779 (2009)

Moody, D.: The "physics" of notations: Toward a scientific basis for constructing visual notations in software engineering. IEEE Transactions on software engineering 35(6), 756–779 (2009)

2009
[11]

OMG: Business process model and notation (bpmn) 2.0.2 specification (Jan 2014), https://www.omg.org/spec/BPMN, accessed on July, 2024

2014
[12]

Richardson, N., Kolovos, D., Garcia-Dominguez, A.: Aconite: Towards generating sirius-based graphical editors from annotated metamodels. In: Int. Conf. on Software Language Engineering. p. 16–28 (2024)

2024
[13]

In: Conf

Shinn, N., Cassano, F., Gopinath, A., Narasimhan, K., Yao, S.: Reflex- ion: language agents with verbal reinforcement learning. In: Conf. on Neural Information Processing Systems (2023)

2023
[14]

Stroppi, L.J.R., Chiotti, O., Villarreal, P.D.: Extending BPMN 2.0: Method and tool support. In: Int. Workshop of Business Process Model and Notation. vol. 95, pp. 59–73 (2011)

2011
[15]

Wei, J., Tay, Y ., Bommasani, R., Raffel, C., Zoph, B., Borgeaud, S., Yogatama, D., Bosma, M., Zhou, D., Metzler, D., Chi, E.H., Hashimoto, T., Vinyals, O., Liang, P., Dean, J., Fedus, W.: Emergent abilities of large language models. Trans. Mach. Learn. Res. 2022 (2022)

2022
[16]

CoRR abs/2308.08155 (2023)

Wu, Q., Bansal, G., Zhang, J., Wu, Y ., Zhang, S., Zhu, E., Li, B., Jiang, L., Zhang, X., Wang, C.: Autogen: Enabling next-gen LLM applications via multi-agent conversation framework. CoRR abs/2308.08155 (2023)

2023 arXiv
[17]

Xi, Z., Chen, W., Guo, X., He, W., Ding, Y ., Hong, B., Zhang, M., Wang, J., Jin, S., Zhou, E., et al.: The rise and potential of large language model based agents: A survey. Sci. China Inf. Sci. 68(2), 121101 (2025)

2025

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.

[1] [1]

Brambilla, M., Cabot, J., Izquierdo, J.L.C., Mauri, A.: Better call the crowd: using crowdsourcing to shape the notation of domain-specific languages. In: Int. Conf. on Software Language Engineering. pp. 129– 138 (2017)

work page 2017

[2] [2]

Ceballos, H.G., Flores-Solorio, V ., García-Vázquez, J.: A probabilistic BPMN normal form to model and advise human activities. In: Int. Workshop on Engineering Multi-Agent Systems. vol. 9318, pp. 51–69 (2015)

work page 2015

[3] [3]

Springer (2013)

Dumas, M., Rosa, M.L., Mendling, J., Reijers, H.A.: Fundamentals of Business Process Management. Springer (2013)

2013

[4] [4]

Agents, Web-Services, and Ontologies Integrated Methodologies pp

Endert, H., Küster, T., Hirsch, B., Albayrak, S.: Mapping BPMN to agents: An analysis. Agents, Web-Services, and Ontologies Integrated Methodologies pp. 43–58 (2007)

work page 2007

[5] [5]

Cambridge University Press (1999)

Engeström, Y ., Miettinen, R., Punamäki-Gitai, R.L.: Perspectives on activity theory. Cambridge University Press (1999)

work page 1999

[6] [6]

Guo, T., Chen, X., Wang, Y ., Chang, R., Pei, S., Chawla, N.V ., Wiest, O., Zhang, X.: Large language model based multi-agents: A survey of progress and challenges. In: Int. Joint Conf. on Artificial Intelligence. pp. 8048–8057 (2024)

work page 2024

[7] [7]

Herbert, L., Sharp, R.: Precise quantitative analysis of probabilistic business process model and notation workflows. J. Comput. Inf. Sci. Eng. 13(1) (2013)

work page 2013

[8] [8]

Multiagent Grid Syst

Küster, T., Lützenberger, M., Heßler, A., Hirsch, B.: Integrating process modelling into multi-agent system engineering. Multiagent Grid Syst. 8(1), 105–124 (2012)

work page 2012