Smart Factory Embedding (SFE)

• Smart Factory Embedding (SFE) is a formal process that maps manufacturing procedures to machines and orchestrates agent-based material transport in automated factories.
• TS-ACES employs a traffic system abstraction with epoch aggregation to reduce MILP complexity, enabling efficient planning and real-time execution even in large-scale scenarios.
• The framework maximizes throughput while ensuring machine compatibility, buffer conservation, and collision avoidance, proving scalable and complete for industrial applications.

Smart Factory Embedding (SFE) refers to the formal process and associated methods for integrating a manufacturing procedure—specifically the mapping of processes to machines and the planning of material transport by programmable agents—within a modern, automated smart factory. SFE is distinguished by the need to maximize throughput, observe machine and transport constraints, and support scalability to factories containing hundreds of machines. Recent advances provide a rigorous, scalable framework for SFE, notably the Traffic System based Anytime Cyclic Embedding Solver (TS-ACES), which substantially extends the tractable scale of factory embedding by abstracting factory layouts into traffic systems and aggregating time into epochs (Leet et al., 2 Oct 2025).

1. Formalization of the Smart Factory Embedding Problem

In SFE, a manufacturing procedure (sequence of processes) is to be "embedded" into a smart factory comprising a set of programmable machines and a transport network (typically a fleet of mobile agents/robots). The embedding consists of:

• Assigning each process in the procedure to a specific machine that is functionally capable and available.
• Specifying how agents (robots) should transport materials or parts between those machines in a continuous, cyclic fashion.

Formally, the SFE problem is defined by constructing an embedding that maximizes factory throughput, subject to process-machine compatibility, transport plan feasibility, buffer capacity, and collision avoidance among agents. The architecture and core constraints are captured in a tuple (assignment matrix, rate matrix, agent transport tensors) and mathematically formalized as a mixed-integer linear program (MILP).

2. Traffic System-Based Abstraction and Epoch Aggregation

TS-ACES introduces a foundational shift by abstracting the factory layout as a traffic system—modeled as a network of roads and junctions rather than a dense grid of individual cells. Time, which would otherwise be captured in discrete timesteps (resulting in exceedingly large optimization problems), is aggregated into epochs, each covering the time an agent needs to traverse an entire road segment. This abstraction:

• Reduces the number of MILP variables and constraints dramatically compared to direct cell-level formulations (such as ACES).
• Enables the modeling of agent movement, token pick-up and deposit, and buffer handovers at a coarser—yet sufficient—granularity, facilitating scalability to $>100$ machines.

Key decision variables in the TS-based embedding include:

• $assign(m, j)$: binary assignment of process $j$ to machine $m$
• $rate(m, j)$: frequency at which assigned machine $m$ processes $j$, bounded by $1/\text{runtime}(m,j)$
• $inB(r,T,z), outB(r,T,z)$: integer tensors denoting the number of agents carrying token $z$ inbound/outbound on road $r$ during epoch $T$
• $pk(m,T,z), dp(m,T,z)$: agent pick-up and deposit counts from machine buffers during epoch $T$

All variables evolve cyclically over $N_e$ epochs, enabling continuous production.

3. MILP Formulation and Objective Optimization

The TS-MILP aims to maximize overall output throughput: $\max \sum_{m \in M} rate(m, outP(P))$ subject to the following principal constraints:

• Assignment constraints: each machine is assigned at most one process.
• Process compatibility: machines can only be assigned supported processes.
• Rate constraints: for all $m,j$, $rate(m,j) \leq 1/\text{runtime}(m,j)$, and $rate(m,j) = 0$ if not assigned.
• Buffer conservation: the number of tokens picked up or deposited per cycle matches process output/input for each machine/token.
• Traffic conservation: agent flow conservation on each road between epochs, coupling $inB$, $outB$, $pk$, and $dp$ tensors.
• Agent occupancy and capacity: sum of agents on a road in each epoch cannot exceed $\text{len}(r)$; subway transitions across junctions are regulated to ensure no deadlocks or agent “teleports.”

