An Integrated Task Decomposition Framework Considering Knowledge Reuse and Resource Availability for Complex Task Crowdsourcing

Abstract

Complex task crowdsourcing (CTC) integrates distributed talent, knowledge, and ideas into innovation via the web; however, task decomposition remains a critical challenge. While existing studies focus primarily on workflow management for specific tasks, they leave a gap in decomposing more complex, creative tasks, which are characterized by the absence of objective ground truths, nonlinear dependencies, and non-sequential processes. To address this gap, we propose a novel integrated task decomposition framework for CTC that comprises three interconnected components. First, primary decomposition considers knowledge reuse by identifying similar past task decomposition schemes to inform the initial breakdown. Second, modifications to the scheme are guided by work breakdown structure (WBS)-based principles, which also serve as a foundation when no prior knowledge is available. Third, to enhance executability, a task package model is proposed to combine subtasks that share common resources, thereby reducing coordination costs and avoiding waste of workers’ capabilities. To solve this model, we develop an improved non-dominated sorting genetic algorithm (NSGA-II) to generate the final decomposition scheme. A case study from ZBJ.COM validates the feasibility and effectiveness of the proposed framework. Experimental results demonstrate that, compared to baseline algorithms, the improved NSGA-II better balances conflicting objectives and generates non-dominated solution sets with higher diversity and more uniform distribution.

1. Introduction

Microtask markets, such as Amazon’s Mechanical Turk (AMT), represent a brand-new mode of work completion [1]. In this mode, employers can utilize a large number of workers from all over the world to complete tasks, and the time and cost required are only a fraction of those of traditional methods [2,3]. Such markets usually only support simple and independent tasks, called microtasks, such as tagging images or determining the relevance of search results [4,5]. However, tasks in life are very complex and take a lot of time. They require technicians from different fields to work collaboratively [6,7,8]. Complex tasks are much more complicated than microtasks and often involve knowledge and skills from different fields, making them difficult for a single worker to accomplish alone [9,10,11,12]. How to handle complex tasks in complex task crowdsourcing (CTC) has become a critical emerging issue.

There are two main approaches to support task completion in CTC: the team formation-based approach and the divide-and-conquer approach. As the divide-and-conquer approach can reduce task complexity and enhance the efficiency and quality of subsequent task–worker matching, it has become one of the most effective approaches for crowdsourcing complex tasks. In this approach, a complex task is first broken down into smaller and more distinct subtasks, which are then assigned to different workers to work in parallel [3,5]. A key issue that must be addressed in the approach is how to reasonably and effectively break a complex task into a series of subtasks [13].

Many researchers have studied this problem and proposed effective methods, such as BudgetFix [14], CrowdForge [15], and Turkomatic [16]. However, these studies mainly focus on providing a conceptual workflow framework, that is, the process of accomplishing complex tasks, rather than an exact algorithm for decomposing complex tasks in crowdsourcing [4,5]. In their approaches, the decomposition work is crowdsourced to crowd workers, and the best one is usually selected by voting. Furthermore, these workflows suffer from the problem of generalizability [3]; they are tailored to very specific problems, such as audio transcription, text correction, and article editing tasks, which have objective ground truths, linear dependencies, and are completed sequentially.

The rapid development of crowdsourcing platforms has contributed to the ever-increasing volume and complexity of crowdsourcing tasks [17,18,19]. Many complex tasks in crowdsourcing now lack objective ground truths, exhibit nonlinear dependencies, and are not bound by strict sequential processes [17]. For example, brand design involves multiple subtasks, such as logo design, color schemes, typography, and brand storytelling. These subtasks must align with each other (e.g., the logo style must match the color tone) rather than existing in isolation, and may have cross-dependencies (e.g., typography choices can influence logo details, and vice versa) rather than follow a strict sequential order. It hinges on workers’ creativity, with outcomes shaped by subjective preferences and quality evaluated through subjective indicators, such as aesthetic preferences and alignment with brand positioning, with no single “correct answer”. However, there is a dearth of research on how to decompose such complex tasks in the context of crowdsourcing. The lack of an appropriate method for decomposing complex tasks into subtasks that can be effectively crowdsourced in CTC must be urgently filled.

Our solution to decomposing complex tasks in CTC is primarily inspired by the following observations derived from practical experiences in addressing complex tasks.

(1)

