Fatigue-Aware Sub-Second Combinatorial Auctions for Dynamic Cycle Allocation in Human–Robot Collaborative Assembly

Abstract

Problem: Existing Human–Robot Collaboration (HRC) allocators cannot react at a sub-second scale while accounting for worker fatigue. Objective: We designed a fatigue-aware combinatorial auction executed every 100 ms. Method: A human and a FANUC robot submit bids combining execution time, predicted energy, and real-time fatigue; a greedy algorithm (≤1 ms) with a $1-1/e$ approximation guarantee and O (|Bids| log |Bids|) complexity maximizes utility. Results: In 1000 RoboDK episodes, the framework increases active cycles·min⁻¹ by 20%, improves robot utilization by +10.2 percentage points, reduces per cycle fatigue by 4%, and raises the collision-free rate to 99.85% versus a static baseline (p < 0.001). Contribution: We provide the first transparent, sub-second, fatigue-aware allocation mechanism for Industry 5.0, with quantified privacy safeguards and a roadmap for physical deployment. Unlike prior auction-based or reinforcement learning approaches, our model uniquely integrates a sub-second ergonomic adaptation with a mathematically interpretable utility structure, ensuring both human-centered responsiveness and system-level transparency.

1. Introduction

1.1. Background and Motivation

Human–Robot Collaboration (HRC) represents a transformative shift in manufacturing, merging the precision and endurance of industrial robots with the dexterity and problem-solving capabilities of human operators. Industry 4.0 laid the groundwork for HRC by integrating cyber-physical systems, the Internet of Things (IoT), and cloud-based analytics into “smart factories”, thereby enabling real-time monitoring, predictive maintenance, and adaptive process control (e.g., [1,2,3]). Nevertheless, these early implementations largely treated humans and robots as separate agents, coordinating through pre-programmed handshakes rather than genuine, continuous cooperation.

In contrast, Industry 5.0 emphasizes human well-being and sustainability, advocating for symbiotic work cells in which the robot augments human capabilities while respecting ergonomic limits and environmental constraints [4,5,6]. To realize this vision, allocation of work must occur at the granularity of auction cycles (e.g., 100 ms decision intervals), rather than coarse “tasks” spanning several seconds. Dynamic Cycle Allocation (DCA) addresses this requirement by reassigning cycles in real time based on instantaneous human states (e.g., fatigue, measured via wearable-inspired Inertial Measurement Unit (IMU) and heart-rate models [7,8]) and robot availability metrics (e.g., payload, reachability, and current motion plan).

Robots consistently outperform humans in high-precision, repetitive operations—such as torque-controlled bolting or calibrated pick-and-place—achieving cycle times under 50 ms with repeatability better than ±0.02 mm when simulated in RoboDK [9]. Conversely, humans excel at tasks requiring adaptability, complex perception, or ad hoc decision-making—such as visual inspection of morphological defects and ergonomic judgment—capabilities increasingly recognized as essential in Industry 5.0 environments [2,4,10]. A robust DCA mechanism must, therefore, balance these complementary strengths, optimizing active cycle throughput while minimizing operator fatigue per cycle and maintaining collision-free operation.

However, two core challenges impede sub-second DCA deployment. First, modeling human states involves high-frequency physiological data fusion and predictive filtering to smooth noise without delaying decisions [10,11]. Second, allocation algorithms must be executed within each 100 ms cycle—imposing strict worst-case computation bounds—while accommodating combinatorial bids over potentially dozens of subtasks. Traditional rule-based systems lack the flexibility to adapt to evolving fatigue or unexpected robot downtimes, often resulting in idle periods or safety hazards (e.g., [12,13]). Reinforcement Learning (RL) and Deep RL (DRL) approaches offer adaptive policies but require large training datasets and specialized hardware, and suffer from sim-to-real gaps and limited interpretability (e.g., [3,9,14]). These limitations motivate the design of mathematically rigorous frameworks that integrate real-time state estimations with provably efficient allocation algorithms to fulfill Industry 5.0’s human-centric aspirations (e.g., [9]).

1.2. Research Objectives and Contributions

The overarching objective of this study is to develop and validate a combinatorial auction-based DCA framework that seamlessly adapts to evolving human and robot states, achieving high throughput, low fatigue, and stringent safety in sub-second cycles. To this end, the following specific contributions are provided:

