A Simple Stang Method for Multi-Skill Call Centers

Auke Pot, Sandjai Bhulai & Ger Koole

Vrije Universiteit, De Boelelaan 1081a, 1081 HV Amsterdam, The Netherlands

Revised version
Abstract In this paper, we study a simple method for stang in multi-skill call centers. The method has short computation times and determines nearly optimal stang levels. It is in both views competitive to other methods from the literature. Due to the fast and accurate performance of the method, many dierent scenarios can be analyzed as well as tactical or strategic decisions. keywords: contact centers, multi-skill call centers, skill-based routing, stang, workforce management.

Introduction

The call center industry is large and growing rapidly; there are millions of employees and hundreds to thousands of call centers world wide. More generally, we speak of customer contact centers, since telephony is not the only communication channel nowadays. A substantial number of contact centers can be classied as inbound centers, i.e., jobs are initiated by customers. A property of this type of contact centers is that jobs arrive randomly over time and, as a consequence, the workload is hard to predict; additional complexity is added by external factors such as, for instance, the weather. Due to these complexities, the allocation of labor resources over time is a hard yet important problem. It is important because an inadequately managed workforce can lead to low service levels, e.g., long waiting times, if there are not enough employees available. This can be avoided by scheduling a suciently large number of employees. However, it is undesired to schedule too many employees because, besides service levels, contact centers also have to meet economical objectives, in particular, minimizing costs due to employee salaries. Minimizing the number of employees is an important subject because labor is expensive; about eighty percent of operating costs in call centers are due to personnel (see Gans, Koole & Mandelbaum [GKM03]). Therefore, the cost reductions obtained with good stang algorithms can be substantial. Note that optimal labor allocation in single-skill call centers is already a complex issue, since it should be studied by integrating shift scheduling as well. This, however, results in 1

intractable models, and therefore we study the stang problem seperately from the shift scheduling problem. In practice, obtaining good rosters requires several iterations between stang and scheduling. In these cases, it is important to have a stang method with short computation times. Contribution In this paper, we deal with the stang problem of the labor allocation process. Our main contribution is that we develop a stang method to determine schedules in multi-skill call centers such that a rough match between the predicted workload and labor capacity is realized taking the randomness of the arrival process into account. The stang method has several appealing properties that make it competitive in comparison to other methods in the literature: it is easy to implement, has short computation times, and yields nearly optimal stang levels. Hence, the results of the method can therefore be used for the scheduling problem. Due to the fast and accurate performance of the method, many dierent scenarios can be analyzed as well as tactical or strategic decisions. For an application to the scheduling problem we refer to Bhulai, Koole & Pot [BKP06]. Literature In call centers the stang levels are typically determined as follows. The working day is split into consecutive time intervals. Then, independence is assumed between the dierent periods as well as stationary behaviour in each period. Using standard formulas, like the Erlang-C formula, the stang level is determined for each time interval. (For literature on the Erlang formula and the determination of stang levels, we refer to Cooper [Coo81].) Most models from the literature have the limitation that assumptions are made (e.g., exponential distributions) to derive closed-form expressions for the relation between service level metrics and stang levels. These closed-form expressions have the advantage that computation times are short, however, the assumptions are unrealistic in practice. The impact of assuming independence between the time intervals can be reduced. Thompson [Tho93] describes a method that corrects for the multi-period impact by means of adjusting the arrival rate appropriately in each period. Green et al. [GKS01] propose the lag-max algorithm that shifts the stang levels forward in time. This results in service levels that are satised for almost all periods when taking transient eects into account. To obtain more accurate stang levels for realistic situations call centers are often forced to use simulation. Koole, Pot & Talim [KPT03] present a heuristic to optimize the division of agents among dierent groups. The method in this paper is an extension of this heuristic, since we additionally take the costs of agents and the service-level conditions into account. Chevalier and Van den Schrieck [CV05] consider overow routing in multi-skill blocking systems with randomization parameters. Examples with four dierent skills are provided, and an agent group is included for each possible set of skills. They describe a method to

optimize the stang levels and randomization parameters by using the Branch-and-Bound algorithm (see Land and Doig [LD60]). Cezik & LEcuyer [CL06] describe a stang method in the context of multi-skill call centers. The method reduces the solution space by means of generating cuts. The computation time of this algorithm is relatively long because each cut requires the multi-skill call center to be simulated multiple times and very accurately. Hence, they are not able to solve the shift scheduling problem, but are only able to determine the stang levels that are constant over the day. Outline The paper is organized as follows. Section 2 denes the problem and introduces the notation that will be used throughout the paper. The main contribution of the paper is in Section 3, presenting an ecient method for stang in a multi-skill environment while meeting a service level constraint. The performance of the stang method is extensively evaluated numerically in Section 4 and compared to the method of Cezik & LEcuyer [CL06]. We show that the method is fast and yields nearly optimal results. Finally, a summary of the results is given in Section 5, which also discusses directions for future research.

Problem Formulation