Experience plays an important role in decomposing complex tasks. When dealing with complex tasks, people usually rely on their past experiences or seek help from senior professionals. It is common practice for experienced project managers to be responsible for task decomposition. For instance, in CTC, task analysis and decomposition are jointly undertaken by project managers and TopCoder copilot on the TopCoder platform (https://www.topcoder.com/ (accessed on 1 July 2025)) [20,21]. However, relying entirely on manual work to decompose complex tasks is time consuming, labor intensive, and inefficient. If historical decomposition templates can be applied to guide the decomposition of new tasks, they will help improve the efficiency and quality of task decomposition while reducing the workload of project managers.

(2)

When performing task decomposition, professionals usually follow specific decomposition principles or criteria to enhance the logic, pertinence, and professionalism of the process [20,22]. For example, when using professional tools such as work breakdown structure (WBS), it is necessary to preset decomposition principles, and this method has also been adopted in relevant studies [22,23].

(3)

When decomposing a complex task, it is necessary to consider whether the decomposed subtasks can be completed with existing resources; if not, the decomposition scheme must be adjusted. In other words, task decomposition must take resource availability into account to ensure the executability of subtasks [22]. In the context of CTC, workers are the main workforce responsible for completing tasks. Due to the dynamic preferences and capacity growth of workers, workers who previously could only perform a single task with a simple skill requirement may now perform multiple tasks with different skill requirements simultaneously. Therefore, task decomposition in CTC must incorporate the resource dynamics as a consideration factor.

Specifically, this study seeks to address the following research questions:

RQ1: How can historical decomposition schemes be effectively reused to inform the decomposition of new tasks?

RQ2: How can subtasks be dynamically aligned with workers’ evolving capabilities during the task decomposition process?

To achieve this, this paper presents a novel integrated task decomposition framework for CTC considering knowledge reuse and resource availability. The proposed framework consists of three components: primary task decomposition considering knowledge reuse, task decomposition modification based on work breakdown structure (WBS), and subtask reorganization considering resource availability. These three components are interrelated and executed sequentially from top to bottom. For knowledge reuse, we seek guidance from the most similar decomposition templates, which are identified by a deep semantic-based similarity measure method, to aid the decomposition process and formulate a primary decomposition scheme. Moreover, to better meet the customized and individualized requirements of employers, the primary decomposition scheme requires further artificial modifications by experts. To this end, we propose several decomposition principles based on WBS, which consider the hierarchical, independent and executable nature of the subtasks, to guide and standardize the work of experts. If no suitable decomposition templates are available, experts can break down a new complex task according to the proposed decomposition principles. However, the above two task decomposition components do not consider the availability of current resources, which may result in the unexecutability of subtasks or too fine-grained subtasks. Therefore, the subtask reorganization component is developed. If two subtasks can be performed by several common workers, the two subtasks can be further combined to form a more executable and interrelated task package. To achieve this, a task package model is formulated and an improved non-dominated sorting genetic algorithm (NSGA-II) is developed to solve the model. Subtask reorganization can not only enhance the executability of tasks and increase task completion efficiency, but also reduce coordination costs, avoid the waste of workers’ capabilities and increase their income.

The main contributions of this study are summarized as follows:

(1)

Propose a novel task decomposition framework for CTC that integrates knowledge reuse, decomposition principles, and resource dynamics, filling the gap in existing research that neglects the integration of these three elements in complex task decomposition.

(2)

Develop a task package model considering workers’ dynamic preferences and capacity growth, which combines subtasks sharing common resources to enhance the quality of task decomposition, providing a new solution for improving subtask executability.

(3)

Design an improved NSGA-II algorithm to solve the task package model, with a local search operator strengthening exploration capability and TOPSIS introduced to select the optimal solution from the Pareto optimal set, improving the efficiency and accuracy of solving complex task decomposition problems.

In the following sections, Section 2 summarizes the related literature. In Section 3, an overview of the proposed task decomposition framework for CTC is presented, and the details of each component of the framework are elaborated in Section 4. A case study is then conducted in Section 5. Finally, the conclusions of this work are drawn in Section 6.

2. Literature Review

Although there are a few decomposition methods in crowdsourcing, they are not suitable for complex task decomposition in CTC. Research methods in related fields, such as cloud manufacturing and mechanical product design, can give us some inspiration. In this section, we first summarize the methods for crowdsourcing complex tasks, then review the related works on complex task decomposition in crowdsourcing, and finally introduce some complex task decomposition methods in the related fields.

2.1. Complex Task Crowdsourcing

Generally, complex tasks involve knowledge and skills from different fields, requiring workers with different skills and abilities to collaborate. Researchers have proposed different methods for crowdsourcing complex tasks, which can be grouped into two types: the team formation-based approach and the divide-and-conquer approach, as shown in Table 1.

In the team formation-based approach, a complex task will be assigned as a whole to a team of workers with complementary knowledge, skills and abilities. Some researchers also refer to this approach as retail-style task assignment [24,25] or monolithic allocation [26]. Since complex tasks are difficult to accomplish by a single worker with simple skills alone, forming a team of workers to tackle such complex tasks is a natural approach, which is a common practice in our daily lives. Tuarob et al. [27] proposed an intelligent recommendation system for collaborative software development. The system can provide suggestions for team configuration based on the given task description and task assignee. These suggestions not only meet the role requirements but also include the necessary technical skills and team-collaboration compatibility. Vinella et al. [28] investigated different ways in which crowd teams can be formed through three team formation models, namely bottom-up, top-down, and hybrid, and highlighted the importance of integrating worker agency in algorithm-mediated team formation systems. Cunha et al. [29] developed a data-based tool that utilizes genetic algorithms to optimize the software team formation. By integrating with the project management system, data analysis is used to generate detailed team information and propose the best team configuration plans, thereby facilitating adjustment by management. With the advent of online social networks, some researchers have explored the team formation problem for CTC in social networks [30,31].

Table 1. Taxonomy of complex task crowdsourcing methods.

Method	Method Description	Applications	Related Works
Team formation-based approach	Assigning a complex task entirely to a team of workers with complementary knowledge, skills and abilities	Usually used on some complex task-oriented websites such as Upwork and CrowdWorks. The formation of worker teams is usually under the control of the requester centrally. They may interview candidate workers and watch if the workers can perform the tasks.	J. Jiang et al. [25], J. Jiang et al. [26], Assavakamhaenghan et al. [32]
Divide-and-conquer approach	A complex task is first broken down into smaller and distinct subtasks and then the subtasks are assigned to different workers to work in parallel	Mainly used in two situations: micro-task-oriented crowdsourcing systems, such as Amazon’s Mechanical Turk, and situations where the workers are non-professional and can only complete simple or micro-tasks.	Zheng et al. [4], Gao et al. [5], Tran-Thanh et al. [14], Kittur et al. [15], Kulkarni et al. [16]

Table 1. Taxonomy of complex task crowdsourcing methods.

Method	Method Description	Applications	Related Works
Team formation-based approach	Assigning a complex task entirely to a team of workers with complementary knowledge, skills and abilities	Usually used on some complex task-oriented websites such as Upwork and CrowdWorks. The formation of worker teams is usually under the control of the requester centrally. They may interview candidate workers and watch if the workers can perform the tasks.	J. Jiang et al. [25], J. Jiang et al. [26], Assavakamhaenghan et al. [32]
Divide-and-conquer approach	A complex task is first broken down into smaller and distinct subtasks and then the subtasks are assigned to different workers to work in parallel	Mainly used in two situations: micro-task-oriented crowdsourcing systems, such as Amazon’s Mechanical Turk, and situations where the workers are non-professional and can only complete simple or micro-tasks.	Zheng et al. [4], Gao et al. [5], Tran-Thanh et al. [14], Kittur et al. [15], Kulkarni et al. [16]

In the divide-and-conquer approach, a complex task is first broken down into smaller and distinct microtasks, which are then assigned to different workers to work in parallel. Generally, microtasks have low complexity and require minimal specialized skills, enabling them to be carried out individually by a single worker [9,25,33]. Therefore, the divide-and-conquer approach is well suited for crowdsourcing systems targeting the microtask market, such as Amazon’s Mechanical Turk, as well as in scenarios where workers are non-specialists capable of completing only simple or microtasks [26]. Breaking a complex task into a series of simple subtasks offers advantages for task requesters, workers and the CTC platform. First, it is easier for a task requester to find competent workers for decomposed low-complexity subtasks than for the entire complex task [20], which increases the efficiency of task completion and reduces the cost of task completion. Second, it offers more opportunities for workers with only simple skills to participate in CTC and gain revenue because low-complexity subtasks require fewer skills. Finally, it can improve the efficiency and quality of supply and demand matchmaking [22], thus making the CTC platform more favored by more task requesters and workers and improving the platform’s market competitiveness. Given these advantages, the divide-and-conquer approach is an effective way to handle task completion in CTC.

Regardless of the approach employed, the completion of complex tasks in crowdsourcing relies on worker participation and coordination, which constrains the applicability of CTC. The emergence of artificial intelligence (AI) in recent years has driven a paradigm shift in crowdsourcing research, with scholars exploring AI’s application potential to overcome existing limitations of crowdsourcing models—ultimately enhancing its capacity to support more complex, ill-defined tasks, such as wicked problems. For instance, Zhu et al. [18] examined how the integration of generative AI impacts user trust when handling complex or creative tasks versus microtasks. Gimpel et al. [17] analyzed AI’s potential roles in facilitating macro-task crowdsourcing through the lens of affordance theory. Gimpel et al. [19] leveraged large language models (LLMs) to aggregate contributions from selected participants in a location- and time-independent setting, demonstrating NLP-driven progress in content synthesis. How AI can enable CTC to tackle increasingly complex and challenging tasks remains a critical research gap—a topic worthy of deeper exploration and a key future direction for the field.

In this paper, we concentrate on the divide-and-conquer approach for crowdsourcing complex tasks. We summarize related research on complex task decomposition in crowdsourcing in Section 2.2.

2.2. Complex Task Decomposition in Crowdsourcing

Task decomposition in CTC is complex and systematic. The research focus of existing studies mainly on the workflow design problem, i.e., designing a better process of completing complex tasks depending on task features [16].

To assist in the completion of complex and interdependent tasks that require coordination using microtask markets such as Amazon’s Mechanical Turk, Kittur et al. [15] conceptualized the CrowdForge framework, which decomposes complex problems into partition, map, and reduce subtasks. However, it does not support iteration or recursion, and the task partitioning process is controlled by crowdsourcing workers [4]. To allocate interdependent microtasks in crowdsourcing under budget constraints, Tran-Thanh et al. [14] used the find–fix–verify workflow to determine the number of interdependent microtasks and the price to pay for each task while ensuring quality guarantees. However, its fixed three-phase workflow lacks flexibility and is more suited to tasks with objective ground truth and is unable to deal with subjective or creative tasks whose quality cannot be quantified, such as brand design tasks and software engineering tasks.

To make crowd workers and requesters work collaboratively on workflow design for complex tasks, Kulkarni et al. [16] provided an efficient workflow management system, Turkomatic, which employs a continuous price–divide–solve loop, enabling workers to recursively divide complex tasks into simpler ones until they are solvable. However, unguided worker planning often leads to unnecessary subtasks and relies heavily on requester intervention to ensure quality. Zheng et al. [4] proposed a crowdsourcing process model based on the state machine technology to manage the life cycle of crowdsourcing tasks and automate the process of decomposition, resolving, and merging of complex tasks. However, its rigid state machine transitions are less adaptable to highly creative or ambiguous tasks with unpredictable workflows.

The existing studies mentioned above provide useful insights into how to decompose complex tasks in CTC. However, they mainly focus on providing a conceptual workflow framework rather than an exact algorithm for decomposing complex tasks in crowdsourcing. In these approaches, it is the workers who give different decomposition options and the best option is selected by voting. Furthermore, the proposed workflows are usually tailored to a very specific problem and cannot be generalized easily to handle other problem instances [3], which lack objective ground truths, have nonlinear dependencies, and are not subject to a strict sequential process. The rapid development of crowdsourcing platforms has contributed to the increasing volume and complexity of crowdsourcing tasks. The gap of an appropriate method for decomposing complex tasks into subtasks that can be effectively crowdsourced in CTC must be urgently filled.

2.3. Complex Task Decomposition in Related Fields

Complex task decomposition is also a key technical problem in other research fields, such as cloud manufacturing [34] and mechanical product design [35]. Related studies in these research fields have addressed the task decomposition problem from different perspectives, providing significant references for the task decomposition in CTC studied in this paper.

To model the structure of mechanical products, Hegge and Wortmann [36] first proposed a generic bill-of-material to clearly describe the hierarchical structure between product parts and effectively avoid data redundancy when describing the structure of different product types in a product family.

To accurately express the strength of the association between product components, the design structure matrix [37] is widely employed to provide a simple, compact and visual representation of products, thus supporting module partitioning for complex mechanical product modular design. The essence of the method is the analysis of the relationships between objects through matrix transformation [38]. To describe the structures of complex mechanical products, many studies have explored structure modeling based on complex network theory [5,35,39,40,41,42,43]. However, as mechanical products have physical structures, decomposing a whole product into multiple assemblies and parts can be much easier than tasks in cloud manufacturing and CTC tasks.

In cloud manufacturing, task decomposition is a critical procedure as well as a prerequisite for task scheduling. It is not an isolated process, but one that must be considered in conjunction with the state of the service supplies [34]. The extent to which tasks are decomposed depends on the granularity of the service supplies and does not necessarily need to be decomposed into atomic tasks. However, due to its significant challenges, only a few studies have focused on the task decomposition problem in cloud manufacturing [34]. To optimize task decomposition and facilitate task scheduling, Fang et al. [44] first decomposed an entire task into executable atomic subtasks based on task/service matching and then merged small-grained subtasks into appropriate-grained subtasks by considering the internal competition of candidate service sets, cooperation, and dependencies between candidate service sets. To facilitate customer collaboration in product development, X. Zhang et al. [45] decomposed product development tasks into several subtasks, which were then divided into different groups to reduce the degree and frequency of interactions between development teams.

The task completion processes of cloud manufacturing and CTC share significant similarities, and subtask reorganization in cloud manufacturing, which accounts for service resource conditions, offers valuable insights for addressing the task decomposition problem in CTC. However, the uniqueness of CTC precludes the direct application of methods used in cloud manufacturing. Unlike tasks in cloud manufacturing, where requirements are explicitly defined and service quality standards are clearly specified, complex tasks in CTC are characterized by abstraction and vague requirement descriptions. Additionally, service resources in CTC primarily consist of crowd workers, whose capabilities are continuously evolving, and service states are highly dynamic. Accordingly, incorporating resource dynamics into the task decomposition process in CTC constitutes a critical research gap that must be addressed.

3. Overview of the Integrated Task Decomposition Framework

In this section, we provide an overview of the proposed integrated task decomposition framework, as shown in Figure 1. Considering the complex requirements of task characteristics and resource dynamics in CTC, the framework consists of three key parts: primary task decomposition, task decomposition modification and task reorganization. When an employer submits a requirement on a CTC platform, a project manager is assigned to communicate with the employer in detail and analyze the employer’s specific requirements to formulate a new complex task. Subsequently, the project manager initiates the integrated task decomposition framework to achieve the optimal task decomposition scheme for the task. The three components of the framework are interrelated and executed sequentially from top to bottom.

(1)

Primary task decomposition considering knowledge reuse. The openness of the Internet and online platforms has contributed to the growing volume of complex tasks in CTC, and it is impossible to break down each new task from scratch. To enhance the efficiency of complex task completion, past decomposition experience can be a useful knowledge for decomposing new tasks. In this component, the decomposition scheme of the most similar task, which is stored in the database of decomposition templates, is obtained as the primary task decomposition scheme for the new task. The details of this component will be presented in Section 4.1.

(2)

Task decomposition modification based on WBS. As tasks in CTC can be very customized, the primary task decomposition scheme may not completely match employers’ requirements, necessitating further checks and modifications by the project manager. To better guide and standardize the project manager’s work, we propose several principles of task decomposition based on WBS, which will be introduced in Section 4.2.

(3)

Subtask reorganization considering resource availability. The above two task decomposition components do not consider the availability of current service resources, which may result in the unexecutability of subtasks or too fine-grained subtasks. Therefore, the CTC platform further recombines two or more subtasks into a task package, considering resource availability to generate an optimal task decomposition scheme. To achieve this, a task package model is formulated, and an improved NSGA-II algorithm is proposed to solve the model in this component, which will be detailed in Section 4.3.

Once the task decomposition scheme is completed, the generated decomposition schemes are added to the database of decomposition templates for future knowledge reuse.

4. The Integrated Task Decomposition Framework

In this section, we detail the three components of the integrated task decomposition framework: primary task decomposition, task decomposition modification, and subtask reorganization. The notations used in this paper are presented in

Table 2. Notions used in this paper.

Notions	Meanings
Notations used for characterizing the modified task decomposition scheme
$H_{WBS}$	Representing a complex task described by a WBS-based task decomposition scheme, where $H_{WBS}=\left(E_L,E_{ID},E_N,E_R,E_D,E_C,E_{RQ},E_S\right)$
$e_{ij}$	A task node in $H_{WBS}$, where i denotes that the location of the task node is the ith layer, and j denotes that the location of the task node is the jth place of this layer
EL	Location set of each layer task node $e_{ij}$ in $H_{WBS}$
$E_{ID}$	The ID number of the task nodes in $H_{WBS}$
$E_N$	The names of the task nodes in $H_{WBS}$
$E_R$	The relationship between task nodes in $H_{WBS}$, where $E_R=\left(E_{i,j-1},E_{i,j+1},E_{i-1,j},E_{i+1,j}\right)$ indicates the preceding, succeeding, upper, and lower task nodes
$E_D$	The estimated duration of task nodes in $H_{WBS}$
$E_C$	The estimated cost of task nodes in $H_{WBS}$
$E_{RQ}$	The task definition of task nodes in $H_{WBS}$
$E_S$	The skill requirements of task nodes in $H_{WBS}$
Notations used for the task package model
N	The number of subtasks
T	The set of subtasks
P	The set of task packages
$J_{ij}$	The task content relevancy between subtask i and subtask j
$K_{iu}$	The task content relevancy between subtask i and task package u
$L_{uv}$	The task content relevancy between task package u and task package v
$W_i^s$	The candidate worker set for subtask i
$W_u^t$	The candidate worker set for the task package u
k	The threshold for the number of the same workers when combining subtasks
$o_i$	The information of the preceding subtasks or task packages for subtask i
$s_i$	The skill requirements of subtask i
$e_u$	The information of the preceding subtasks or task packages for task package u
$q_u$	The skill requirements of the task package u
$x_{ij}$	If subtask i is combined with subtask j, it is equal to 1; otherwise, it is equal to 0
$y_{iu}$	If subtask i is combined with task package u, it is equal to 1; otherwise, it is equal to 0
$z_{uv}$	If task package u is combined with task package v, it is equal to 1; otherwise, it is equal to 0
Notations used for characterizing an optimal task decomposition scheme
$H_{BOS}$	Representing the bill of service of task packages, where $H_{BOS}=\left(T_{ID},T_R,T_D,T_{WL},T_C,T_{RQ}\right)$
$T_{ID}$	The ID number of task packages
$T_R$	The relationship of the task packages, where $R=\left(t_{i,j-1},t_{i,j+1}\right)$ indicates the preceding and succeeding task packages
$T_D$	The estimated duration of task packages
$T_{WL}$	The rated workload of task packages
$T_C$	The estimated cost of task packages

.

4.1. Primary Task Decomposition Considering Knowledge Reuse

Past successful decomposition cases provide useful references for decomposing new tasks; thus, the critical task in this component is to identify the most similar templates stored in the database. As task descriptions in CTC are represented by unstructured texts and employers’ personalized requirements are hidden in the text, it is challenging to identify similar tasks for reference. In recent years, deep learning-based natural language processing (NLP) techniques have received significant attention for processing unstructured textual information from different industries. Several representative pre-trained language models have been proposed, such as embeddings from language models (ELMO) [46], generative pre-trained transformer (GPT) [47], and bidirectional encoder representation from transformers (BERT) [48], which utilize large amounts of unlabeled data to learn common language representations and generate word vectors through context. Neural network architectures, such as recurrent neural networks (RNNs), convolutional neural networks (CNNs) [49], and long short-term memory (LSTM) [50] have also demonstrated excellent performance in solving different NLP tasks, such as language modeling, machine translation, and text classification.

In this paper, we employ a deep learning model that combines BERT and CNN, as shown in Figure 2, which has been widely used in research for language modeling [51,52]. Compared with other text embedding models, the attention mechanism of BERT can learn the context information and capture the global features of sentences or documents by identifying correlated words in text, which can not only effectively solve the problem of polysemy but also strengthen the semantic representation of sentences [53]. However, BERT leads to inconsistencies in the text representation during pre-training and fine-tuning on downstream tasks during sentence recognition [51]. To address the problem, CNN is further employed to extract local salient features, such as keywords in text, based on the output of BERT. CNN is widely used in text sentiment classification, commodity review sentiment analysis, and other fields with the ability to extract characteristic information from data [54]. Therefore, by combining BERT and CNN, both contextual and local representations of tasks can be obtained. It is noted that other text processing methods can be employed as desired, depending on the specific research or business objectives.

Based on the respective global and local task representations obtained by BERT and CNN, the semantic similarity between tasks can be obtained by cosine similarity [55], as shown in Equation (1). A larger value of $d_{cos}$ indicates that the similarity between tasks is higher.

$$d_{cos}={\displaystyle \frac{\sum _{i=1}^n{x}_i{y}_i}{\sqrt{\sum _{i=1}^n{x}_i^2}\times \sqrt{\sum _{i=1}^n{y}_i^2}}}$$

(1)

In practice, the project manager could rank the decomposition templates based on the task similarities $d_{cos}$, and select the most similar or suitable templates as a reference.

In practice, the project manager can sort the decomposition templates based on the task similarity $d_{cos}$, view their decomposition schemes, and select the most similar or appropriate template as the primary decomposition scheme for the new task.

4.2. Task Decomposition Modification Based on WBS

The primary task decomposition scheme obtained in the primary task decomposition component is only a rough draft, which has to be further modified by the project manager to meet the employer’s specific and customized requirements. Therefore, we propose the task decomposition modification component to better guide and standardize the project manager’s artificial work. WBS is a method with goal orientation and considers the integrity of problems when dealing with problems with project characteristics. Meanwhile, WBS can effectively define the output and work content of the project, which can not only be applied to tangible projects but also define service projects [56]. In this component, we propose several decomposition principles and then introduce the modified task decomposition scheme based on WBS. It is noted that WBS can also be used when a new task has to be broken down from scratch.

4.2.1. Decomposition Principles of Complex Tasks in CTC

Decomposing complex tasks into subtasks that meet the needs of employers and the operation rules of platforms is the basis for the subsequent task scheduling [9]. Therefore, it is necessary to consider both employers’ needs and platform operation rules when decomposing complex tasks. We propose the following decomposition principles for breaking down complex tasks in CTC based on the WBS method.

• Priority for special requirements of employers

Due to the non-standardized characteristic of CTC tasks, the tasks submitted by employers usually have special requirements, which have to be first considered when decomposing complex tasks. When an employer sets rigid requirements for a specific aspect of a task, then that specific part of the task will not be broken down [9,57]. Moreover, when an employer proposes highly individualized and special requirements that have rarely appeared in past work tasks, then these special requirements will not be broken down and handled separately.

2.

Standardized decomposition considering service categories

As tasks are varied in industries, requirements and knowledge fields, it is a general way for CTC platforms to classify different tasks into different service categories to facilitate better task management. Therefore, service categories are vital references for complex task decomposition. Since each worker also falls into a specific service category, it is also easier to identify suitable workers for each subtask derived from the complex task according to the service categories.

3.

Top-down hierarchical decomposition

The complex tasks in CTC are decomposed layer by layer according to the top-down order [45]; that is, the tasks of the upper layer are supported by the tasks of the lower layer. As tasks in CTC are usually non-standardized and are described in the form of natural language text, the description of the upper layer is more vague and concise than that of the lower layer; that is, the description of the lower layer will be more detailed and precise than that of the upper layer.

4.

Executability of decomposed subtasks

When decomposing complex tasks according to the top-down rule, it is necessary to ensure the executability of subtasks to avoid over-refinement or insufficient task decomposition [45,58]. The best granularity of subtasks is that each subtask can be performed by a single worker [57,58].

4.2.2. Modified Task Decomposition Scheme Characterization

Following the decomposition principles above, a complex task can be decomposed into a number of logically and sequentially interrelated subtasks, formulating a tree-based task decomposition scheme. The relationships between subtasks and their details can be characterized based on WBS [59].

We use the following notations to describe the modified task decomposition scheme. Define a set $H_{WBS}=\left(E_L,E_{ID},E_N,E_R,E_D,E_C,E_{RQ},E_S\right)$ representing a complex task. $E_L$ represents the location set of each layer task node $e_{ij}$, where i represents that the location of the task node is the ith layer, and j represents that the location of the task node is the jth place of this layer. $E_{ID}$ indicates the ID number of task nodes at all layers. The ID number corresponds to the service category number. If there is no corresponding service category number for task nodes, they will be numbered separately. $E_N$ indicates the name of the task nodes at all layers. $E_R$ represents the relationship between task nodes at all layers. $E_R=\left(E_{i,j-1},E_{i,j+1},E_{i-1,j},E_{i+1,j}\right)$ indicates the preceding, succeeding, upper, and lower task nodes. $E_D$ represents the estimated duration time of task nodes at all layers. $E_C$ shows the estimated cost of task nodes at all layers. $E_{RQ}$ indicates the task definition of task nodes at all layers. $E_S$ represents the skill requirements of task nodes at all layers.

4.3. Subtask Reorganization Considering Resource Availability

Due to the dynamic preferences and increasing capacity of workers, those who previously could only perform single tasks with simple skill requirements may now be able to simultaneously execute multiple tasks with diverse skill requirements. However, the two aforementioned task decomposition components fail to account for the availability of current service resources, potentially leading to the unexecutability of subtasks or excessively fine-grained subtasks. To address this issue, we further propose the subtask reorganization component to reorganize different subtasks into more feasible, larger task packages. Considering resource availability, if two or more subtasks can be executed by multiple overlapping workers, these subtasks may be further packaged to form a new, larger task package. This approach can also enhance task completion efficiency, reduce coordination costs, and boost workers’ earnings. The schematic diagram of task package generation is shown in Figure 3.

The subtask reorganization component consists of four subcomponents. To reorganize subtasks in the modified task decomposition scheme, the service resource availability is first checked, and then a task package model is formulated. Subsequently, an improved NSGA-II algorithm is developed to solve this model and generate the optimal task decomposition scheme. Finally, we elaborate on the characterization of the optimal task decomposition scheme.

4.3.1. Resource Availability Check

To verify the executability of each decomposed subtask, the candidate worker set for each subtask is first determined by calculating the similarity between the subtask and workers’ historical tasks using Equation (11). For each subtask, historical tasks are sorted in descending order based on this similarity, and the workers of top-m similar tasks are then selected as candidates.

The principles governing subtask reorganization can be articulated as follows: Two subtasks may be combined if they share a certain number of common workers and the logical sequence of completing the complex task remains coherent after their combination. For example, as shown in Figure 3, Subtask 2 and Subtask 3 have m candidate workers, respectively, wherein workers W₂₂ and W₃₁ are the same, and workers W_2m and W₃₂ are the same. If the number of the same workers reaches the pre-defined threshold k, Subtask 2 and Subtask 3 can be further combined to form a task package. If there are subtasks that have not been combined, they form task packages independently. For example, Subtask 1 is not combined with other subtasks, so it forms a task package alone.

4.3.2. Task Package Model Formulation

To reorganize subtasks in the modified task decomposition scheme, a multi-objective task package model is constructed in this section.

(1)

Problem statement

Suppose the modified task decomposition scheme consists of N subtasks, namely $T=\left\{t_1, t_2, \dots , t_N\right\}$. When there are subtasks sharing a certain number of the same workers, a task package can be generated by combining these subtasks. The combination must obey the rules of the logical relationship between subtasks. To this end, a multi-objective mathematical task package model is constructed, and its objective functions are stated as follows.

• The number of task packages is minimized. The purpose of task packages is to reduce the number of subtasks, thereby reducing the communication cost and the coordination management cost of workers. Therefore, decomposing a complex task into a smaller number of task packages will facilitate the smooth completion of the task.
• The average content relevance of task packages is maximized. To avoid deliberately pursuing a small number of task packages and combining less relevant subtasks, it is necessary to ensure that the task content is highly related within a task package. The content relevancy between subtasks in this paper is obtained through experts’ evaluation.

(2)

Model assumptions

We make the following assumptions according to the requirements of the modeling:

• Some information is known before modeling, namely the number of subtasks, the candidate set of workers for each subtask, the information of the preceding subtasks for each subtask, the skill requirements of each subtask, and the number of the same workers that need to be met when two subtasks are combined.
• There are three ways to form a task package: i.e., two subtasks are combined, one task package is combined with one subtask, or two task packages are combined.

(3)

Mathematical model

The task package model is presented below.

$$min{F}_1=N-\sum _{i\in T}\sum _{j\in T}{x}_{ij}-\sum _{i\in T}\sum _{u\in P}{y}_{iu}-\sum _{u\in P}\sum _{v\in P}{z}_{uv}$$

(2)

$$max{F}_2={\displaystyle \frac{\sum _{i\in T}\sum _{j\in T}{J_{ij}x}_{ij}-\sum _{i\in T}\sum _{u\in P}{K_{iu}y}_{iu}-\sum _{u\in P}\sum _{v\in P}{L}_{uv}{z}_{uv}}{N-\sum _{i\in T}\sum _{j\in T}{x}_{ij}-\sum _{i\in T}\sum _{u\in P}{y}_{iu}-\sum _{u\in P}\sum _{v\in P}{z}_{uv}}}$$

(3)

s.t.

$$card\left(W_i^s{x}_{ij}\cap W_j^s{x}_{ij}\right)\ge k$$

(4)

$$card\left(W_i^s{y}_{iu}\cap W_u^t{y}_{iu}\right)\ge k$$

(5)

$$card\left(W_u^t{z}_{uv}\cap W_v^t{z}_{uc}\right)\ge k$$

(6)

$$J_{ij}={\displaystyle \frac{\left|\left(\left\{o_i\right\}\cup s_i\right)\cap \left(\left\{o_j\right\}\cup s_j\right)\right|}{\left|\left(\left\{o_i\right\}\cup s_i\right)\cup \left(\left\{o_j\right\}\cup s_j\right)\right|}}$$

(7)

$$K_{iu}={\displaystyle \frac{\left|\left(\left\{o_i\right\}\cup s_i\right)\cap \left(\left\{e_u\right\}\cup q_u\right)\right|}{\left|\left(\left\{o_i\right\}\cup s_i\right)\cup \left(\left\{e_u\right\}\cup q_u\right)\right|}}$$

(8)

$$L_{uv}={\displaystyle \frac{\left|\left(\left\{e_u\right\}\cup q_u\right)\cap \left(\left\{e_v\right\}\cup q_v\right)\right|}{\left|\left(\left\{e_u\right\}\cup q_u\right)\cup \left(\left\{e_v\right\}\cup q_v\right)\right|}}$$

(9)

$$x_{ij}\in \left\{0, 1\right\}$$

(10)

$$y_{iu}\in \left\{0, 1\right\}$$

(11)

$$z_{uv}\in \left\{0, 1\right\}$$

(12)

Equation (2) indicates that the number of task packages in the optimal task decomposition scheme is minimized. Equation (3) shows that the average content relevancy of the task package is maximized.

Equation (4) indicates that when subtask i and subtask j are combined to form a task package, there are k identical workers in their worker candidate sets. Equation (5) shows that when subtask i and task package u are combined to form a task package, there are k identical workers in their worker candidate sets. Equation (6) indicates that when task package u and task package v are combined to form a task package, there are k identical workers in their worker candidate sets. Equation (7) shows the content relevancy of the task package combined by subtask i and subtask j. Equation (8) shows the content relevancy of the task package combined with subtask i and task package u. Equation (9) shows the content relevancy of the task package combined by task package u and task package v. Equation (10) to Equation (12) are 0–1 decision variables.

4.3.3. Algorithm Design

We propose an improved NSGA-II algorithm to solve the task package model constructed above. NSGA-II is superior to other meta-heuristic algorithms in solving multi-objective optimization problems due to its fast non-dominated sorting and elitist selection strategy. Although NSGA-II can generate a set of optimal solutions that converge to the Pareto front, it is prone to premature convergence. The introduction of local search operators is the main mechanism to avoid premature convergence, and the hybrid algorithm combining NSGA-II with local search operators has been proven to be an effective algorithm for solving multi-objective optimization problems [60,61].

Therefore, NSGA-II is used as the algorithm framework to achieve global iterative optimization by crossover operations and mutation operations. The iterated local search algorithm (ILR) is introduced to perform the local search, which explores the space of different solutions, and finds a better solution to make up for the randomness of the NSGA-II algorithm and the lack of search in the solution space. During the local search, the Metropolis criterion in the simulated annealing algorithm is introduced to determine whether to accept the inferior solution in a probabilistic way, which breaks the limitation of ILR receiving new solutions and broadens the local search range of solutions. When selecting one optimal solution for this model, TOPSIS is introduced to choose a solution from the Pareto optimal solution set [62,63]. The main steps of the improved NSGA-II proposed in this paper are as follows, and the flow chart is shown in Figure 4.

Step 1 Generate an initial population Chrom with a population size NIND, and use it as the parent population for evolutionary iteration. The integer permutation coding rule is used, that is, if a complex task is decomposed into n subtasks, the chromosome is designed with n positions, and each position in the chromosome corresponds to the numbering of a subtask.

Step 2 Perform crossover and mutation operations on the parent population Chrom to generate the offspring population Chrom_off.

Step 3 Perform the local search operation on the offspring population Chrom_off, that is, use the reverse operator and the swap operator to locally search the solution of the NSGA-II, and the Metropolis criterion is used to determine whether to accept the inferior solutions. A new offspring population Chrom_off’ is obtained.

Step 4 The parent population Chrom and the offspring population Chrom_off’ are combined. Divide the combined population into multiple segments according to the constraints, that is, each segment represents a task package, and calculate their objective function values ObjV.

Step 5 Based on the normalized objective function values ObjV_Nor, perform non-dominated sorting and calculate the crowding distances for them. The elitist selection strategy is used to select the first NIND individuals as the parent population Chrom for the next evolutionary iteration.

Step 6 If the evolutionary algebra of the NSGA-II gen exceeds the maximum evolutionary algebra MAXGEN, go to Step 7; otherwise, go to Step 2.

Step 7 The TOPSIS method is used to choose the optimal solution from the Pareto solution set.

Among the above steps, Steps 1, 2, 4, 5 and 6 are relatively simple and will not be described in detail. The details of Step 3 and Step 7 are described as follows.

• Local search operation

Based on the ILR algorithm, two operators are designed to locally search the solution of the NSGA-II and the Metropolis criterion is used to determine whether to accept inferior solutions.

• Reverse operator
• The reverse operator randomly chooses two positions in a chromosome, and the segment between the two positions is reversed, as shown in Figure 5. The metropolis criterion is used to determine whether to accept the perturbed solution as a new solution. The pseudocode of the reverse operator is shown in Algorithm 1.

Algorithm 1. The pseudocode of the reverse operator.

Input: The solution of NSGA-II S

The evolutionary algebra gen

Parameters P

Output: The improved solution S

$r_1,r_2\leftarrow Random Selection \left(S\right)$ // Randomly choose two positions in a chromosome

$S^{\prime }\leftarrow Reverse (r_1,r_2,S)$ // Reverse the selected chromosome segment

$ObjV\leftarrow Objection (S,P)$ // Calculate the objective function value of the solution S

${ObjV}^{\prime }\leftarrow Objection (S^{\prime },P)$ // Calculate the objective function value of the solution S′

if ${ObjV}^{\prime }$ is better than $ObjV$ then $S\leftarrow S^{\prime }$ // If the objective function value of the solution S′ is better than that of the solution S, the solution S′ is accepted

elseif $\mathrm{e}\mathrm{x}\mathrm{p}(-{\displaystyle \frac{\left|{ObjV}^{\prime }-ObjV\right|}{gen}})\ge rand$ then $S\leftarrow S^{\prime }$ // The Metropolis criterion is used to decide whether to accept the solution S′

endif

Return S

• Swap operator

The swap operator randomly chooses two positions in a chromosome and inserts the subtask of the first position before the subtask of the second position, as shown in Figure 6. The metropolis criterion is used to determine whether to accept the perturbed solution as a new solution. The pseudocode of the swap operator is shown in Algorithm 2.

2.

The optimal solution selection based on TOPSIS

To select an optimal solution from the Pareto optimal solution set obtained by NSGA-II, the TOPSIS method is introduced, and the pseudocode is shown in Algorithm 3.

Algorithm 2. The pseudocode of the swap operator.

Input: The solution of the reverse operator S

The evolutionary algebra gen

Parameters P

Output: The improved solution S

$r_1,r_2\leftarrow Random Selection \left(S\right)$ // Randomly choose two positions in a chromosome

$S^{\prime }\leftarrow Swap (r_1,r_2,S)$ // Perform an swap operation

$ObjV\leftarrow Objection (S,P)$ // Calculate the objective function value of the solution S

${ObjV}^{\prime }\leftarrow Objection (S^{\prime },P)$ // Calculate the objective function value of the solution S′

if ${ObjV}^{\prime }$ is better than $ObjV$ then $S\leftarrow S^{\prime }$ // If the objective function value of the solution S′ is better than that of the solution S, the solution S′ is accepted

elseif $\mathrm{e}\mathrm{x}\mathrm{p}(-{\displaystyle \frac{\left|{\mathit{O}\mathit{b}\mathit{j}\mathit{V}}^{\mathbf{\prime }}-\mathit{O}\mathit{b}\mathit{j}\mathit{V}\right|}{\mathit{g}\mathit{e}\mathit{n}}})\ge rand$ then $S\leftarrow S^{\prime }$ // The metropolis criterion is used to decide whether to accept the solution S′

endif

Return S

Algorithm 3. The pseudocode of the optimal solution selected based on TOPSIS.

Input: The Pareto optimal solution set S

Parameters P

$\mathrm{Weights} \mathrm{of} \mathrm{objective} \mathrm{functions} {\omega }_i$

Output: The optimal solution S*

$ObjV\leftarrow Objection (S,P)$ // Calculate the objective function value of the solution S

${ObjV}^{\prime }\leftarrow Normalization\left(ObjV\right)$ // Normalize objective function value

$PIS,NIS\leftarrow Extremum\left({ObjV}^{\prime }\right)$ // Calculate the ideal solutions

$D\leftarrow Distance({ObjV}^{\prime },PIS,NIS)$ // Calculate the distance between each solution and the ideal solutions

$C\leftarrow Close\left(D\right)$ // Calculate the closeness coefficient for each solution

$S^{\ast }\leftarrow selection(S,C)$ // Choose the solution with the largest closeness coefficient as the optimal solution

Return S*

4.3.4. Optimal Task Decomposition Scheme Characterization

The optimal task decomposition scheme is generated by solving the task package model. Since the bill of service (BOS) can effectively plan service activities and calculate service costs [64], it is used to present information about task packages and their interrelationships.

Define a set $H_{BOS}=\left(T_{ID},T_R,T_D,T_{WL},T_C,T_{RQ}\right)$ representing the BOS of task packages. $T_{ID}$ indicates the ID number of task packages. $T_R$ represents the relationship of the task packages. $R=\left(t_{i,j-1},t_{i,j+1}\right)$ indicates the preceding and succeeding task packages. $T_D$ represents the estimated duration of task packages. $T_{WL}$ represents the rated workload of task packages. $T_C$ shows the estimated cost of task packages. $T_{RQ}$ indicates the task content of task packages.

5. Case Study

5.1. Case 1

To verify the feasibility and effectiveness of the integrated task decomposition framework proposed in this study, we collected brand design cases from ZBJ.COM—a renowned CTC platform in China. Brand design represents a typical complex task in the CTC context, encompassing requirements such as brand positioning, brand concept design, visual identity system design, copyright protection, enterprise registration, and so on. In this paper, 10 brand design service cases (including two from the catering industry, one from the entertainment industry, one from the health industry, three from the manufacturing industry, and three from the real estate industry) were collected to construct the database of decomposition templates described in Section 4.1.

5.1.1. Primary Task Decomposition

Service requesters usually post their tasks on CTC platforms. Specifically, in this case, HT company publishes a brand design project on ZBJ.COM and describes the personalized requirements in natural language, as shown in Figure 7.

We can obtain the similarities between the new complex task and the 10 cases using the BERT-CNN model introduced in Section 4.1. To ensure the significance of task vectors, we train a BERT-CNN task classification model based on the task category labels provided by ZBJ.COM, and then extract task representations for similarity calculations using the text encoding module of the classification model. Detailed information on the model structure, experiments, and parameter tuning is shown below.

(1)

Model structure details. The preprocessed task descriptions are first input into a BERT-based model, which generates two outputs: word-level contextual representations and a global representation corresponding to the [CLS] token. The word-level representations are then input into the CNN module, which extracts local features through convolution layers and a max pooling layer, generating a local representation. This local representation is subsequently concatenated with the global representation generated by BERT to form a comprehensive representation, which is finally input into a fully connected layer and a softmax function to output the probability distribution of the task categories.

(2)

Experiments. We collected task data from the brand design field on ZBJ.COM from November 2019 to November 2020, totaling 87,214 task samples across seven annotated categories, and divided the data into training and test sets with a ratio of 7:3. We compared the BERT-CNN model with the standalone BERT model, using accuracy (Acc) and recall (R) as performance metrics. The experimental results showed that the BERT-CNN model outperforms the baseline model in both performance metrics, with an accuracy of 0.89 and a recall of 0.87, significantly higher than BERT (Acc = 0.82, R = 0.80), fully demonstrating the effectiveness of the BERT-CNN model and the strong semantic discrimination capabilities of the text vectors it extracts.

(3)

Parameter-tuning details. In the experiments, we used a pre-trained BERT-based model with fixed parameters. Since the length of complex task descriptions in our dataset mainly ranges from 100 to 300 tokens, the maximum text length was fixed at 300 when inputting into BERT. Sentences shorter than the maximum length are padded with “[PAD]”, while those exceeding it are truncated. We mainly tuned the hyperparameters of the CNN module by adopting the grid search method and Adaptive Moment Estimation (Adam) [65]. We set the size of the convolution kernels to (2,3,4), (3,4,5), and (4,5,6), the number of convolution kernels to 10, 20 and 30, the convolution stride to 3, 5 and 7, respectively. The experimental results indicate that the model performs best when the parameter combination is set to (3,4,5), 30, and 5, and thus this configuration was selected as the final configuration. The parameter settings related to the model are shown in

Table 3. The parameter setting of the BERT-CNN-based model.

Parameter Name	Parameter Setting
The maximum length of texts	300
The vector dimensions in the BERT model	768
The number of Transformer encoding layers in the BERT model	12
The size of the convolution kernels	3,4,5
The number of convolution kernels	30
Convolution stride	5

.

Through the trained BERT-CNN classification model, we extract output vectors from its encoding module, i.e., the concatenated comprehensive representation, as semantic representations of tasks, which are then used for subsequent task similarity calculations. This process ensures the validity of the task vector representations, providing a reliable foundation for subsequent analyses. In addition, it is noted that other text processing methods can also be employed as desired.

The similarities between tasks are shown in

Table 4. The similarities between the new complex task and the 10 cases.

Case ID	Similarity	Case ID	Similarity
1	0.80	6	0.50
2	0.75	7	0.48
3	0.72	8	0.42
4	0.65	9	0.32
5	0.61	10	0.30

. According to the similarity, the decomposition scheme of Case 1, as shown in Figure 8, is selected as the primary decomposition scheme for the new task.

5.1.2. Task Decomposition Modification

Obviously, the primary task decomposition scheme cannot be directly used to decompose the new complex task. Considering the task requirements in Figure 7 and following the task decomposition principles in Section 4.2, we further formulated four new subtasks, i.e., automobile advertising design, indicator design, copyright protection, and enterprise registration. In total, the modified task decomposition scheme consists of 16 lowest-level subtasks, as shown in

Table 5. The subtasks of HT company’s promotion system construction project.

No.	Subtask Name	No.	Subtask Name
1	Mind identity design	9	Work dress design
2	Brand strategy design	10	Automobile advertising design
3	Basic visual identity design	11	Indicator design
4	Basic element combination design	12	Product packaging design
5	Enterprise symbol design	13	Promotional design
6	Mascot design	14	Space identity design
7	Office stationery design	15	Copyright protection
8	Giveaway design	16	Enterprise registration

and Figure 9. The relationships between subtasks and their details are described in

Table 6. The WBS of HT company’s promotion system construction project.

${\mathit{E}}_{\mathit{L}}$	${\mathit{E}}_{\mathit{I}\mathit{D}}$	${\mathit{E}}_{\mathit{N}}$	${\mathit{E}}_{\mathit{R}}$				${\mathit{E}}_{\mathit{D}}$	${\mathit{E}}_{\mathit{C}}$	${\mathit{E}}_{\mathit{R}\mathit{Q}}$	${\mathit{E}}_{\mathit{S}}$
			${\mathit{E}}_{\mathit{i}-1,\mathit{j}}$	${\mathit{E}}_{\mathit{i}+1,\mathit{j}}$	${\mathit{E}}_{\mathit{i},\mathit{j}-1}$	${\mathit{E}}_{\mathit{i},\mathit{j}+1}$
(1,1)	1710	HT company’s promotion system construction project	-	5044 2107 5787	-	-	90	558,000	Brand design, space identity design, company renaming, copyright protection, and so on	-
(2,1)	5044	Brand management consulting	1710	1634 2892 2894	-	2107 5787	65	533,400	Mind identity design, brand strategy design, brand design, and so on	Excellent writing and communication skills
(2,2)	2107	Copyright protection	1710	-	5044	-	10	7600	Enterprise logo copyright protection, trademark registration, and so on	Familiar with the patent application process and related laws
(2,3)	5787	Enterprise registration	1710	-	5044	-	15	17,000	Registration, stamp carving, and so on	Familiar with business registration and related laws
(3,1)	1634	Mind identity design	5044	-	-	2892	7	28,500	Brand core value design, brand story design, brand slogan design, and so on	Advertising design skills
…

.

5.1.3. Subtask Reorganization

Based on the historical transaction data from the CTC platform, candidate workers for each subtask in the modified task decomposition scheme are obtained by the resource availability check method described in Section 4.3.1, as shown in

Table 7. The candidate workers for subtasks.

Subtasks	The Workers’ IDs of Similar History Tasks
Subtask 1	No.886	No.814	No.978	No.398	No.423	No.675	…
Subtask 2	No.261	No.970	No.003	No.814	No.093	No.398
Subtask 3	No.318	No.963	No.100	No.288	No.751	No.226
Subtask 4	No.580	No.047	No.005	No.620	No.968	No.882
Subtask 5	No.757	No.530	No.318	No.574	No.670	No.588
Subtask 6	No.240	No.343	No.041	No.923	No.111	No.189
Subtask 7	No.757	No.318	No.574	No.588	No.951	No.961
Subtask 8	No.804	No.961	No.826	No.226	No.005	No.142
Subtask 9	No.757	No.661	No.670	No.961	No.179	No.887
Subtask 10	No.286	No.661	No.771	No.384	No.887	No.110
Subtask 11	No.961	No.750	No.226	No.768	No.296	No.882
Subtask 12	No.933	No.296	No.005	No.975	No.359	No.692
Subtask 13	No.757	No.503	No.661	No.670	No.588	No.951
Subtask 14	No.864	No.137	No.800	No.576	No.538	No.478
Subtask 15	No.110	No.575	No.226	No.530	No.079	No.254
Subtask 16	No.147	No.110	No.390	No.575	No.987	No.226

. In this process, the BERT-CNN model used in Section 4.1 is also employed to identify historical tasks similar to the subtasks, and the parameters related to the BERT-CNN model are consistent with those in Table 3.

To further reorganize subtasks in the modified decomposition scheme, the task package model in Section 4.3.2 is employed and the improved NSGA-II algorithm proposed in Section 4.3.3 is used to solve it. The relevant parameter settings of the algorithm are shown in

Table 8. The parameter setting of the improved NSGA-II algorithm.

Parameter Name	Parameter Setting
The number of individuals NIND	100
The maximum number of evolutionary iterations MAXGEN	100
The crossover probability Pc	0.9
The mutation probability Pm	0.05
The number of similar tasks for each subtask m	[50, 100, 150, 200]
The threshold of the number of overlapping workers when two subtasks are combined k	3
The weights of the objective functions	(1/2,1/2)

. We set a different number of similar tasks to obtain the candidate workers for each subtask, and the solution results and objectives are shown in

Table 9. The decomposition results of subtasks with different similar task thresholds.

The Number of Similar Tasks for Each Subtask m	(F1, F2)
50	(12, 12.888)
100	(11, 12.267)
150	(10, 11.643)
200	(10, 11.643)

.

Considering the employer’s requirements, an optimal decomposition scheme is chosen from the four decomposition schemes shown in Table 9, and its structure is shown in Figure 10.

In order to effectively present the information of the task packages and their interrelationships, we further characterize the optimal task decomposition scheme based on BOS proposed in Section 4.3.4, as shown in

Table 10. The BOS of HT company’s promotion system construction project.

${\mathit{T}}_{\mathit{I}\mathit{D}}$	${\mathit{T}}_{\mathit{R}}$		${\mathit{T}}_{\mathit{D}}$	${\mathit{T}}_{\mathit{W}\mathit{L}}$	${\mathit{T}}_{\mathit{C}}$	${\mathit{T}}_{\mathit{R}\mathit{Q}}$
	${\mathit{t}}_{\mathit{i},\mathit{j}-1}$	${\mathit{t}}_{\mathit{i},\mathit{j}+1}$
Task package 1	-	Task package 2	7	20	28,500	Design of corporate mission, business philosophy, and code of conduct
Task package 2	Task package 1	Task package 3	9	25	30,000	Brand image design, brand creative design
Task package 3	Task package 2	Task package 4	12	30	117,100	Logo design, enterprise-specific font and color design
Task package 4	Task package 3	Task package 5, 6, 7, 8	7	20	71,300	Basic element combination design, mascot design, and so on
Task package 5	Task package 4	Task package 9	20	45	115,200	Business card design, stationery design, work clothing design, and so on
Task package 6	Task package 4	Task package 9	16	35	46,500	Product identification card design, brochure design, and so on
Task package 7	Task package 4	Task package 9	20	40	90,800	Corporate appearance design, placard design, and so on
Task package 8	Task package 4	Task package 9	15	25	34,000	Space custom design, space culture design, corporate image space design, and so on
Task package 9	Task package 5, 6, 7, 8	-	10	20	7600	Logo copyright protection, trademark registration, and so on
Task package 10	Task package 2	-	15	20	17,000	Registration, stamp carving, and so on

.

Through the decomposition example of the brand design task from ZBJ.COM, the feasibility and effectiveness of the integrated task decomposition framework proposed in this paper have been analyzed and demonstrated.

5.2. Case 2

Case 1 preliminarily verified the feasibility and effectiveness of the proposed task decomposition method. In Case 2, we will further demonstrate the effectiveness and superiority of the improved NSGA-II algorithm for solving the task package model proposed in Section 4.3.3.

5.2.1. Comparison Algorithms

Several state-of-the-art algorithms for solving multi-objective mathematical models, namely AMOSA [66], PMOEA [67], MOEA/D [68], NSGA-II [69], are used for comparison. For a fair comparison, the crossover, mutation and parameter setting of these algorithms remain the same as the improved NSGA-II.

5.2.2. Performance Metrics

To validate the effectiveness and superiority of the improved NSGA-II algorithm, we consider two comparison metrics. On the one hand, it is necessary to compare the performance of the algorithms in obtaining the optimal solution for the task package model. Therefore, the two objectives of the task package model are used as metrics for comparing the performance of the algorithms. On the other hand, the performance of the algorithms in exploring the parent front should also be evaluated. For this purpose, we use several commonly used Pareto metrics [70] in multi-objective optimization for performance comparison, namely the convergence metric, diversity metric, and spacing metric. The smaller convergence metric and spacing metric, and the larger diversity metric, the better the algorithm’s performance.

5.2.3. Performance Comparisons Between the Algorithms

Table 11. Performance comparisons on the objectives between algorithms.

Algorithms	F1	F2	F2/F1
Improved NSGA-II	14.510	14.475	0.998
AMOSA	11.000	9.266	0.842
PMOEA	12.560	12.426	0.989
MOEA/D	9.500	8.557	0.901
NSGA-II	11.140	10.982	0.986

shows the performance comparisons between algorithms on the two objectives of the task package model. For better comparison, we use the average value of the parent front for each algorithm and the ratio of the two objectives, i.e., F₂/F₁, to comprehensively represent the performance of the algorithms.

As shown in the table, the improved NSGA-II algorithm yields the highest F₂/F₁ ratio, indicating that it achieves a better balance between the two conflicting objectives compared to other algorithms. While alternative algorithms generate fewer task packages, their average content relevance is also lower than that of the improved NSGA-II algorithm. This suggests that these algorithms tend to combine irrelevant subtasks into a single package, which may hinder subsequent task–worker matching.

Furthermore,

Table 12. Performance comparisons on Pareto metrics between the algorithms.

Algorithms	Convergence Metric	Diversity Metric	Spacing Metric
Improved NSGA-II	0.767	0.035	0.013
AMOSA	0.759	0.036	0.259
PMOEA	0.791	0.014	0.034
MOEA/D	0.693	0.033	0.030
NSGA-II	0.760	0.027	0.067

presents the performance of the algorithms in exploring the parent front. As indicated in the table, the improved NSGA-II proposed in this study exhibits slightly inferior performance to MOEA/D, AMOSA, and the standard NSGA-II in terms of the convergence metric. However, it outperforms the other four algorithms on both the diversity metric and the spread metric. This result demonstrates that the improved NSGA-II is capable of generating a non-dominated solution set with higher diversity and more uniform distribution, indicating its superiority over the comparison algorithms.

Overall, Case 2 verifies the superiority of the improved NSGA-II proposed in this paper over baseline algorithms commonly used for multi-objective optimization problems.

6. Conclusions

To facilitate crowdsourcing applications from scaling to more complex, interdependent and creative tasks, such as brand design, software engineering, and product design, we propose an integrated task decomposition framework for CTC, which considers knowledge reuse and resource availability, to decompose a complex task into fine-grained subtasks with logical correlations and associations. The database of task decomposition templates allows for the knowledge reuse, thereby increasing the efficiency of the complex task decomposition. Moreover, combining subtasks considering resource dynamics can not only enhance the executability of subtasks but also reduce coordination costs, avoid the waste of the workers’ ability, and boost workers’ earnings in subsequent task scheduling.

This paper conducts a case study on brand design, and the experimental results validate the effectiveness and superiority of the proposed task decomposition framework. As a representative complex task in CTC contexts, brand design features the key characteristics: the absence of objective ground truths, nonlinear dependencies between subtasks, and freedom from strictly sequential processes. These properties are shared by other complex tasks, such as software development, product design, and engineering design, indicating that the proposed framework can be generalized to these domains.

The theoretical and practical implications, the limitations and directions for future work are stated as follows.

Theoretical implications: (1) Existing research on complex task decomposition in CTC has predominantly focused on fragmented elements—either conceptual workflow frameworks (e.g., CrowdForge, Turkomatic) without integrating knowledge reuse, or static decomposition logics that neglect resource dynamics. This study enriches CTC decomposition theory by proposing an integrated framework that systematically incorporates knowledge reuse, WBS-based decomposition principles, and resource dynamics. It addresses the theoretical gap of disconnection between these elements, providing a holistic theoretical perspective for understanding how to achieve effective decomposition in dynamic, high-complexity crowdsourcing environments.

(2) Prior task decomposition theories in crowdsourcing have been largely confined to tasks with clear objective ground truths and linear dependencies (e.g., data annotation, audio transcription). This study extends the theoretical scope of decomposition theories by validating their applicability to complex tasks with ambiguous boundaries, nonlinear dependencies, and subjective quality criteria (e.g., brand design). It demonstrates that decomposition logics can be generalized to high-creativity domains, addressing the theoretical limitation of narrow applicability in existing research and laying a foundation for decomposition theories in ambiguous, creative crowdsourcing contexts.

(3) Existing literature on CTC task decomposition often treats resources (workers) as static, overlooking the impact of dynamic preferences and capability growth on subtask executability. The task package model proposed in this study, which explicitly integrates resource dynamics into decomposition, supplements the theoretical landscape by introducing a new lens to explain how decomposition strategies can balance subtask granularity, resource utilization, and executability. It fills the theoretical gap of neglecting resource dynamism, providing a theoretical basis for adaptive decomposition in contexts where worker capabilities and preferences evolve iteratively.

Practical Implications: (1) For CTC platforms. The proposed task decomposition framework offers actionable tools to improve operational efficiency. The database of decomposition templates reduces redundant efforts in repeated task decomposition, while the resource-aware subtask reorganization minimizes coordination costs in subsequent matching and scheduling. This can enhance platform competitiveness by accelerating task completion and reducing management overhead. (2) For employers and workers. Employers can benefit from faster and more structured decomposition of complex tasks, ensuring subtasks are logically aligned. Workers can gain from reduced communication burdens and increased earnings, as resource-aware subtask reorganization avoids underutilization of their capabilities. (3) For CTC domains: Practitioners in fields such as brand design, software development, and engineering design can leverage the framework to handle tasks with nonlinear dependencies and ambiguous objectives. It provides a standardized yet flexible decomposition approach that balances creativity and efficiency.

Limitations and directions for future work: First, task similarity in this study is solely derived from task descriptions, which may result in imprecise similarity measurements. Future work could incorporate additional features, such as task duration, budget, and location, to develop a more fine-grained and task-specific similarity measurement method. Second, the decomposition templates utilized herein are sourced from a single platform, restricting their generalizability to other platforms. Exploring knowledge transfer and sharing mechanisms across CTC platforms represents a promising direction for future research. Third, the proposed framework relies on manual modifications of the task decomposition scheme by project managers, which may lead to excessive workload and unavoidable errors. Future studies could further investigate the integration of artificial intelligence (AI) to automate and support the task decomposition process.