• Adaptive Auction-Based Model: Proposal of a combinatorial auction mechanism in which human and robot agents submit real-time bids reflecting cycle execution time, energy consumption, and fatigue costs [12,13].
• Mathematical Formulation and Approximation: Development of an optimization model that maximizes aggregate system utility under assignment constraints, solved via a greedy algorithm offering a $1-1/e$ approximation guarantee within O (|Bids| log |Bids|) time complexity [15].
• High-Fidelity Simulation Validation: Comprehensive evaluation using RoboDK v5.9 with a FANUC LR Mate 200iD-7L and a 22-Degrees of Freedom (DoF) human avatar, demonstrating a 20% increase in active cycles·min⁻¹, 4% reduction in fatigue per cycle, and >99.85% collision-free rate against a static baseline [16,17].
• Industry 5.0 Alignment and Future Roadmap: Discussion of real-world testbed deployment, multi-agent generalizations, and integration of sustainability Key Performance Indicators (KPIs) (e.g., energy per cycle and CO₂ footprint), positioning the framework as a foundational step toward socially sustainable, human-centered automation [18,19].

1.3. Paper Organization

The remainder of this paper is organized as follows:

• Section 2 reviews the state of the art in HRC allocation, covering rule-based, optimization, RL/DRL, and auction mechanisms.
• Section 3 details the combinatorial auction model, bid computation, and greedy allocation algorithm.
• Section 4 describes the RoboDK simulation environment, human avatar modeling, operator role scenarios, and data capture protocols.
• Section 5 presents experimental results, including statistical analyses and sensitivity studies.
• Section 6 discusses the implications, limitations, and potential extensions.
• Section 7 concludes with a summary of the findings and contributions.

2. Related Work

2.1. Rule-Based and Optimization-Driven Cycle Allocation

Early industrial HRC work relied on rule-based heuristics due to their predictability and minimal computational burden. Nourmohammadi et al. [20] employed constraint programming to balance human–robot assembly lines, achieving modest throughput gains but a failure to respond when operator fatigue or part variability changed in real time. Yin et al. [21] extended rule sets to include simple ergonomic risk indices (e.g., joint torque thresholds), yet their static decision trees could not preempt fatigue-induced safety hazards [4,22].

In parallel, optimization methods—such as mixed-integer programming or metaheuristics—have been proposed to derive provably optimal cycle assignments. Barravecchia et al. [22] introduced a “collaboration scale” metric, embedding it into an integer linear program to maximize combined human and robot utilization but solving their model on even 20 tasks took hundreds of milliseconds [23]. Karas Celik and Özçelik [24] tackled HRC line rebalancing via a hyper-matheuristic, yet their cycle time variability model ignored dynamic human states and thus could not react to real-world fatigue fluctuations [25]. As a result, purely optimization-centric approaches remain impractical for the sub-second reallocation demands of modern collaborative cells.

2.2. Reinforcement Learning and Deep RL for Adaptive Allocation

Reinforcement Learning has been explored to overcome the rigidity of rule-based/optimization schemes by learning allocation policies that react to observed human and robot states [14,26]. Sandrini et al. [26] used an actor-critic agent to reassign sequential assembly subtasks, reporting up to a 12% cycle-time improvement in simulated cells; however, each policy required millions of simulator steps and elaborate digital-twin setups. Deep RL further extends RL via neural approximators (e.g., DQN and convolutional policies [14,27,28]) but, despite capturing nonlinear-ergonomics–throughput trade-offs, these end-to-end methods suffer from sample complexity, sim-to-real gaps, opacity, and restrictive inference latency (e.g., [3,9,14]).

These limitations motivate alternative, semantically transparent frameworks that guarantee bounded latency and built-in interpretability.

2.3. Auction-Based Mechanisms in Multi-Agent and HRC Contexts

Auctions naturally distribute allocation decisions across autonomous agents. In multi-robot contexts, Bandyopadhyay et al. [12] explored quantum-game-theoretic auctions, while Liu et al. [13] and Kozlov & Ougolnitsky [29] applied reverse auctions for federated learning resource sharing. In HRC, auction models remain nascent: Meregalli Falerni et al. [11] considered preference learning but assumed static human utility; no existing work embeds dynamic physiological states such as fatigue into bid functions. Moreover, prior auction formulations often omit formal combinatorial constraints, limiting the allocation of interdependent subtasks in one cycle.

This work fills this gap by casting Dynamic Cycle Allocation as a combinatorial auction, with real-time bid updates reflecting human fatigue and robot availability, solved via a greedy $1-1/e$ approximation in under 1 ms [12,13,30].

2.4. Integration of Human Factors and Real-Time Adaptability

The literature on human-aware HRC underlines the critical need to integrate ergonomic and cognitive metrics into allocation logic. Orlando et al. [7] and Pereira et al. [8] surveyed sensor-based fatigue modeling, demonstrating strong correlations between physiological signals and task errors, yet these studies stop short of embedding such metrics into decision-making loops. Yuan et al. [4] called for Industry 5.0 approaches that harmonize productivity with well-being, while Xiao et al. [14] and Peng et al. [31] hinted at hybrid RL–auction schemes but did not provide rigorous mathematical proof of real-time feasibility. The synthesis is that prior work falls into (i) rule/optimization (fast but non-adaptive); (ii) RL/DRL (adaptive but opaque and slow); and (iii) auctions (scalable, yet human-agnostic). This triangulation exposes the gap our framework fills, namely, transparent auctions embedding continuous fatigue to achieve sub-second adaptation.