Consider a call center that handles calls which require a skill from the set M := {1, 2, . . . , M }. Calls of type m M arrive according to a Poisson process with rate m . Every agent in the call center belongs to an agent group from the set G = {1, 2, . . . , G}. The service rates are skill and group dependent, denoted by rate m,g for skill m M and group g G. We assume that a control policy is given that denes the call-selection and agent-selection rule. Call assignment occurs according to the agent-selection rule. If a call is not assigned to an agent group, it is queued, after which it is served according to the call-selection rule. We dene the service level as the percentage of arrivals that waits less than the acceptable waiting time (AWT) in the queue. This service level is denoted by SL (s) when control policy is used, where s is a vector of length G denoting the stang levels of the dierent groups. The minimal requirement is denoted by . In practice, call centers often take = 80% and an AWT of 20 seconds. The objective is to calculate the number of agents s that is required to meet the service-level constraint. Note that the service-level constraints are only included to a limited extend. Service levels cannot be specied per job type. In our opinion, this is not a severe restriction. Schedules are most often generated at least a few weeks ahead of time based on predictions. Call centers often have to reschedule during the day when the real workload deviates from the predictions. Thus, service levels often can be and need to be controlled during operations. In addition, service levels can also be controlled by means of optimizing the routing policies. The stang costs are denoted by K(s) and are determined by calculating the expected 3

costs of scheduling sg agents in group g. Mathematically, K(s) :=

gG

K g (sg ),

where K g (sg ) are the costs of scheduling sg agents. The objective function is given by f (s) := K(s). The objective of nding optimal stang levels can be translated into the following optimization problem maxsZG f (s) + P1 s.t. SL (s) , with Z+ the set of non-negative integers.

Stang Algorithm

In this section we present an ecient method to determine the stang levels for each agent group, based on P1. However, the problem P1 is intractable since the number of dierent agent congurations s is huge and hence suers from the curse of dimensionality. Experiments show that there exists no simple ordering of states such that simplication by local search would be possible. For this reason, we reformulate problem P1 as maxnZ+ maxsZG :se=n f (s) + s.t. SL (s) . Our solution approach is to solve the Lagrangian dual of this integer problem. Note that we are solving a discrete optimization problem so that there can be a duality gap. Moreover, the service level is only concave in the number of agents if the system is stable, assuming no abandonments occur, see Jagers & Van Doorn [JvD91]. Therefore, we should ignore stang vectors that yield unstable systems. However, in case of abandonments a problem could arise, because the service level is not a concave function anymore. To this end, we formulate the algorithm in such a way that we only require weaker monotonicity properties. For the formulation of the Lagrangian dual, we dene f (, s) := SL (s) K(s), and f (n) () := Then, problem P1 becomes P2 maxn>Ln f (n) , 4
sZG :se=n +

(1)

max

f (, s).

where f (n) := min f (n) (),

R

and Ln denotes the smallest number of agents such that the service level constraint can be satised. The variable is the Lagrange multiplier of the service level constraint, denoting the sensitivity of K(s) for changes in . Finally, in the remainder of this section we need to dene SL(n), (), dened as SL(n), () := SL arg
sZG :se=n +

max

f (, s) .

We now present a simple heuristic for solving problem P2, and explain the heuristic in detail afterwards. Staffing heuristic() 1 Initialization: f 0, nL 0, nU M, L 0, and U M 2 For all n (golden ratio search): 3 Init: f (n) () M and L + (U L )/z 4 While U L > (bisection) 5 Initialization: f (n) () 0 and s 0 and declare SL(n), () 6 For all s : se = n (local search) 7 Calculate SL (s) and f (, s) 8 If f (, s) > f (n) () 9 s s, f (n) () f (, s), and SL(n), () SL (s) 10 End if 11 Next 12 If f (n) () < f (n) 13 s s and f (n) f (n) () 14 End if 15 If SL(n), () < then L , else U End if 16 L + (U L )/z 17 Next 18 If f (n) > f then f f (n) and s s End if 19 Update nL , nU , and n by using the golden ratio. 20 Next The heuristic consists of several parts. The initialization occurs in lines 15 and uses several parameters: nL /nU is the lower/upper bound of the total number of agents, L /U is the lower/upper bound of , and M is a large number, e.g., 104 . In lines 611 the heuristic nds the optimal agent conguration with respect to f (, s) for a xed Lagrange multiplier and a xed number of agents n = se. Lines 1516 optimize the costs by varying , whereas lines 1819 vary n. Optimality with respect to is tested in lines 1214, which is also checked against optimality with respect to n in line 18. The result is stored in the variable