An explicit example of the buffer conservation constraint for a non-sink machine $m$ and token $z$: $$\sum_{T=0}^{N_e-1} pk(m,T,z) = \sum_{k} assign(m,k) \cdot numOut(k,z) \cdot N_e \cdot T_e$$ This constraint ensures cyclical, lossless buffer operation.

4. Hyperparameter Search and Anytime Operation

TS-ACES employs an anytime hyperparameter search to select efficient planning horizons:

• Epoch length $T_e$ is set so that agents can safely transition between junction queues: $T_e \geq$ total outflow from entry roads plus maximal queue clearance for exit roads per Theorem 1.
• The number of epochs $N_e$ is incremented iteratively, and for each candidate pair $(T_e, N_e)$, the TS-MILP is solved. Solutions yielding higher throughput replace incumbent embeddings.

This method produces a sequence of feasible, progressively better embeddings within a given time budget, making TS-ACES practical for real-world industrial deployment.

5. Real-Time Plan Generation and Execution

Once a traffic system-based embedding is solved, the abstract plan is transformed into a detailed, cell-based transport plan using a generator $G$. The generator maintains state tensors (agent positions/cargo, buffer contents) at cell resolution and in each timestep executes:

• $moveAgentsOnRoad()$: move agents between cells on their assigned road.
• $moveAgentOnJunction()$: transition agents through junctions across roads.
• $depositToken()$, $pickupToken()$: buffer manipulation synchronized to agent arrivals/departures.

The generator is designed for $O(|A|)$ update complexity, ensuring that plans are computationally tractable and executable in real time, even for factories with hundreds of agents.

6. Scalability, Completeness, and Empirical Validation

The central advance of TS-ACES lies in its scalability and completeness:

• Scalability: by shifting from cell/timestep to road/epoch level modeling, problem sizes are reduced by several orders of magnitude. In validation, TS-ACES solved SFE instances for factories with up to 107 machines (Contact Lens Large), 104 machines (Hard Candy Large), and similarly scaled use cases in under 60 seconds.
• Completeness: the method is proven to be complete. For any strongly connected layout, a feasible (possibly trivial) cyclic embedding always exists. As the search horizon is extended (increasing $N_e, T_e$), TS-ACES is guaranteed to find a feasible solution if one exists.

Performance metrics from the evaluation show that TS-ACES achieves higher or equal throughput compared to previous MILP-based approaches (e.g., classic ACES) in large-scale scenarios. For example, in Contact Lens Large, TS-ACES achieves a throughput of 4.71 (versus 2.14 for ACES), while also maintaining real-time ($\sim$10ms per update) transport plan execution.

7. Industrial Impact and Current Limitations

TS-ACES was benchmarked on representative industrial scenarios including contact lens production, drug synthesis, and hard candy manufacturing. These scenarios include the full set of SFE constraints (process-to-machine assignment, buffer discipline, agent collision avoidance, and road capacity) and realistic sized factories. Although ACES provides marginally higher throughput for small scenarios, TS-ACES dominates for larger cases.

Current limitations include:

• The MILP still scales polynomially with $|M|$ (machines), though the road/epoch abstraction defers combinatorial explosion.
• The strategy does not address multitasking machines or re-entrant process steps, which are pertinent for advanced manufacturing.
• Solution quality and runtime depend on hyperparameter selection and solver backend performance.

Nevertheless, TS-ACES marks a significant advancement in the tractable embedding of complex manufacturing procedures into flexible, highly automated smart factory environments.

---

Table: Comparison of SFE Solvers

Solver	Maximum Scale (machines)	Embedding Formalism	Real-Time Plan Generation	Throughput Optimization	Completeness
ACES	Dozens	Grid, timestep-based	Linear time per step	Yes	Yes
TS-ACES	O(100)+	Traffic system, epochs	Linear time per step	Yes	Yes

---

TS-ACES enables a paradigm in which the complete SFE problem—process assignment and transport optimization—is tractably solved at industrial scale via the traffic system abstraction and an anytime MILP framework, firmly establishing a new baseline for deploying flexible, high-throughput smart factory systems (Leet et al., 2 Oct 2025).