In summary, existing allocation schemes lack one or more of the following: sub-second responsiveness, fatigue-aware cost modeling, or a transparent optimization structure. This work directly addresses these deficiencies. Rule-based systems fail to adapt to evolving physiological states; optimization-based methods incur unacceptable computation delays; RL/DRL models suffer from opacity, transferability issues, and costly training; and auction frameworks have yet to embed human ergonomics in real time. Our proposed approach overcomes these barriers by integrating fatigue into a mathematically grounded auction mechanism that is executed within strict timing constraints.

2.5. Availability of Data and Code

All MATLAB scripts for generating the synthetic datasets, sensitivity analysis results, and publication figures are freely accessible from the GitHub repository [32]. The complete aggregated simulation results—including per episode throughput, fatigue, and safety metrics—and the full synthetic dataset (Parquet format) have been deposited on FigShare [33].

3. Problem Statement

Existing HRC allocation methods exhibit critical shortcomings when applied to high-speed, human-aware assembly. Static rule-based schemes rely on fixed priority lists that ignore dynamic human factors—such as cumulative fatigue or transient skill degradation—leading to suboptimal cycle assignments and elevated safety risks [20,21]. Optimization-based approaches (e.g., integer linear programming and mixed-integer nonlinear programming) can find globally optimal allocations but incur computational latencies of hundreds of milliseconds to seconds, rendering them unsuitable for 10 Hz decision loops [23].

Reinforcement Learning (RL) and Deep RL (DRL) approaches offer adaptive policies learned offline, yet they require millions of training episodes and specialized hardware, lack interpretability, and suffer from a “reality gap” when transferring policies to physical cells [3,9,14]. Moreover, few RL-based HRC frameworks formally incorporate real-time human fatigue into the reward structure, limiting their capacity to safeguard operator wellness. Auction-based models provide a promising foundation for distributed, scalable allocation but existing formulations in robotics seldom address dynamic human factors and most neglect rigorous combinatorial bidding, hindering bundle assignments and transparency [12,13,30].

Consequently, a clear research gap emerges that addresses the need for a real-time, human-aware allocation framework that (1) guarantees sub-second computation per decision, (2) incorporates continuous human fatigue and robot availability into cost functions, and (3) offers mathematically transparent bidding and allocation, thereby ensuring both safety and high productivity in collaborative assembly cells [15,34,35].

3.1. Combinatorial Auction Model

The Dynamic Cycle Allocation problem in Human–Robot Collaboration is modeled as a combinatorial auction in which each agent (the human operator or the FANUC robot) submits bids for bundles of tasks. A central allocator then selects the winning bids to maximize total system utility. This formulation guarantees adaptability to changing human fatigue levels and robot availability while preserving a clear optimization structure.

3.1.1. Agents and Tasks

• Agents:

• Human operator $(h$): Represented by the state vector $s_h=\left[f_h,l_h\right]$, where $f_h\in \left[\mathrm{0,1}\right]$ is fatigue and $l_h\in \{\mathrm{0,1},2\}$ is the skill level.
• Robot$\left(r\right)$: Defined by kinematic constraints and an availability flag of $a_r\in \{\mathrm{idle},\mathrm{busy}\}$.

• Tasks:

• $\mathcal{T}=\{t_1,t_2,\dots ,t_n\}$ denotes the set of subtasks (e.g., picking, placing, and bolting).
• Each task $\left(t_j\right)$ carries a complexity level $c\left(t_j\right)\in \{\mathrm{0,1},2\}$ and an estimated execution time ${\tau }_i\left(t_j\right) foragent\left(i\right)$.

3.1.2. Auction Formulation

• Agents submit bids $B_i\left(S\right)$ for each bundle $S\subseteq \mathcal{T}$.
• Binary decision variables $x_i\left(S\right)\in \left\{\mathrm{0,1}\right\}$ indicate if bundle$\left(S\right)$ is awarded to agent $\left(i\right)$.
• The optimization problem is

  $$\underset{\left\{x_i\left(S\right)\right\}}{\mathit{max}}\sum _{i\in \{h,r\}}\sum _{S\subseteq \mathcal{T}}{B}_i\left(S\right)\hspace{0.17em}{x}_i\left(S\right) \mathrm{s}.\mathrm{t}.\sum _{i\in \{h,r\}}\sum _{S\hspace{0.17em}:\hspace{0.17em}{t}_j\in S}{x}_i\left(S\right)\le 1,|t_j\in \mathcal{T},x_i\left(S\right)\in \{\mathrm{0,1}\}.$$

  (1)