s , which is the nal output of the algorithm. A few lines require additional explanation, which are given next. Apply local search In the part where the optimal agent conguration is determined, lines 611, we mention a local search algorithm that has not yet been dened. To this end, we dene an ordering on the set {s : se = n} such that s1 < s2 i f (, s1 ) < f (, s2 ). The local search algorithm works well theoretically if there exists a path s1 = s1 < s2 < < sp = s2 of length p such that si+1 = si ea + eb , with a, b G and ei a vector with an 1 at index i, and 0 otherwise. In practice, it also performs well in all our experiments. In the local search algorithm, the next state si+1 = si ea + eb is the successor of si chosen such that f (, si+1 ) is maximized over all m, n G and f (, si+1 ) > f (, si ). Avoid simulations We use other performance evaluation methods than simulation to determine service levels in the local search algorithm. The benet is a considerable reduction of computation times. We refer to Section 3.1 for alternative methods that are based on blocking models. In general, a disadvantage of these methods is that the absolute values of the service level approximations are not accurate. However, changes in service levels by adjustments to the sizes of the agent groups can be measured suciently accurate (see Section 3.2 for a discussion). Hence, to make sure that the service level converges to , we did an extension in line 15. To make this work, we need that SL(n), () is a monotone increasing function in . This is likely to hold, because if the Lagrange multiplier of the service-level increases, the service level has a higher weight in the objective function, so that it is likely to increase. Thus, it enables us to optimize the Lagrange multiplier such that the service level approaches , ensuring that the service level condition is met. Assume monotonicity The second part of the heuristic deals with the optimal value of . The implementation is based on the intuition that f (n) () is convex in for xed n. Indeed, when increases, the service level becomes more relevant when determining s, resulting in a higher value of f (n) () due to more conservative scheduling. The third part of the heuristic optimizes n and relies on concavity of f (n) . Indeed by intuition, the service level is concave in n if the system is stable and the costs K(s) will typically be linear. Notice that n is not a continuous variable such that results can be inaccurate. The variable n is optimized by the golden ratio search (see Press et al. [PTVF02]). In line 19 we always increase nL if the service level can not be met, for example, if the system is not stable. This is checked by taking = M, and applying the local search algorithm from lines 610, such that the service level is maximized.

3.1

Performance improvements

The algorithm as described in the previous section has long computation times because of the huge number of required simulations in line 6. This can be reduced signicantly, which is discussed in this section. A straightforward technique to evaluate the system in each iteration is simulation, which is often used in industry. However, this technique is very time-consuming. The calculation times can be reduced substantially by reducing the number of simulations. This can also be done by using methods from the literature that are based on a multi-skill blocking model, see, e.g., Franx et al. [FKP06] and Chevalier & Tabordon [CT03]. These methods assume no queues and approximate the blocking probability of the system. Although these assumptions are not made in our model, these methods from the literature are useful; earlier studies show that when comparing two dierent stang levels, the dierence in blocking probabilities accurately reect the dierence in service levels for the original system, see Koole et al. [KPT03] for a rst example, and Chevalier et al. [CST04] and Chevalier & Van den Schrieck [CV05] for a method that integrates one of these methods in an optimization algorithm. Thus, these methods are useful for optimization purposes, and therefore used in all of our numerical examples. In particular, we used the HyperExponential Decomposition method from Franx et al. [FKP06] and the Hayward-Fredericks method [Fre80]. The results that are reported in the tables are obtained by the Hayward-Fredericks method. We prefer this method above the HyperExponential Decomposition method because it is faster. To support these methods of blocking models, the algorithm is adjusted as follows: replace in lines 611 SL by SL, denoting 1 minus the blocking probability instead of the probability of waiting less than 20 seconds, replace by because the Lagrange multiplier has no longer the same meaning, redene in Equation (1) f (, s) = K(s), and determine after line 11, SL(n), () by simulation, and calculate f (n) (). Line 15 is of crucial importance because it ensures that the service level constraint is met. For that reason, the redenition of f (, s) is justied. Another way to improve the performance is as follows. With the initialization it is preferable to choose nL and nU as tight as possible. This increases the speed of the algorithm. A formula such as the Erlang-C was helpful to calculate lower and upper bounds on the total number of agents. A lower bound is obtained by considering the system as a single-skill call center and taking the lowest service rate over all groups and skills. An upper bound is obtained by considering separate call centers for each job type. Finally, we mention a number of technical notes to reduce the computation times 1. We take z = MAX(2.0, LOG(U L )). 2. For each n the local search starts with the agents equally distributed among the agent groups. Every time that is adjusted according to the bisection algorithm, the group sizes are not changed. 7

3. Before is optimized for a certain n, we check if the best objective value that has been found so far, can be improved for that value of n by calculating an upper bound. Otherwise, is not optimized and the golden ratio method continues directly by choosing another value of n. 4. Each time the stang vector is adjusted according to s s + ei ej , we repeat the same movement several times, as long as the objective improves and ej is greater than 0, with a maximum of 3 times.

3.2

Optimality of blocking models

