E' possibile sostituire i dirigenti con un algoritmo? (1)

Osservando attentamente, per anni, il lavoro di diversi dirigenti (nel settore ICT in Italia, ma credo si possa generalizzare ben oltre questo contesto) ho riscontrato un modo di lavorare abbastanza omogeneo tra le diverse persone. Quasi come se tutti i dirigenti che ho incontrato avessero seguito lo stesso corso di "management"! Forse, semplicemente, i comportamenti da me notati sono quelli che più facilmente permettono di ottenere un avanzamento nella carriera. Credo che il modo con cui le organizzazioni selezionano il personale da promuovere alla carriera direttiva sia una delle maggiori cause della loro inefficienza.

Già dopo poco tempo di osservazione si è insinuato in me il dubbio... E' possibile sostituire questo tipo di dirigenti con un algoritmo? 

Lasciando l'analisi degli effetti di questo approccio a un prossimo post, di seguito provo a riportare i lineamenti dell'algoritmo che vorrei provare. In futuro penso di creare un progetto open source per implementare l'algoritmo (si cercano collaboratori). Il software si potrebbe validare in azienda utilizzando qualche dirigente reale come oracolo.

Il dirigente è modellato come un agent: reagisce a richieste che gli vengono sottoposte dall'esterno.

Request è la richiesta che perviene al dirigente. Una richiesta è caratterizzata da un mittente (from), una domanda a cui rispondere (question) e una data di scadenza opzionale (due_date).

 L'elaborazione delle richieste avviene nel metodo onRequest dove si innesca un ciclo in cui ciascuna iterazione si compone di due fasi (round). Durante la prima fase sono raccolte le opinioni dai propri collaboratori; mentre durante la seconda il dirigente cerca di raggiungere un consenso.

Il ciclo termina quando viene raggiunto il consenso ovvero quando il tempo a disposizione si esaurisce.

In grassetto le funzioni che saranno analizzate in un prossimo articolo.

Request : {
  from : senderDomain
  question : string;
  due_date : date;
}

onRequest(initial_req : Request) { 
  try { 
    due_date = due_date != null ? 
             initial_req.due_date : determine_due_date(initial_req);

    priority = prioritize_request(initial_req.from, due_date);
 
    first_iteration = true;
     
    repeat {
      // first round : ask for candidate solutions
      if (first_iteration) {
        interpreted_req1 = new Request();
        interpreted_question = randomized_summarization(initial_req);
        interpreted_req1.question = ask_for_candidate_solution();
        interpreted_req1.priority = priority;
        interpreted_req1.due_date = calculate_due_date(priority, due_date);
      } else {
        interpreted_req1 = new Request();
        interpreted_req1.question = ask_for_new_candidate_solutions(response, most_frequent_res1);
        interpreted_req1.priority = priority;
        interpreted_req1.due_date = calculate_due_date(priority, due_date);
      }
         
      responses1 = send_request_and_collect_responses(team, interpreted_req1);
      most_frequent_res1 = randomized_mode_scoring(responses1);
         
      // second round : ask to to vote for the most common solution
      interpreted_req2 = new Request();
      interpreted_req2.question = proposal_with_default_on_due_date(most_frequent_res1);
      interpreted_req2.priority = priority;
      interpreted_req2.due_date = calculate_due_date(priority, due_date);
         
      responses2 = send_request_and_collect_responses(team, interpreted_req2);
      most_frequent_res2 = randomized_mode_scoring(responses2);
         
      // loop until convergence
      has_converged = most_frequent_res2 == YES;
    } until (has_converged);
     
   solution = most_frequent_res1;
  } catch (timeout) {
    // no convergence in allowed time-frame
    solution = randomized_select(most_frequent_res1, responses1);
  }
 
  reply(initial_req.from, team, solution); 
}