This constraint ensures each task is assigned to one agent at most.

All simulation configuration files, parameter sweeps, and post-processing routines can be cloned or downloaded from the project’s GitHub repository [32]. Large data files (simulation logs, aggregated results, and the Parquet dataset) are available via FigShare [33].

3.2. Model Assumptions

The assumptions are as follows: (A1) task times are i.i.d. within ±20% noise; (A2) fatigue increases linearly within a 2500-cycle horizon; (A3) no simultaneous execution conflicts inside a bundle; (A4) a sensor latency < 10 ms, so the state is current at bidding; and (A5) utility is the additive over bundles.

3.3. Bid Calculation

Bids for singleton tasks ($t_j$) are defined and extended to bundles by summation as follows:

• Robot Bid:

$$B_r\left(t_j\right)=w_1\hspace{0.17em}{\tau }_r\left(t_j\right)+w_2\hspace{0.17em}{e}_r\left(t_j\right),$$

(2)

where ${\tau }_r\left(t_j\right)$ is the RoboDK-simulated completion time, $e_r\left(t_j\right)$ is the estimated energy cost, and weights $w_1=0.6 \mathrm{a}\mathrm{n}\mathrm{d}\hspace{0.17em}{w}_2=0.4$ balance speed and energy consumption.

• Human Bid:

$$B_h\left(t_j\right)=w_3\hspace{0.17em}{f}_h+w_4\hspace{0.17em}c\left(t_j\right),$$

(3)

where $f_h\in \left[\mathrm{0,1}\right]$ is the current fatigue, $c\left(t_j\right)$ is the task complexity, and $w_3=w_4=0.5$ balances the ergonomic load and task difficulty.

For any bundle $S,{ B}_i\left(S\right)={\sum }_{t_j\in S}{B}_i\left(t_j\right)$. Bids are updated every auction cycle to reflect current agent states.

3.4. Greedy Allocation Algorithm

The allocation strategy is detailed in Algorithm 1, which implements a greedy auction mechanism to maximize utility. Complexity O (|Bids| log |Bids|) has an approximation ratio $\ge 1-1/e\approx 0.632$ for monotone submodular utility.

Algorithm 1 Greedy Auction (Tasks, Bids)

1. while Tasks $\ne \mathrm{\varnothing }$ do 2. Compute score $s(a,S)=B_a\left(S\right)/\left|S\right|$ for all admissible bundles $S$ 3. Select $\left(a^{*},S^{*}\right)=argmax\_a,S s(a,S)$ 4. Assign $S^{*}$ to $a^{*}$; Tasks ← Tasks\$S^{*}$ 5. end while

3.5. Real-Time Integration

The allocation cycle is executed at 10 Hz (100 ms per iteration) within a closed-loop MATLAB–RoboDK interface as follows:

• State Update: Human states $f_h$ and $l_h$ are obtained from synthetic sensor models; robot availability $a_r$ is queried via the RoboDK Application Programming Interface (API).
• Bid Computation: At each cycle, the bid function $B_i\left(t_j\right)$ is re-evaluated for every task $t_j$.
• Task Assignment: The greedy algorithm determines allocations, which are sent to RoboDK over Transmission Control Protocol/Internet Protocol (TCP/IP) (0.28 ms latency).
• Feedback Logging: Execution results (completion, duration, and safety) are returned by RoboDK and logged for subsequent analyses.

Seeds for deterministic runs 1–500, RoboDK Safety Wizard configurations, and API calls are detailed in the accompanying repository. This closed loop ensures continuous adaptation to human fatigue and the robot workload, supporting Industry 5.0’s human-centric requirements.

4. Methodology

4.1. Simulation Environment (Summary)

Robot: FANUC LR Mate 200iD-7L (URDF import; ±0.02 mm). Human: 22 DoF avatar with synthetic IMU/HR sensors. Tasks: picking/placing/sorting/packaging; duration ~$\mathcal{N}=(\mu ,(0.2{\mu )}^2)$. Control loop: MATLAB ↔ RoboDK TCP/IP; latency 0.28 ms. Safety: RoboDK collision sensors, 0.5 m exclusion zone, and speed throttling via a fatigue semaphore.

4.2. Operator Roles and Scene Capturing

Six distinct operator roles were defined to validate the auction-based allocation framework under varied human–robot interactions. For each role, a single high-resolution (1920 × 1080 px) screenshot was exported directly from RoboDK using one of four pre-configured camera rigs.

The six roles and their capture parameters are as follows (see Figure 1):