To justify the usage of blocking models we validate this by performing numerical experiments. We compare two performance measures: the overall blocking probability in case of no queues, and the fraction of customers that are served within 20 seconds waiting in the presence of queues. The rst measure is approximated by using the Hayward-Fredericks method and the second measure is approximated by means of simulation. We consider an arbitrarily chosen model. There are 3 types of jobs, M = {1, 2, 3}. Jobs arrive with intensities 1 = 1, 2 = 1.5, and 3 = 2. The groups are S1 = {1}, S2 = {2}, S3 = {3}, S4 = {1, 2}, S5 = {2, 3}, and S6 = {1, 2, 3}. The routing policy is (1 : 1 4 6), (2 : 2 4 5 6), and (3 : 3 5 6). The service rates are 1,1 = 0.5, 2,2 = 0.55, 3,3 = 0.6, 1,4 = 0.47, 2,4 = 0.50, 2,5 = 0.51, 3,5 = 0.56, 1,6 = 0.45, 2,6 = 0.45, and 3,6 = 0.52. The initial stang levels are s1 = 2, s2 = 2, s3 = 2, s4 = 2, s5 = 2, and s6 = 2. By means of experiments we measure and compare the relative dierences of both performance measures when agents are moved from one group to another. Under the initial stang levels we obtain a service level of SL (s) = 0.7922 in case of queues, and a service level of SL (s) = 0.8896 in case of no queues. Table 1 shows the changes in the service level when the stang levels are adjusted. In more detail, it presents the absolute values of the two service levels on the left and the relative changes to the service levels compared to the initial stang levels on the right. The rows are ordered according to the relative dierences associated to the queueing model. We conclude that the ordering of these dierences for both models are roughly identical. Next, we execute another experiment to compare the stang levels of the two methods that result from optimization. A local-search method is applied to maximize the service levels with the same total number of agents, i.e., 12 persons. In case of queues, the optimal service level is 84% and the corresponding stang levels are (0, 0, 2, 4, 4, 2). Without queues, we obtain a service level of 83% and the stang vector (0, 0, 0, 2, 4, 6). This shows that approximations by means of blocking probabilities yield nearly optimal stang levels. However, this example also reveals that the optimal stang vectors can dier between both methods. In our opinion, the three most important observations of this experiment are: Blocking probabilities are less sensitive to adjustments of the stang vector. 8

s (1, 2, 3, 2, 2, 2) (1, 2, 2, 2, 3, 2) (1, 2, 2, 2, 2, 3) (2, 1, 2, 2, 3, 2) (2, 1, 3, 2, 2, 2) (2, 2, 2, 1, 3, 2) (2, 1, 2, 2, 2, 3) (2, 2, 2, 1, 2, 3) (2, 2, 3, 1, 2, 2) (1, 2, 2, 3, 2, 2) (2, 2, 2, 2, 3, 1) (2, 2, 3, 2, 2, 1) (1, 3, 2, 2, 2, 2) (2, 2, 3, 2, 1, 2) (2, 3, 2, 1, 2, 2) (2, 2, 1, 2, 3, 2) (2, 2, 2, 2, 1, 3) (2, 1, 2, 3, 2, 2) (2, 2, 1, 2, 2, 3) (3, 2, 2, 1, 2, 2) (2, 2, 2, 3, 2, 1) (3, 1, 2, 2, 2, 2) (2, 3, 2, 2, 2, 1) (2, 2, 2, 3, 1, 2) (2, 3, 2, 2, 1, 2) (2, 3, 1, 2, 2, 2) (2, 2, 1, 3, 2, 2) (3, 2, 2, 2, 2, 1) (3, 2, 2, 2, 1, 2) (3, 2, 1, 2, 2, 2)

blocking SL (s) SL (s) 0.898 0.98% 0.900 1.18% 0.903 1.58% 0.899 1.10% 0.896 0.73% 0.897 0.84% 0.899 1.13% 0.899 1.09% 0.894 0.53% 0.893 0.47% 0.885 0.45% 0.884 0.61% 0.887 0.19% 0.887 0.19% 0.885 0.50% 0.888 0.09% 0.891 0.19% 0.890 0.08% 0.890 0.11% 0.878 1.28% 0.872 1.95% 0.877 1.35% 0.868 2.34% 0.873 1.84% 0.870 2.15% 0.868 2.36% 0.871 2.03% 0.862 3.05% 0.862 3.05% 0.861 3.18%

waiting SL (s) 0.832 5.05% 0.830 4.78% 0.828 4.54% 0.823 3.90% 0.821 3.66% 0.820 3.58% 0.818 3.35% 0.817 3.24% 0.816 3.11% 0.811 2.49% 0.809 2.15% 0.803 1.41% 0.801 1.20% 0.798 0.81% 0.797 0.71% 0.794 0.25% 0.793 0.14% 0.792 0.04% 0.788 0.52% 0.758 4.25% 0.755 4.66% 0.747 5.59% 0.745 5.85% 0.739 6.71% 0.736 7.05% 0.735 7.11% 0.725 8.39% 0.723 8.73% 0.701 11.51% 0.699 11.69% SL (s)

Table 1: Relative dierences

 The usage of blocking models yields solutions with relatively many generalists compared to delay models. This is intuitively clear because the service of a client in blocking models requires that an agent must be available upon arrival, which pleads for agents with many skills. In delay systems, however, customers can also be served after the arrival epoch because they can wait. Then, the higher service speed of specialists becomes more benecial. The number of nearly optimal stang vectors is huge and the vectors are diverse. This holds for both types of models. For example, the previous example gave two solutions with almost the same service level. A reason for the latter two observations is that we did not dierentiate between the stang costs of the dierent agent groups. However, the stang algorithm does dierentiate between costs by means of the Lagrange multiplier. Hence, the dierence in stang vectors between delay and blocking models becomes much smaller, which can be concluded from the example in Section 4.3. Moreover, Section 4 provides numerical examples of all algorithms of this paper. They allow us to conclude that the stang algorithm works well and produces nearly optimal results in reasonable cases.

Numerical experiments

