anchor.diff:      ServerInitState = InitState,
       Server = evaluator_start("server", ServerSeq, ServerInitState),
   
  -    i("start client evaluator"),
  +    i("start client evaluator(s)"),
       ClientInitState = InitState,
  -    Client = evaluator_start("client", ClientSeq, ClientInitState),
  +    Client1 = evaluator_start("client-1", ClientSeq, ClientInitState),
  +    Client2 = evaluator_start("client-2", ClientSeq, ClientInitState),
  +    Client3 = evaluator_start("client-3", ClientSeq, ClientInitState),
   
       i("start 'tester' evaluator"),
  -    TesterInitState = #{host   => local_host(),
  -                        server => Server#ev.pid,
  -                        client => Client#ev.pid},
  +    TesterInitState = #{host    => local_host(),
  +                        server  => Server#ev.pid,
  +                        client1 => Client1#ev.pid,
  +                        client2 => Client2#ev.pid,
  +                        client3 => Client3#ev.pid},
       Tester = evaluator_start("tester", TesterSeq, TesterInitState),
   
       i("await evaluator"),
  -    ok = await_evaluator_finish([Server, Client, Tester]).
  +    ok = await_evaluator_finish([Server,
  +                                 Client1, Client2, Client3,
  +                                 Tester]).
   
   
   start_node(Host, NodeName) ->
  -    case do_start_node(Host, NodeName) of
  +    UniqueNodeName = f("~w_~w", [NodeName, erlang:unique_integer([positive])]),
  +    case do_start_node(Host, UniqueNodeName) of
           {ok, _} = OK ->
               OK;
  -        {error, already_started, Node} ->
  -            stop_node(Node), % We don't know in what state it is, so kill i t
  -            do_start_node(Host, NodeName);
  -        ERROR ->
  -            ERROR
  +        {error, Reason, _} ->
  +            {error, Reason}
       end.
   
  -do_start_node(Host, NodeName) ->
  +do_start_node(Host, NodeName) when is_list(NodeName) ->
  +    do_start_node(Host, list_to_atom(NodeName));
  +do_start_node(Host, NodeName) when is_atom(NodeName) ->
       Dir   = filename:dirname(code:which(?MODULE)),
       Flags = "-pa " ++ Dir,
       Opts  = [{monitor_master, true}, {erl_flags, Flags}],
  
positive.code:                            {ok, State#{server_sa => ServerSA}}
                     end},
  
           %% Start the client
           #{desc => "order client start",
             cmd  => fun(#{client      := Pid, 
                           client_node := Node,
                           server_sa   := ServerSA} = _State) ->
                             ev_start(Pid, {Node, ServerSA}),
                             ok
                     end},
           #{desc => "await client ready (init)",
             cmd  => fun(#{client := Pid} = _State) ->
                             ok = ev_await_ready(Pid, client, init)
                     end},
  
  
negative.code: %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  sc_rc_receive_response_tcp(InitState) ->
      %% Each connection are handled by handler processes.
      %% These are created (on the fly) and handled internally 
      %% by the server!
      ServerSeq =
          [
           %% *** Init part ***
  