• Material Delivery: The operator maneuvers the manual pallet jack into the feed zone. Callout is placed above the head, with the arrow pointing to the jack handle.
• Tray Loading: The operator lifts a color-coded tray of cylindrical workpieces onto the conveyor inlet. Lighting is adjusted to avoid glare on the tray surface.
• Part Transfer: The operator picks completed assemblies off the primary conveyor, maintaining orientation for downstream packaging.
• HMI Supervision: The operator gestures at the HMI console; real-time status bars and parameter sliders are visible on-screen.
• Quality Inspection: The operator stands at the secondary conveyor, visually verifying the part dimensions against the caliper template on the inspection table.
• Packaging Preparation: The operator arranges inspected parts into standardized shipping boxes on the pallet jack, preparing for logistics hand-off.

Throughout all captures, the semaphore is prominently visible above the operator; its color changes are synchronized with the fatigue trace shown on the floating text labels, providing an intuitive visual cue for reviewers who may be unfamiliar with the earlier article.

Each of the six roles is presented in its own figure (Figure 2, Figure 3, Figure 4, Figure 5, Figure 6 and Figure 7), captured from one of four fixed camera perspectives to preserve visual clarity and eliminate occlusions. The figure captions now include the camera rig orientation, mounting height (1.5 m), focal length (35 mm), frame rate (30 fps), role name, and exact callout text. All images were exported as 1920 × 1080 px PNGs, named according to the convention episode<Role>_<Camera>_<Timestamp>.png, and archived alongside a JSON metadata file (fields: role, timestamp, camera_id, exposure, illumination level, and acquisition parameters) in the project repository.

4.3. Parameters and Baselines

To guarantee reproducibility, all simulation parameters were fixed and documented as follows:

• Initial Conditions: Human fatigue $f_h\left(0\right)=0.2$ (20 %), skill level $l_h\left(0\right)=0$ (novice), and robot state $a_r\left(0\right)=\mathrm{idle}$.
• Fatigue Dynamics: $\mathsf{\Delta }{f}_h=k\cdot \mathrm{execTime}$ and $k=5\times {10}^{-3}\hspace{0.17em}{\mathrm{units}·\mathrm{s}}^{-1}$, reflecting the empirically observed correlation between task duration and fatigue accumulation in HRC contexts [7,8]. The $\mathrm{execTime}$ per task was measured using RoboDK simulations.
• Semaphore Thresholds: Green ≤ 0.25, orange 0.25–0.40, and red ≥ 0.40—as enforced by the finite-state machine described in Section 4.1—ensure that bid computations reflect the same ergonomic thresholds used for visual feedback.
• Task Times: Sampled from $\mathcal{N}\left(10\hspace{0.17em}\mathrm{s},\hspace{0.17em}2\hspace{0.17em}{\mathrm{s}}^2\right)$ to reflect the ±20 % variability observed in industrial benchmarks [20,21,36].
• Greedy Auction Parameters:

  Table 1. Greedy auction parameters.

  Parameter	Symbol	Value	Role
  Robot speed weight	α	0.6	Prioritizes faster robot execution
  Robot energy weight	β	0.4	Penalizes higher energy consumption
  Human fatigue weight	δ	0.5	Discourages allocations at high fatigue
  Human complexity weight	γ	0.5	Balances task difficulty
  Auction frequency	f	10 Hz	One allocation every 100 ms

  ${\alpha =w}_1, \beta =w_2, \mathsf{\gamma } {=w}_3, \mathrm{a}\mathrm{n}\mathrm{d} \mathsf{\delta } {=w}_4$; weights sum to 1 per agent and were empirically selected to balance productivity and ergonomics.

  consolidates the weights and frequency used in the allocation algorithm.
• Baselines: Static rule-based, the cycles are assigned by a fixed priority of human-centric cycles to the operator and robot-centric cycles to the FANUC arm, irrespective of dynamic states [4,20,21]. Implementation: Both methods are coded in MATLAB R2025a using the same RoboDK API calls for a fair comparison. Safety margins (0.5 m robot exclusion zone) and joint velocity limits (50% of maximum) are identically enforced.

Each experimental condition comprised 1000 independent episodes (~2500 cycles each), yielding 2.5 × 10⁶ cycles. Sensitivity analyses used 100 Monte Carlo replications per perturbation, consistent with simulation-based optimization approaches in industrial system design [37,38,39]. Data capture and archiving proceeded as follows:

• Logged Metrics:

  ◦

  Throughput: Active auction cycles·min⁻¹, computed as the number of robot-active cycles divided by total robot-engaged time in minutes.

  ◦

  Average Fatigue per Cycle: Mean operator fatigue level (units·cycle⁻¹) sampled per cycle. Semaphore color changes were logged in parallel to cross-validate the fatigue estimates.

  ◦

  Safety Rate: Collision-free cycle proportion, flagged by RoboDK collision sensors.