In this section, we provide numerical examples illustrating the method from Section 3. The examples use models having innite waiting queues, customers having innite patience for service, and service according to a rst-in-rst-out service discipline per job type. Upon arrival, calls are assigned to employees according to overow policies (see, e.g., Franx et al. [FKP06]), and in such a way that specialists have the highest priority, agents with 2 skills the second-highest priority, and agents with 3 skills the third-highest priority. At a service completion, among the queues with jobs for which the agent has the right skill, a job from the longest queue is taken. The computations were executed on a PC with a 2800 AMD Athlon processor. The RAM usage for our method was always very low.

4.1

A Call Center with Two Skills

Consider a call center with 2 skills and 3 agent groups, i.e., G = 3 and M = {1, 2}. The arrival rates are 1 = 1.5 and 2 = 2. A group of specialists is included for each call type, S1 = {1}, S2 = {2}, and additional exibility is ensured by generalists, S3 = {1, 2}. Upon arrival the routing policy is (1 : 1 3) and (2 : 2 3). This means that calls of type 1 are assigned to agents of group 1, unless all type-1 agents are unavailable. In that case, agent group 3 is considered. The sequence for type 2 calls is interpreted similarly. The costs cg of stang an agent in the g-th group is 0.5 if g = 1, 0.7 if g = 2, and 0.9 in case g = 3. Specialists are more ecient than generalists, thus 11 = 0.18, 22 = 0.6, 13 = 0.16, and 23 = 0.5. 10

16 2.5e3 6.3e2 1.6e2 3.9e1 9.8e0 1.7e1 2.3e1 2.7e1 3.6e1 s (6,4,6) (7,4,5) (7,4,5) (9,5,2) (11,5,0) (10,6,0) (10,6,0) (10,6,0) (9,5,2) 9.8 SL 80% 80% 80% 81% 76% 76% 76% 76% 81% 2.5e3 6.3e2 1.6e2 3.9e1 9.8e0 2.4e0 4.3e0 6.7e0

n 17 s (7,5,5) (8,4,5) (8,4,5) (10,5,2) (11,6,0) (14,3,0) (12,5,0) (12,5,0) 9.5 SL 87% 88% 88% 87% 84% 41% 81% 81% 2.5e3 6.3e2 1.6e2 3.9e1 9.8e0 2.4e0 4.3e0 4.3e0

18 s (8,5,5) (9,4,5) (9,4,5) (10,6,2) (12,6,0) (15,3,0) (13,5,0) (13,5,0) 10 SL 93% 93% 93% 91% 89% 42% 83% 83%

Table 2: Output of the stang algorithm (with 2 skills) Table 2 summarizes the main results that are obtained by applying the algorithm to this example. The table consists of three columns for dierent numbers of agents n, determined by the optimization procedure. For each n it shows in each consecutive row the obtained by bisection, together with the optimal stang level obtained by local search, and the corresponding service level. The variable converges over the dierent rows to the optimal value. The integer after the e in the column of , say k, denotes that the k value should be multiplied by 10 . The table only presents data of the rst 9 iterations of the bisection algorithm because they show the most signicant improvements. The last two rows show the optimal outcomes, for each value of n; the rst row presents the optimal , SL , and s . The second row contains the stang costs of the optimal vector. In addition, the stang costs K(s ) are 9.8, 9.5, and 10 for 16, 17, and 18 agents, respectively. Moreover, taking n = 19 yields as optimum K(s ) = 10.5. The objective value of 9.5 for n = 17 is the best solution found. It also appears to be optimal; no better solution was found by enumerating the whole search space and evaluating each stang vector. The algorithm requires simulating a few more than 17 dierent stang vectors, taking a few seconds computation time each. Moreover, the optimization procedure performed by local search hardly takes any time.

4.2

A Call Center with Three Skills

By adding a skill to the set from the previous example the number of dierent skill sets increases from 3 to 7. The skills of the agent groups are: S1 = {1}, S2 = {2}, S3 = {3}, S4 = {1, 2}, S5 = {2, 3}, S6 = {1, 3}, and S7 = {1, 2, 3}. The routing is (1 : 1 4 6 7), (2 : 2 4 5 7), and (3 : 3 5 6 7). Jobs arrive with rates

11

1 = 2 = 3 = 2 and the service rates mg , denoting the service rate of agents from group g working on call type m, are: 11 = 0.3, 22 = 0.4, 33 = 0.5, 14 = 0.27, 24 = 0.36, 25 = 0.36, 35 = 0.45, 16 = 0.27, 36 = 0.45, 17 = 0.24, 27 = 0.32, and 37 = 0.40. The costs of the agents are: c1 = 1.3, c2 = 1.4, c3 = 1.5, c4 = 1.4, c5 = 1.6, c6 = 1.5, and c7 = 1.6. A summary of the execution of the algorithm is depicted in Table 3. The meaning of the content needs no further explanation because the structure of the table is similar to Table 2. The table shows that no feasible solution is found when taking n = 21. Even for high values of the service level does not exceed 78%, while 80% is required. The best solution is obtained by setting n = 22, which resulted in a service level of exactly 80% and stang costs of 30.6. Higher values of n yielded higher costs.

4.3

Comparison to Cutting Planes Methods