• Storage: Data streamed via MATLAB to Parquet files (partitioned by episode), with CSV exports (HRC_Simulation_Results_Fanuc.csv) hosted on FigShare (DOI: 10.6084/m9.figshare.29431700) [32,33].
• Determinism: Random seeds 1–500 ensured identical task sequences and noise realizations across runs [40,41,42].
• Post-Processing: Custom Python 3 scripts (pandas, numpy) computed descriptive statistics and generated plots for throughput, fatigue trajectories, and safety histograms. All scripts and raw data are available in the public repository.
• Imaging Archive: All 6000 screenshots (1000 episodes × 6 roles) were auto-named following the protocol episode_role_camera.png and stored alongside JSON metadata to facilitate reproducibility and traceability [43]. Each screenshot embeds the semaphore state in the image footer, enabling rapid visual correlation between fatigue levels and allocation outcomes.

5. Results

5.1. Performance Metrics

The combinatorial auction-based framework was evaluated in RoboDK v5.9 over 1000 independent simulation episodes, each comprising approximately 2500 allocation cycles (100 ms per cycle). A human operator and a FANUC LR Mate 200iD-7L robot collaborated on an industrial assembly benchmark [4,7,8]. The following four primary metrics were extracted and analyzed:

• Throughput (active auction cycles·min⁻¹): Active auction cycles per minute were computed by dividing the total number of cycles in which the robot executed work (“active cycles”) by the corresponding robot-engaged time in minutes. The auction-based method achieved a mean throughput of 360 ± 5 active cycles·min⁻¹, representing a 20% increase over the static rule-based baseline (300 ± 7 active cycles·min⁻¹). Throughput distributions were approximately normal (Shapiro–Wilk: p > 0.05), with a coefficient of variation below 2% across episodes, indicating high consistency [14,26].
• Average Fatigue per Cycle (units·cycle⁻¹): Operator fatigue $f_h$ was sampled at the end of each cycle and averaged over 2500 cycles per episode. Under the auction scheme, mean fatigue reached 0.50 ± 0.01 units·cycle⁻¹, a 4% reduction relative to the rule-based baseline (0.52 ± 0.02 units·cycle⁻¹). Figure 8 shows a gentler auction slope: linear regression over the first 1000 cycles yields 5.0 × 10⁻⁴ units·cycle⁻¹ vs. 5.5 × 10⁻⁴ for the baseline (≈9% lower), supporting the ergonomic improvement [7,21].
• Robot Utilization (%): Defined as the percentage of total allocation cycles in which the robot was actively executing tasks, utilization reached 60.2 ± 1.3% under the proposed framework compared with 50.0 ± 1.5% for the rule-based method. Higher utilization translated into fewer idle intervals and an improved balancing of human–robot workloads. Figure 9 evidences the reduced idle gaps (white regions) under auctions, while Figure 10 shows that residual collisions cluster early; adaptive reallocation then suppresses further events [30,44].
• Safety Rate (% collision-free cycles): Measured as the ratio of cycles completed without any collision events, the auction-based approach attained 99.85 ± 0.05% collision-free executions, outperforming the baseline (95.10 ± 0.10%). Collision events clustered during phases of peak synchronization; the auction model redistributed work to avoid risky overlaps, as seen in the collision scatter (Figure 10) [45,46].

5.2. Comparative Statistical Analysis

A one-way analysis of variance (ANOVA), followed by Tukey’s Honest Significant Difference (HSD) test (α = 0.05), confirmed that the auction-based framework significantly outperformed the static baseline across all four metrics (p < 0.001). Effect sizes, quantified by partial ${\eta }^2$, ranged from 0.31 (safety rate) to 0.44 (throughput), indicating large practical significance [28,47].

Table 2. Aggregate performance metrics across 1000 simulation episodes.

Method	Throughput (Active Cycles · min−1)	Mean Fatigue (Units·Cycle−1)	Utilization (%)	Safety (%)
Auction-Based	360 ± 5 *	0.50 ± 0.01 *	60.2 ± 1.3 *	99.85 ± 0.05 *
Rule-Based	300 ± 7	0.52 ± 0.02	50.0 ± 1.5	95.10 ± 0.10

* Significant difference from baseline (Tukey HSD; p < 0.05).

summarizes the performance metrics across 1000 episodes, analyzed using MATLAB R2025a’s Statistics and Machine Learning Toolbox [34].

Beyond the averages, the boxplots in Figure 11 illustrate the reduced interquartile ranges for throughput and workload under the auction model, underscoring its consistency. The orange diamonds denote the episode-wise mean, while the central box and whiskers reflect interquartile ranges and outliers. The rule-based strategy exhibited occasional outliers with low throughput and high fatigue, absent in the auction results. These results support the role of learning-based mechanisms in promoting more predictable and stable human–robot collaboration, as also demonstrated in conflict-resolution frameworks leveraging machine learning for pHRI [48].

5.3. Sensitivity Analysis

Robustness to parameter variations was assessed via Monte Carlo simulations (100 runs each) perturbing the following key factors:

• Fatigue Rate $\left(k\right)$: The fatigue increment constant $k$ was varied by ±10% around its nominal value (5 × 10⁻³ units·s⁻¹). Throughput remained stable within ±1.2% (363 ± 4 active cycles·min⁻¹ at k = 5.5 × 10⁻³), while average fatigue per cycle increased by 2.3% under higher fatigue rates. Safety rates surpassed 99.8% in all parameter perturbations (Monte Carlo runs), confirming robustness [23].
• Bid weights ($w_1$, $w_2$, $w_3$, and $w_4$): Each bid weight was independently varied by ±10%. Throughput fluctuations remained under 0.5%, and average fatigue per cycle changes were under 0.8%, confirming that the framework does not require precise fine-tuning to deliver benefits [3,9].
• Auction Frequency: Auction cycles at 5 Hz and 20 Hz were also tested. A lower frequency (5 Hz) reduced active cycle throughput by ~3%, while a higher frequency (20 Hz) yielded marginal gains (<1%) at the cost of a 15% higher Central Processing Unit (CPU) load. The 10 Hz setting balances responsiveness and computational demand [18,19].

Figure 12 plots the metric sensitivity curves, demonstrating broad plateaus of high performance over parameter ranges. These results align with prior simulation-based optimization findings and validate the framework’s resilience to implementation variations [9,49,50,51,52,53].

6. Discussion

6.1. Interpretation of Results

The extensive simulation campaign confirms that the auction-based allocation framework delivers substantial gains in active auction cycle throughput, ergonomics, and safety compared with a static rule-based approach. The observed 20% increase in throughput (from 300 ± 7 to 360 ± 5 active cycles·min⁻¹) is not only statistically significant (p < 0.001; ${\eta }^2=$ 0.44) but also practically meaningful: it translates to roughly 60 more active cycles per hour handled by the cell, enabling an additional ≈ 3.6 min of robot work per 10 min period. Moreover, the 4% reduction in average fatigue per cycle (from 0.52 ± 0.02 to 0.50 ± 0.01 units·cycle⁻¹) represents a tangible ergonomic benefit, slowing fatigue accumulation by an average of 0.0008 units per cycle (see Figure 8), which can meaningfully extend operator endurance and reduce error rates [21,25].

Robot utilization improved from 50.0 ± 1.5% to 60.2 ± 1.3%, indicating that idle intervals decreased by ≈61 s per 10 min of operation, freeing capacity for additional cycles or maintenance checks without human intervention.

The near-perfect 99.85 ± 0.05% safety rate demonstrates that integrating fatigue into bid calculations effectively prevents high-risk cycle overlaps; collision events dropped from 4.9% to 0.15% of cycles, a 69% decrease in collision frequency (see Figure 10) [45,46].

Taken together, these results illustrate a balanced trade-off: slight increases in computation per cycle (≈0.5 ms additional CPU load) yield outsized returns in system throughput and human well-being, aligning closely with Industry 5.0’s principles of productivity coupled with social sustainability [4,11]. The framework’s ability to dynamically reallocate auction cycles as fatigue rises—from 0.2 to 0.5 over an episode—ensures that neither agent becomes a bottleneck, fostering resilient, uninterrupted operation (Figure 10).

6.2. Comparison with Existing Methods

A detailed juxtaposition of four canonical allocation paradigms—rule-based, optimization-based, deep RL, and the proposed auction framework—is presented in

Table 3. Comparison of cycle allocation methods in HRC.

Method	Adaptability	Interpretability	Comp. Time (Per Cycle)	Fatigue Modeling
Rule-Based	Low	High	<0.1 ms	No
Optimization-Based	Medium	Medium	>200 ms	Partial
DL-RL	High	Low	~50 ms (inference)	Partial
Auction-Based (Proposed)	High	High	<1 ms	Yes

Adaptability and interpretability levels were qualitatively scored as Low/Medium/High using three criteria each. Adaptability: (A1) ability to react within ≤100 ms, (A2) explicit integration of human fatigue, (A3) need for offline retraining. Interpretability: (I1) transparency of decision mechanism, (I2) ease of certifying safety, (I3) ability to attribute allocation rationale. Methods satisfying all three criteria are classified as “High”, two = “Medium”, and ≤1 = “Low”. The qualitative labels (High, Medium, and Low) were assigned based on criteria, including model transparency, learning dependency, and required hardware support, as discussed in Section 2 and Section 6.2.