In this section we make a comparison to the method from Cezik & LEcuyer [CL06]. We assume that their method yields nearly optimal results, such that we can use it as a benchmark to measure the accuracy of the Lagrange relaxation algorithm from Section 3. However, we are not able to compare the results of their paper because they dierentiate between the importance of the dierent call types. Priorities between call types are incorporated by the way that calls are selected when an agent nishes a call. Agents give the highest priority to type 1, and the higher the index of the call type the lower the priority is. In contrast, no priorities are supported in our model. An agent serves the longest waiting customer. Hence, we composed other instances with this type of call selection policy. A Call Center with Three Skills We consider a call center with 3 skills. The agent groups are S1 = {1}, S2 = {2}, S3 = {1, 2}, S4 = {1, 3}, S5 = {2, 3}, and S6 = {1, 2, 3}. The routing policy is (1 : 1 3 4 6), (2 : 2 3 5 6), and (3 : 4 5 6). The instances are completely described by Table 4, which contains all the other required parameters. The time unit is minutes and the period of the simulation runs in both methods is 160 hours. The results are presented in Table 5. The service level is in all cases close to 80% with a deviation of 2%. We read from the table that the objective values of the 2 methods are close to each other for each instance. In most cases the objective values are lower with the Lagrange relaxation, as introduced in this paper. However, the service levels are also slightly lower in these cases. Hence, we conclude that the accuracy is comparable to the cutting planes method. A Call Center with Five Skills The examples in this section concern a call center with 5 job types. Its agent groups and agent selection policy are similar to the ones used in Cezik & LEcuyer [CL06], which is 12

n 22 23 24

21

Table 3: Output of the stang algorithm (with 3 skills)

SL 78% 78% 78% 78% 78% 78% 78% 78% 78% 78% 78% 2.5e3 6.3e2 1.6e2 3.9e1 9.8e0 1.7e1 1.2e1 1.3e1 1.2e1 1.2e1 1.2e1 s (4,3,2,2,3,2,6) (4,3,2,2,3,2,6) (5,4,3,3,1,2,4) (6,5,4,3,0,2,2) (9,5,5,3,0,0,0) (8,5,4,3,0,2,0) (9,5,5,3,0,0,0) (8,5,4,3,0,2,0) (9,5,5,3,0,0,0) (8,5,4,3,0,2,0) (8,5,4,3,0,2,0) 30.6 SL 86% 86% 86% 85% 75% 80% 75% 80% 75% 80% 80% SL 91% 91% 91% 91% 78% 85% 83% 78% 83% 83% s (5,3,2,1,4,2,6) (5,3,2,2,3,2,6) (5,4,3,4,1,2,4) (6,4,3,4,0,2,4) (10,6,5,2,0,0,0) (8,4,4,5,0,2,0) (9,6,4,2,0,2,0) (10,6,5,2,0,0,0) (9,6,4,2,0,2,0) (9,6,4,2,0,2,0) 31.9 2.5e3 6.3e2 1.6e2 3.9e1 9.8e0 1.7e1 1.2e1 1.0e1 1.1e1 1.1e1 2.5e3 6.3e2 1.6e2 3.9e1 9.8e0 2.4e0 4.3e0 5.6e0 6.7e0 7.4e0 8.0e0 9.8e0

13

2.5e3 4.4e3 5.8e3 6.8e3 7.6e3 8.7e3 9.0e3 9.2e3 9.4e3 9.6e3 9.7e3 -

s (4,3,2,2,4,2,4) (4,3,2,2,4,2,4) (4,3,2,2,4,2,4) (4,3,2,2,4,2,4) (4,3,2,2,4,2,4) (4,3,2,2,4,2,4) (4,3,2,2,4,2,4) (4,3,2,2,4,2,4) (4,3,2,2,4,2,4) (4,3,2,2,4,2,4) (4,3,2,2,4,2,4) 31.0

s (4,2,1,3,4,2,8) (5,4,2,2,2,3,6) (5,3,3,4,1,2,6) (7,4,4,5,0,2,2) (10,6,4,2,0,2,0) (19,4,1,0,0,0,0) (14,5,3,2,0,0,0) (13,5,4,2,0,0,0) (11,6,5,2,0,0,0) (11,6,5,2,0,0,0) (11,6,5,2,0,0,0) (10,6,4,2,0,2,0) 33.2

SL 95% 95% 95% 93% 85% 34% 57% 57% 79% 79% 79% 85%

depicted in Table 6. In contrast, an agent serves the longest waiting customer at a service completion. The service rates are m,g = 12 for all m and g. We require the overall service level to be at least 80%. The arrival rates per hour are presented in Table 7. We apply the algorithm from Section 3. The stang costs are (K 1 (st,1 ), K 2 (st,2 ), . . .) = (0.908, 0.954, 0.908, 1, 1, 1, 1, 1, 1, 0.954, 1, 1). Note that we add the subscript t to denote the dependency on the time period. Table 8 presents the stang vectors that resulted from the stang algorithm. In order to evaluate the stang algorithm more extensively, and to have more comparisons to Cezik & LEcuyer [CL06], we consider stang costs similar to theirs: K 1 (st,1 ), K 2 (st,2 ), . . . = (1, 1, 1.1, 1.1, 1.1, 1.1, 1.2, 1.2, 1.2, 1.2, 1.3, 1.4). Table 9 presents the results of both algorithms. The content and structure of the table is similar to the previous tables. The performance measures are the objective value, the CPU time, and the number of simulations. We can read from the table that the accuracy and the computation times are both superior compared to the cutting plane method.