. Compared with optimization-based solvers (e.g., integer programming by Barravecchia et al. [22]), which yield exact allocations at the cost of >200 ms per decision and limited scalability beyond ~20 tasks, the greedy auction method completes in < 1 ms per auction cycle with only a 37% theoretical loss from optimality, of $1-1/e\approx 0.632$.

In contrast to deep RL methods—such as the Convolutional Neural Network (CNN)-DQN hybrid by Sandrini et al. [26], which achieved a 19.8% throughput gain but required ≈10 h of GPU training per scenario and exhibits opaque policy reasoning—the auction model delivers a near-comparable 20% gain in active cycles·min⁻¹ without offline training, offering full transparency through explicit cost functions [14].

Rule-based systems like those of Yin et al. [21] and Nourmohammadi et al. [20] can run at <0.1 ms but plateau at 300 active cycles·min⁻¹ and lack fatigue awareness, leading to spikes in collision rates and operator fatigue. The proposed approach unifies the speed of rule-based heuristics with the adaptivity of learning methods while preserving a clear mathematical foundation that facilitates certification and user trust in regulated industries.

6.3. Privacy and Socio-Technical Considerations

Although the present study uses fully synthetic physiological signals (see the Ethical Statement), deploying the framework on real workers introduces privacy and fairness risks: fatigue traces could reveal health conditions or be misused for performance surveillance. To mitigate these risks, we propose (i) on-device preprocessing and storage minimization; (ii) pseudonymization and access control aligned with GDPR-like principles; (iii) explicit informed consent and opt-out mechanisms; and (iv) periodic audits to detect bias in allocation decisions. These safeguards broaden the socio-technical applicability of the framework without compromising responsiveness.

6.4. Limitations

Several constraints temper the current framework’s applicability.

• Scale of Task Sets. Although the greedy algorithm runs in O (|Bids| log |Bids|) time (with |Bids| representing the number of admissible agent–bundle bids), empirical profiling shows performance begins to degrade when |$\mathcal{T}$| > 100 because |Bids| grows rapidly with the bundle size. Future work must explore hierarchical auctions or task clustering to maintain sub-millisecond decision times in large-scale assembly lines [15,47].
• Fatigue Model Simplifications. Single-scalar synthetic fatigue may underestimate transient muscular recovery: empirical studies suggest richer models can shift per cycle fatigue by ≈±5–8%. Incorporating multi-factor physiological sensing could, therefore, magnify the observed 4% reduction (best-case) or slightly dilute it but would not overturn the statistically significant throughput and safety gains [8,54,55].
• Human Acceptance and Trust. Automated reallocations may be perceived as unpredictable or unfair by operators. User studies must assess cognitive load, trust calibration, and interface design to ensure that the system’s transparency encourages acceptability [7,25].
• Environmental Variability. Simulations assume stable lighting, friction, and network conditions. Real-world environments introduce sensor noise, conveyor variation, and network jitter, which could erode performance if not explicitly mitigated through robust control loops and adaptive filtering [16,56].

6.5. Generalization Potential

Although validated on a single assembly workflow, the bidding formulation only depends on task time, energy, and fatigue costs; thus, porting to alternative workflows (e.g., inspection and disassembly) requires redefining bundle sets and retraining the fatigue estimator. Preliminary internal stress tests retained ≥90% of the throughput gain, indicating a promising cross-domain transfer.

By pursuing these avenues, the framework can evolve from a high-fidelity simulation prototype into a comprehensive, scalable, and sustainable toolchain for next-generation human–robot manufacturing systems. Although the current model is validated on an assembly task, its modular structure—fatigue estimation, bid generation, and greedy allocation—can be generalized to inspection, packaging, or logistics workflows, provided appropriate cost models and fatigue proxies are incorporated. Future studies should empirically validate such transferability.

7. Conclusions

The proposed fatigue-aware combinatorial auction is executed every 100 ms, achieving +20% throughput, −4% per cycle fatigue, +10.2 pp utilization, and 99.85% safety versus a static baseline (p < 0.001). These significant gains show that transparent sub-second auctions can jointly enhance productivity and ergonomics. As implementation only relies on standard API calls and additive cost functions, integration into existing cells is straightforward. Future work will address (i) physical testbed validation with real wearable sensing, (ii) multi-agent decentralized auctions, (iii) sustainability-aware bidding (energy and CO₂), (iv) adaptive/event-triggered auction cadence, (v) hierarchical auctions for large task sets, and (vi) explainable analytics (e.g., SHAP) to strengthen operator trust, collectively charting a path from a simulation prototype to a privacy-preserving, scalable Industry 5.0 toolchain.