Concluding remarks

In this paper we presented a method for stang in multi-skill call centers. Two appealing advantages are the short computation times and the high accuracy. Although our experiments deal with call centers having at most ve skills, computations are still tractable for call centers with more skills. Another advantage is that the method is easy to implement. The results of the method can therefore be used for the shift scheduling problem in order to generate shifts and rosters. Acknowledgments Our thanks go in rst place to the referees, who gave us very useful comments and suggestions. Our thanks also go to Pierre LEcuyer, Eric Buist, Wyean Chan, and Thanos Avrimidis for letting us use their cutting planes code. Finally, we would like to thank Marco Bijvank for improving the readability of an earlier version of the manuscript.

References
[BKP06] [CL06] [Coo81] S. Bhulai, G.M. Koole, and S.A. Pot, Simple methods for shift scheduling in multi-skill call centers, Submitted, 2006. M.T. Cezik and P. LEcuyer, Stang multi-skill call centers via linear programming and simulation, To appear in Management Science, 2006. R.B. Cooper, Introduction to queueing theory, 2nd ed., North Holland, 1981.

14

[CST04]

P. Chevalier, R.A. Shumsky, and N. Tabordon, Routing and stang in large call centers with specialized and fully exible servers, Submitted to Manufacturing and Service Operations Management, 2004. P. Chevalier and N. Tabordon, Overow analysis and cross-trained servers, International Journal of Production Economics 85 (2003), 4760. P. Chevalier and J. Van den Schrieck, Optimizing the stang and routing of small size hierarchical call-centers, Working paper, 2005. G.J. Franx, G.M. Koole, and S.A. Pot, Approximating multi-skill blocking systems by hyperexponential decomposition, Performance Evaluation 63 (2006), 799824. A. Fredericks, Congestion in blocking systems-a simple approximation technique, The Bell System Technical Journal 59 (1980), no. 6, 805827.

[CT03] [CV05] [FKP06]

[Fre80]

[GKM03] N. Gans, G.M. Koole, and A. Mandelbaum, Telephone call centers: Tutorial, review, and research prospects, Manufacturing & Service Operations Management 5 (2003), 79141. [GKS01] L.V. Green, P.J. Kolesar, and J. Soares, Improving the SIPP approach for stang service systems that have cyclic demand, Operations Research 49 (2001), 549564. A.A. Jagers and E.A. van Doorn, Convexity of functions which are generalizations of the Erlang loss function and the Erlang delay function: Problem 90-8, SIAM Review 33 (1991), 281282. G.M. Koole, S.A. Pot, and J. Talim, Routing heuristics for multi-skill call centers, Proceedings of the Winter Simulation Conference, 2003, pp. 18131816. A.H. Land and A.G. Doig, An automatic method for solving discrete programming problems, Econometrica 28 (1960), 497520.

[JvD91]

[KPT03] [LD60]

[PTVF02] W.H. Press, S.A. Teukolsky, W.T. Vetterling, and B.P. Flannery, Numerical recipes in C, Cambridge University Press, 2002. [Tho93] G.M. Thompson, Accounting for the multi-period impact of service when determining employee requirements for labor scheduling, Journal of Operations Management 11 (1993), no. 3, 269287.

15

Table 4: Cases with 3 skills 16

22 0.18 0.18 0.18 0.18 0.18 0.15 0.15 0.18 0.15 0.15 31 0.19 0.19 0.19 0.19 0.14 0.19 0.14 0.14 0.19 0.14 52 0.17 0.17 0.17 0.17 0.17 0.14 0.14 0.17 0.14 0.14 53 0.16 0.16 0.16 0.16 0.16 0.16 0.16 0.16 0.16 0.16 61 0.18 0.18 0.18 0.18 0.13 0.18 0.13 0.13 0.18 0.13 62 0.16 0.16 0.16 0.16 0.16 0.13 0.13 0.16 0.13 0.13 63 0.15 0.15 0.15 0.15 0.15 0.15 0.15 0.15 0.15 0.15 c1 1.0 1.3 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0

ID 1 2 3 4 5 6 7 8 9 10

1 1.0 1.0 1.0 1.0 1.0 1.0 1.0 2.0 2.0 2.0

2 1.5 1.5 1.5 1.5 1.5 1.5 1.5 1.5 1.5 1.5

3 2.0 2.0 2.0 2.0 2.0 2.0 2.0 2.0 2.0 2.0

11 0.20 0.20 0.20 0.20 0.15 0.20 0.15 0.15 0.20 0.15

parameters 32 41 43 0.17 0.19 0.16 0.17 0.19 0.16 0.17 0.19 0.16 0.17 0.19 0.16 0.17 0.14 0.16 0.14 0.19 0.16 0.14 0.14 0.16 0.17 0.14 0.16 0.14 0.19 0.16 0.14 0.14 0.16

c2 1.0 1.0 1.0 1.2 1.0 1.0 1.0 1.0 1.0 1.0

c3 1.1 1.4 1.1 1.3 1.1 1.1 1.1 1.1 1.1 1.1

c4 1.1 1.4 1.3 1.3 1.1 1.1 1.1 1.1 1.1 1.1

c5 1.1 1.1 1.3 1.3 1.1 1.1 1.1 1.1 1.1 1.1

c6 1.2 1.5 1.4 1.4 1.2 1.2 1.2 1.2 1.2 1.2

g 1 2 3 4 5 6 f CPU #sim f CPU #sim

1 6 10 0 10 7 0 34.6 3 31 34.8 16 50

2 5 10 0 5 11 2 38.6 3 32 38.5 14 44

3 5 8 2 5 5 8 37.8 3 30 38.8 12 38

instance IDs 4 5 6 7 Lagrange relaxation 7 8 6 8 8 9 12 12 0 0 0 0 8 10 11 11 8 8 6 6 2 0 0 0 40.2 4 40 36.8 2 18 Cutting 43.4 37.1 25 22 50 56 36.7 38.7 2 3 19 21 planes 37.6 38.0 14 14 32 45

8 15 9 0 11 7 0 43.8 4 34 44.8 17 43

9 11 9 1 13 6 0 42.0 3 22 42.5 21 55

10 14 10 1 12 7 0 46.0 2 17 47.0 26 44

Table 5: Results with 3 skills

m 1 2 3 4 5

01 x

02

03 x x

04 x x

agent group 05 06 07 x x x x x x x

g 08 x x

09 x x

10

x x x

11 x x x x

12 x x x x x

Table 6: Skills and policy of the rst example

m 1 2 3 4 5

1 440 140 440 340 340

2 440 240 340 390 365

3 440 340 440 440 390

4 440 440 340 490 415

5 440 540 440 540 440

6 440 490 340 540 465

time t 7 8 440 440 440 440 440 340 515 490 490 515

9 440 490 440 465 540

10 440 540 340 440 515

11 440 440 440 415 490

12 440 340 340 390 465

13 440 240 440 365 440

14 440 140 340 340 415

Table 7: Arrival rates per hour of example with 5 skills

17

time t 2 3 4 5 6 10 11 12 13 14

Table 8: Stang vectors of example with 5 skills

18
148.8 9 33 150.2 189 114 173.2 141 78 177.8 205 142 201.0 206 108 171.1 12 35 176.2 15 45 198.6 9 23 188.4 13 34 192.7 13 35 Cutting 190.6 196.2 147 131 76 63 184.6 197.3 14 11 40 29 planes 187.8 198.9 257 155 103 76

1 2 3 4 5 6 7 8 9 10 11 12 0 0 50 0 0 0 0 0 0 79 2 18 188.9 15 41 190.3 167 89 185.1 15 40 186.8 278 143 165.0 12 36 167.1 162 130 0 0 59 0 0 0 0 0 0 98 2 22 0 0 71 0 0 0 0 0 0 94 0 22 0 0 80 0 0 0 0 0 0 110 1 20 0 0 72 0 0 0 0 0 0 98 5 23 0 0 75 0 0 0 0 0 0 110 3 9 0 0 62 0 0 0 0 0 0 94 1 18

0 0 45 0 0 0 0 0 0 84 1 21

7 8 9 Lagrange relaxation 0 0 0 0 0 0 0 0 81 75 71 79 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 112 119 106 119 0 2 0 3 8 9 19 9 0 0 52 0 0 0 0 0 0 99 1 18 160.7 14 44 161.7 105 87

0 0 48 0 0 0 0 0 0 90 3 8 140.5 11 39 141.8 95 88

f CPU #sim

143.0 11 41

f CPU #sim

145.7 130 89

time t 2 3 4 5 6 10 11 12 13 14

Table 9: Stang vectors of example with 5 skills

19
175.6 14 50 177.3 234 185 203.3 414 214 210.1 184 121 236.7 414 242 200.1 12 37 207.6 13 37 233.6 16 40 223.3 19 50 226.7 15 40 Cutting 225.3 229.8 420 329 255 203 217.5 231.8 17 13 49 36 planes 220.4 234.3 300 461 158 239

1 2 3 4 5 6 7 8 9 10 11 12 31 21 4 1 34 21 0 31 0 17 0 0 223.4 15 41 226.6 285 201 217.3 17 46 219.9 426 263 193.5 12 38 198.2 333 222 30 31 16 0 37 20 0 31 0 18 0 0 32 22 11 0 41 32 0 33 0 18 0 0 22 24 7 1 52 44 1 43 0 17 0 0 30 20 16 0 37 37 0 43 0 19 0 0 31 31 22 0 34 23 0 38 1 18 0 0 28 20 15 1 33 20 0 39 1 18 0 0

31 31 6 1 28 10 0 26 0 19 0 0

7 8 9 Lagrange relaxation 30 25 27 29 19 25 18 28 19 18 14 6 0 1 1 1 43 45 42 40 31 29 30 41 0 0 0 0 38 42 45 46 0 0 0 0 22 20 19 19 0 0 0 0 0 0 0 0 29 28 16 0 28 13 0 33 1 23 0 0 188.1 15 45 190.3 336 174

36 28 4 0 30 11 0 28 1 15 0 0 166.3 14 50 167.7 220 148

f CPU #sim

165.5 13 50

f CPU #sim

168.9 212 210