diff --git a/akka-actor-tests/src/test/java/akka/actor/JavaAPI.java b/akka-actor-tests/src/test/java/akka/actor/JavaAPI.java
index 5bf4e5b5c8..5a4d415fb5 100644
--- a/akka-actor-tests/src/test/java/akka/actor/JavaAPI.java
+++ b/akka-actor-tests/src/test/java/akka/actor/JavaAPI.java
@@ -3,7 +3,7 @@ package akka.actor;
 import akka.japi.Creator;
 import org.junit.Test;
 import akka.actor.Actors;
-import akka.cluster.RemoteSupport;
+import akka.remote.RemoteSupport;
 import static org.junit.Assert.*;
 
 public class JavaAPI {
diff --git a/akka-actor-tests/src/test/scala/akka/actor/ClusterSpec.scala b/akka-actor-tests/src/test/scala/akka/actor/ClusterSpec.scala
index 42486dd4cc..d33a6792e5 100644
--- a/akka-actor-tests/src/test/scala/akka/actor/ClusterSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/actor/ClusterSpec.scala
@@ -13,16 +13,14 @@ class ClusterSpec extends WordSpec with MustMatchers {
       //akka.cluster
       getString("akka.cluster.name") must equal(Some("test-cluster"))
       getString("akka.cluster.zookeeper-server-addresses") must equal(Some("localhost:2181"))
-      getInt("akka.cluster.server.port") must equal(Some(2552))
+      getInt("akka.remote.server.port") must equal(Some(2552))
       getInt("akka.cluster.max-time-to-wait-until-connected") must equal(Some(30))
       getInt("akka.cluster.session-timeout") must equal(Some(60))
       getInt("akka.cluster.connection-timeout") must equal(Some(60))
-      getBool("akka.cluster.use-compression") must equal(Some(false))
-      getInt("akka.cluster.connection-timeout") must equal(Some(60))
-      getInt("akka.cluster.remote-daemon-ack-timeout") must equal(Some(30))
+      getInt("akka.remote.remote-daemon-ack-timeout") must equal(Some(30))
       getBool("akka.cluster.include-ref-node-in-replica-set") must equal(Some(true))
-      getString("akka.cluster.layer") must equal(Some("akka.cluster.netty.NettyRemoteSupport"))
-      getString("akka.cluster.secure-cookie") must equal(Some(""))
+      getString("akka.remote.layer") must equal(Some("akka.cluster.netty.NettyRemoteSupport"))
+      getString("akka.remote.secure-cookie") must equal(Some(""))
       getString("akka.cluster.log-directory") must equal(Some("_akka_cluster"))
 
       //akka.cluster.replication
@@ -33,25 +31,25 @@ class ClusterSpec extends WordSpec with MustMatchers {
       getInt("akka.cluster.replication.snapshot-frequency") must equal(Some(1000))
       getInt("akka.cluster.replication.timeout") must equal(Some(30))
 
-      //akka.cluster.server
-      getInt("akka.cluster.server.port") must equal(Some(2552))
-      getInt("akka.cluster.server.message-frame-size") must equal(Some(1048576))
-      getInt("akka.cluster.server.connection-timeout") must equal(Some(120))
-      getBool("akka.cluster.server.require-cookie") must equal(Some(false))
-      getBool("akka.cluster.server.untrusted-mode") must equal(Some(false))
-      getInt("akka.cluster.server.backlog") must equal(Some(4096))
-      getInt("akka.cluster.server.execution-pool-keepalive") must equal(Some(60))
-      getInt("akka.cluster.server.execution-pool-size") must equal(Some(16))
-      getInt("akka.cluster.server.max-channel-memory-size") must equal(Some(0))
-      getInt("akka.cluster.server.max-total-memory-size") must equal(Some(0))
+      //akka.remote.server
+      getInt("akka.remote.server.port") must equal(Some(2552))
+      getInt("akka.remote.server.message-frame-size") must equal(Some(1048576))
+      getInt("akka.remote.server.connection-timeout") must equal(Some(120))
+      getBool("akka.remote.server.require-cookie") must equal(Some(false))
+      getBool("akka.remote.server.untrusted-mode") must equal(Some(false))
+      getInt("akka.remote.server.backlog") must equal(Some(4096))
+      getInt("akka.remote.server.execution-pool-keepalive") must equal(Some(60))
+      getInt("akka.remote.server.execution-pool-size") must equal(Some(16))
+      getInt("akka.remote.server.max-channel-memory-size") must equal(Some(0))
+      getInt("akka.remote.server.max-total-memory-size") must equal(Some(0))
 
-      //akka.cluster.client
-      getBool("akka.cluster.client.buffering.retry-message-send-on-failure") must equal(Some(false))
-      getInt("akka.cluster.client.buffering.capacity") must equal(Some(-1))
-      getInt("akka.cluster.client.reconnect-delay") must equal(Some(5))
-      getInt("akka.cluster.client.read-timeout") must equal(Some(3600))
-      getInt("akka.cluster.client.reap-futures-delay") must equal(Some(5))
-      getInt("akka.cluster.client.reconnection-time-window") must equal(Some(600))
+      //akka.remote.client
+      getBool("akka.remote.client.buffering.retry-message-send-on-failure") must equal(Some(false))
+      getInt("akka.remote.client.buffering.capacity") must equal(Some(-1))
+      getInt("akka.remote.client.reconnect-delay") must equal(Some(5))
+      getInt("akka.remote.client.read-timeout") must equal(Some(3600))
+      getInt("akka.remote.client.reap-futures-delay") must equal(Some(5))
+      getInt("akka.remote.client.reconnection-time-window") must equal(Some(600))
     }
   }
 }
diff --git a/akka-actor-tests/src/test/scala/akka/actor/DeployerSpec.scala b/akka-actor-tests/src/test/scala/akka/actor/DeployerSpec.scala
index 1edfea0055..388ce4bba4 100644
--- a/akka-actor-tests/src/test/scala/akka/actor/DeployerSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/actor/DeployerSpec.scala
@@ -20,13 +20,14 @@ class DeployerSpec extends WordSpec with MustMatchers {
           "service-ping",
           None,
           LeastCPU,
-          RemoveConnectionOnFirstFailureRemoteFailureDetector,
-          Clustered(
-            List(Node("node1")),
-            new ReplicationFactor(3),
-            Replication(
-              TransactionLog,
-              WriteThrough)))))
+          BannagePeriodFailureDetector(10),
+          RemoteScope("localhost", 2552))))
+      // ClusterScope(
+      //   List(Node("node1")),
+      //   new ReplicationFactor(3),
+      //   Replication(
+      //     TransactionLog,
+      //     WriteThrough)))))
     }
   }
 }
diff --git a/akka-actor-tests/src/test/scala/akka/config/ConfigSpec.scala b/akka-actor-tests/src/test/scala/akka/config/ConfigSpec.scala
index 449212d4f1..4a9198422b 100644
--- a/akka-actor-tests/src/test/scala/akka/config/ConfigSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/config/ConfigSpec.scala
@@ -39,8 +39,8 @@ class ConfigSpec extends WordSpec with MustMatchers {
       getInt("akka.actor.throughput") must equal(Some(5))
       getInt("akka.actor.throughput-deadline-time") must equal(Some(-1))
 
-      getString("akka.cluster.layer") must equal(Some("akka.cluster.netty.NettyRemoteSupport"))
-      getInt("akka.cluster.server.port") must equal(Some(2552))
+      getString("akka.remote.layer") must equal(Some("akka.cluster.netty.NettyRemoteSupport"))
+      getInt("akka.remote.server.port") must equal(Some(2552))
     }
   }
 }
diff --git a/akka-actor/src/main/java/akka/actor/Actors.java b/akka-actor/src/main/java/akka/actor/Actors.java
index 79a5ac241a..35b99b5d13 100644
--- a/akka-actor/src/main/java/akka/actor/Actors.java
+++ b/akka-actor/src/main/java/akka/actor/Actors.java
@@ -1,7 +1,11 @@
+/**
+ * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
+
 package akka.actor;
 
 import akka.japi.Creator;
-import akka.cluster.RemoteSupport;
+import akka.remote.RemoteSupport;
 
 import com.eaio.uuid.UUID;
 
diff --git a/akka-actor/src/main/java/akka/event/JavaEventHandler.java b/akka-actor/src/main/java/akka/event/JavaEventHandler.java
index 7e6e2d4143..608877e24a 100644
--- a/akka-actor/src/main/java/akka/event/JavaEventHandler.java
+++ b/akka-actor/src/main/java/akka/event/JavaEventHandler.java
@@ -1,12 +1,14 @@
-package akka.event;
+/**
+ * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
 
+package akka.event;
 
 import akka.actor.ActorRef;
 
 /**
  * Java API for Akka EventHandler
  */
-
 public class JavaEventHandler {
 
 
diff --git a/akka-actor/src/main/java/akka/routing/RouterFactory.java b/akka-actor/src/main/java/akka/routing/RouterFactory.java
index ad4d719930..65ce7a10c6 100644
--- a/akka-actor/src/main/java/akka/routing/RouterFactory.java
+++ b/akka-actor/src/main/java/akka/routing/RouterFactory.java
@@ -1,3 +1,7 @@
+/**
+ * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
+
 package akka.routing;
 
 /**
diff --git a/akka-actor/src/main/scala/akka/actor/Actor.scala b/akka-actor/src/main/scala/akka/actor/Actor.scala
index 02cfe6c14b..9b40954a4b 100644
--- a/akka-actor/src/main/scala/akka/actor/Actor.scala
+++ b/akka-actor/src/main/scala/akka/actor/Actor.scala
@@ -11,7 +11,7 @@ import akka.routing._
 import Config._
 import akka.util.{ ReflectiveAccess, Duration }
 import ReflectiveAccess._
-import akka.cluster.RemoteSupport
+import akka.remote.RemoteSupport
 import akka.cluster.ClusterNode
 import akka.japi.{ Creator, Procedure }
 import akka.serialization.{ Serializer, Serialization }
@@ -187,13 +187,13 @@ object Actor {
   /**
    * Handle to the ClusterNode. API for the cluster client.
    */
-  lazy val cluster: ClusterNode = ClusterModule.node
+  //  lazy val cluster: ClusterNode = ClusterModule.node
 
   /**
    * Handle to the RemoteSupport. API for the remote client/server.
    * Only for internal use.
    */
-  private[akka] lazy val remote: RemoteSupport = cluster.remoteService
+  private[akka] lazy val remote: RemoteSupport = RemoteModule.remoteService.server
 
   /**
    * This decorator adds invocation logging to a Receive function.
@@ -241,10 +241,6 @@ object Actor {
    *   actor ! message
    *   actor.stop()
    * </pre>
-   * You can create and start the actor in one statement like this:
-   * <pre>
-   *   val actor = actorOf[MyActor]
-   * </pre>
    */
   def actorOf[T <: Actor: Manifest](address: String): ActorRef =
     actorOf(manifest[T].erasure.asInstanceOf[Class[_ <: Actor]], address)
@@ -258,10 +254,6 @@ object Actor {
    *   actor ! message
    *   actor.stop
    * </pre>
-   * You can create and start the actor in one statement like this:
-   * <pre>
-   *   val actor = actorOf[MyActor]
-   * </pre>
    */
   def actorOf[T <: Actor: Manifest]: ActorRef =
     actorOf(manifest[T].erasure.asInstanceOf[Class[_ <: Actor]], new UUID().toString)
@@ -275,10 +267,6 @@ object Actor {
    *   actor ! message
    *   actor.stop()
    * </pre>
-   * You can create and start the actor in one statement like this:
-   * <pre>
-   *   val actor = actorOf(classOf[MyActor])
-   * </pre>
    */
   def actorOf[T <: Actor](clazz: Class[T]): ActorRef = actorOf(clazz, new UUID().toString)
 
@@ -290,10 +278,6 @@ object Actor {
    *   actor ! message
    *   actor.stop
    * </pre>
-   * You can create and start the actor in one statement like this:
-   * <pre>
-   *   val actor = actorOf(classOf[MyActor])
-   * </pre>
    */
   def actorOf[T <: Actor](clazz: Class[T], address: String): ActorRef = actorOf(Props(clazz), address)
 
@@ -309,10 +293,6 @@ object Actor {
    *   actor ! message
    *   actor.stop()
    * </pre>
-   * You can create and start the actor in one statement like this:
-   * <pre>
-   *   val actor = actorOf(new MyActor)
-   * </pre>
    */
   def actorOf[T <: Actor](factory: ⇒ T): ActorRef = actorOf(factory, newUuid().toString)
 
@@ -328,10 +308,6 @@ object Actor {
    *   actor ! message
    *   actor.stop
    * </pre>
-   * You can create and start the actor in one statement like this:
-   * <pre>
-   *   val actor = actorOf(new MyActor)
-   * </pre>
    */
   def actorOf[T <: Actor](creator: ⇒ T, address: String): ActorRef = actorOf(Props(creator), address)
 
diff --git a/akka-actor/src/main/scala/akka/actor/ActorRef.scala b/akka-actor/src/main/scala/akka/actor/ActorRef.scala
index f635f91ad5..bbffb6c0bc 100644
--- a/akka-actor/src/main/scala/akka/actor/ActorRef.scala
+++ b/akka-actor/src/main/scala/akka/actor/ActorRef.scala
@@ -341,7 +341,7 @@ private[akka] case class RemoteActorRef private[akka] (
 
   def isShutdown: Boolean = !running
 
-  ClusterModule.ensureEnabled()
+  RemoteModule.ensureEnabled()
 
   protected[akka] override def timeout: Long = _timeout
 
diff --git a/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala b/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala
index bb07051de5..1f920252da 100644
--- a/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala
+++ b/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala
@@ -37,10 +37,13 @@ private[akka] class ActorRefProviders(
 
   import ActorRefProvider._
 
-  def register(provider: ActorRefProvider, providerType: ProviderType) = providerType match {
-    case LocalProvider   ⇒ localProvider = Option(provider)
-    case RemoteProvider  ⇒ remoteProvider = Option(provider)
-    case ClusterProvider ⇒ clusterProvider = Option(provider)
+  def register(providerType: ProviderType, provider: ActorRefProvider) = {
+    EventHandler.info(this, "Registering ActorRefProvider [%s]".format(provider.getClass.getName))
+    providerType match {
+      case LocalProvider   ⇒ localProvider = Option(provider)
+      case RemoteProvider  ⇒ remoteProvider = Option(provider)
+      case ClusterProvider ⇒ clusterProvider = Option(provider)
+    }
   }
 
   //FIXME Implement support for configuring by deployment ID etc
@@ -64,8 +67,8 @@ private[akka] class ActorRefProviders(
     actorOf(props, address, providersAsList).getOrElse(throw new ActorRefProviderException(
       "Actor [" +
         address +
-        "] could not be created or found in any of the registered ActorRefProvider's [" +
-        providersAsList.mkString(", ") + "]"))
+        "] could not be found in or created by any of the registered 'ActorRefProvider's [" +
+        providersAsList.map(_.getClass.getName).mkString(", ") + "]"))
   }
 
   def findActorRef(address: String): Option[ActorRef] = {
@@ -115,7 +118,7 @@ class LocalActorRefProvider extends ActorRefProvider {
         //WARNING FIXME HUGE RACE CONDITION THAT NEEDS GETTING FIXED
         Deployer.lookupDeploymentFor(address) match { // see if the deployment already exists, if so use it, if not create actor
 
-          case Some(Deploy(_, _, router, _, Local)) ⇒
+          case Some(Deploy(_, _, router, _, LocalScope)) ⇒
             // FIXME create RoutedActorRef if 'router' is specified
             Some(new LocalActorRef(props, address, systemService)) // create a local actor
 
@@ -129,7 +132,7 @@ class LocalActorRefProvider extends ActorRefProvider {
 
 //   def actorOf(props: Props, address: String): Option[ActorRef] = {
 //     deploy match {
-//       case Deploy(configAddress, recipe, router, failureDetector, Clustered(preferredHomeNodes, replicas, replication)) ⇒
+//       case Deploy(configAddress, recipe, router, failureDetector, Cluster(preferredHomeNodes, replicas, replication)) ⇒
 
 //         ClusterModule.ensureEnabled()
 
diff --git a/akka-actor/src/main/scala/akka/actor/Deployer.scala b/akka-actor/src/main/scala/akka/actor/Deployer.scala
index b8b201585c..32718c7225 100644
--- a/akka-actor/src/main/scala/akka/actor/Deployer.scala
+++ b/akka-actor/src/main/scala/akka/actor/Deployer.scala
@@ -46,7 +46,7 @@ object Deployer extends ActorDeployer {
   def deploy(deployment: Deploy): Unit = instance.deploy(deployment)
 
   def isLocal(deployment: Deploy): Boolean = deployment match {
-    case Deploy(_, _, _, _, Local) | Deploy(_, _, _, _, _: Local) ⇒ true
+    case Deploy(_, _, _, _, LocalScope) | Deploy(_, _, _, _, _: LocalScope) ⇒ true
     case _ ⇒ false
   }
 
@@ -122,7 +122,7 @@ object Deployer extends ActorDeployer {
     val addressPath = "akka.actor.deployment." + address
     configuration.getSection(addressPath) match {
       case None ⇒
-        Some(Deploy(address, None, Direct, RemoveConnectionOnFirstFailureLocalFailureDetector, Local))
+        Some(Deploy(address, None, Direct, RemoveConnectionOnFirstFailureLocalFailureDetector, LocalScope))
 
       case Some(addressConfig) ⇒
 
@@ -145,109 +145,161 @@ object Deployer extends ActorDeployer {
         }
 
         // --------------------------------
-        // akka.actor.deployment.<address>.failure-detector
+        // akka.actor.deployment.<address>.failure-detector.xxx
         // --------------------------------
-        val failureDetector: FailureDetector = addressConfig.getString("failure-detector", "remove-connection-on-first-local-failure") match {
-          case "remove-connection-on-first-local-failure"  ⇒ RemoveConnectionOnFirstFailureLocalFailureDetector
-          case "remove-connection-on-first-remote-failure" ⇒ RemoveConnectionOnFirstFailureRemoteFailureDetector
-          case customFailureDetectorClassName              ⇒ CustomFailureDetector(customFailureDetectorClassName)
+        val failureDetectorOption: Option[FailureDetector] = addressConfig.getSection("failure-detector") match {
+          case Some(failureDetectorConfig) ⇒
+            failureDetectorConfig.keys.toList match {
+              case Nil ⇒ None
+              case detector :: Nil ⇒
+                detector match {
+                  case "remove-connection-on-first-local-failure" ⇒
+                    Some(RemoveConnectionOnFirstFailureLocalFailureDetector)
+
+                  case "remove-connection-on-first-failure" ⇒
+                    Some(RemoveConnectionOnFirstFailureFailureDetector)
+
+                  case "bannage-period" ⇒
+                    failureDetectorConfig.getSection("bannage-period") map { section ⇒
+                      BannagePeriodFailureDetector(section.getInt("time-to-ban", 10))
+                    }
+
+                  case "custom" ⇒
+                    failureDetectorConfig.getSection("custom") map { section ⇒
+                      val implementationClass = section.getString("class").getOrElse(throw new ConfigurationException(
+                        "Configuration for [" + addressPath +
+                          "failure-detector.custom] must have a 'class' element with the fully qualified name of the failure detector class"))
+                      CustomFailureDetector(implementationClass)
+                    }
+
+                  case _ ⇒ None
+                }
+              case detectors ⇒
+                throw new ConfigurationException(
+                  "Configuration for [" + addressPath +
+                    "failure-detector] can not have multiple sections - found [" + detectors.mkString(", ") + "]")
+            }
+          case None ⇒ None
         }
+        val failureDetector = failureDetectorOption getOrElse { BannagePeriodFailureDetector(10) } // fall back to default failure detector
 
+        // --------------------------------
+        // akka.actor.deployment.<address>.create-as
+        // --------------------------------
         val recipe: Option[ActorRecipe] = addressConfig.getSection("create-as") map { section ⇒
-          val implementationClass = section.getString("implementation-class") match {
+          val implementationClass = section.getString("class") match {
             case Some(impl) ⇒
-              getClassFor[Actor](impl).fold(e ⇒ throw new ConfigurationException("Config option [" + addressPath + ".create-as.implementation-class] load failed", e), identity)
-            case None ⇒ throw new ConfigurationException("Config option [" + addressPath + ".create-as.implementation-class] is missing")
+              getClassFor[Actor](impl).fold(e ⇒ throw new ConfigurationException(
+                "Config option [" + addressPath + ".create-as.class] load failed", e), identity)
+            case None ⇒
+              throw new ConfigurationException(
+                "Config option [" + addressPath + ".create-as.class] is missing, need the fully qualified name of the class")
           }
-
           ActorRecipe(implementationClass)
         }
 
         // --------------------------------
-        // akka.actor.deployment.<address>.cluster
+        // akka.actor.deployment.<address>.remote
         // --------------------------------
-        addressConfig.getSection("cluster") match {
-          case None ⇒
-            Some(Deploy(address, recipe, router, RemoveConnectionOnFirstFailureLocalFailureDetector, Local)) // deploy locally
+        addressConfig.getSection("remote") match {
+          case Some(remoteConfig) ⇒ // we have a 'remote' config section
 
-          case Some(clusterConfig) ⇒
+            if (addressConfig.getSection("cluster").isDefined) throw new ConfigurationException(
+              "Configuration for deployment ID [" + address + "] can not have both 'remote' and 'cluster' sections.")
+
+            val hostname = remoteConfig.getString("hostname", "localhost")
+            val port = remoteConfig.getInt("port", 2552)
+
+            Some(Deploy(address, recipe, router, failureDetector, RemoteScope(hostname, port)))
+
+          case None ⇒ // check for 'cluster' config section
 
             // --------------------------------
-            // akka.actor.deployment.<address>.cluster.preferred-nodes
+            // akka.actor.deployment.<address>.cluster
             // --------------------------------
+            addressConfig.getSection("cluster") match {
+              case None ⇒
+                Some(Deploy(address, recipe, router, RemoveConnectionOnFirstFailureLocalFailureDetector, LocalScope)) // deploy locally
 
-            val preferredNodes = clusterConfig.getList("preferred-nodes") match {
-              case Nil ⇒ Nil
-              case homes ⇒
-                def raiseHomeConfigError() = throw new ConfigurationException(
-                  "Config option [" + addressPath +
-                    ".cluster.preferred-nodes] needs to be a list with elements on format\n'host:<hostname>', 'ip:<ip address>' or 'node:<node name>', was [" +
-                    homes + "]")
+              case Some(clusterConfig) ⇒
 
-                homes map { home ⇒
-                  if (!(home.startsWith("host:") || home.startsWith("node:") || home.startsWith("ip:"))) raiseHomeConfigError()
+                // --------------------------------
+                // akka.actor.deployment.<address>.cluster.preferred-nodes
+                // --------------------------------
 
-                  val tokenizer = new java.util.StringTokenizer(home, ":")
-                  val protocol = tokenizer.nextElement
-                  val address = tokenizer.nextElement.asInstanceOf[String]
+                val preferredNodes = clusterConfig.getList("preferred-nodes") match {
+                  case Nil ⇒ Nil
+                  case homes ⇒
+                    def raiseHomeConfigError() = throw new ConfigurationException(
+                      "Config option [" + addressPath +
+                        ".cluster.preferred-nodes] needs to be a list with elements on format\n'host:<hostname>', 'ip:<ip address>' or 'node:<node name>', was [" +
+                        homes + "]")
 
-                  protocol match {
-                    //case "host" ⇒ Host(address)
-                    case "node" ⇒ Node(address)
-                    //case "ip"   ⇒ IP(address)
-                    case _      ⇒ raiseHomeConfigError()
-                  }
-                }
-            }
+                    homes map { home ⇒
+                      if (!(home.startsWith("host:") || home.startsWith("node:") || home.startsWith("ip:"))) raiseHomeConfigError()
 
-            // --------------------------------
-            // akka.actor.deployment.<address>.cluster.replicas
-            // --------------------------------
-            val replicationFactor = {
-              if (router == Direct) new ReplicationFactor(1)
-              else {
-                clusterConfig.getAny("replication-factor", "0") match {
-                  case "auto" ⇒ AutoReplicationFactor
-                  case "0"    ⇒ ZeroReplicationFactor
-                  case nrOfReplicas: String ⇒
-                    try {
-                      new ReplicationFactor(nrOfReplicas.toInt)
-                    } catch {
-                      case e: Exception ⇒
-                        throw new ConfigurationException(
-                          "Config option [" + addressPath +
-                            ".cluster.replicas] needs to be either [\"auto\"] or [0-N] - was [" +
-                            nrOfReplicas + "]")
+                      val tokenizer = new java.util.StringTokenizer(home, ":")
+                      val protocol = tokenizer.nextElement
+                      val address = tokenizer.nextElement.asInstanceOf[String]
+
+                      protocol match {
+                        //case "host" ⇒ Host(address)
+                        case "node" ⇒ Node(address)
+                        //case "ip"   ⇒ IP(address)
+                        case _      ⇒ raiseHomeConfigError()
+                      }
                     }
                 }
-              }
-            }
 
-            // --------------------------------
-            // akka.actor.deployment.<address>.cluster.replication
-            // --------------------------------
-            clusterConfig.getSection("replication") match {
-              case None ⇒
-                Some(Deploy(address, recipe, router, failureDetector, Clustered(preferredNodes, replicationFactor, Transient)))
+                // --------------------------------
+                // akka.actor.deployment.<address>.cluster.replicas
+                // --------------------------------
+                val replicationFactor = {
+                  if (router == Direct) new ReplicationFactor(1)
+                  else {
+                    clusterConfig.getAny("replication-factor", "0") match {
+                      case "auto" ⇒ AutoReplicationFactor
+                      case "0"    ⇒ ZeroReplicationFactor
+                      case nrOfReplicas: String ⇒
+                        try {
+                          new ReplicationFactor(nrOfReplicas.toInt)
+                        } catch {
+                          case e: Exception ⇒
+                            throw new ConfigurationException(
+                              "Config option [" + addressPath +
+                                ".cluster.replicas] needs to be either [\"auto\"] or [0-N] - was [" +
+                                nrOfReplicas + "]")
+                        }
+                    }
+                  }
+                }
 
-              case Some(replicationConfig) ⇒
-                val storage = replicationConfig.getString("storage", "transaction-log") match {
-                  case "transaction-log" ⇒ TransactionLog
-                  case "data-grid"       ⇒ DataGrid
-                  case unknown ⇒
-                    throw new ConfigurationException("Config option [" + addressPath +
-                      ".cluster.replication.storage] needs to be either [\"transaction-log\"] or [\"data-grid\"] - was [" +
-                      unknown + "]")
+                // --------------------------------
+                // akka.actor.deployment.<address>.cluster.replication
+                // --------------------------------
+                clusterConfig.getSection("replication") match {
+                  case None ⇒
+                    Some(Deploy(address, recipe, router, failureDetector, ClusterScope(preferredNodes, replicationFactor, Transient)))
+
+                  case Some(replicationConfig) ⇒
+                    val storage = replicationConfig.getString("storage", "transaction-log") match {
+                      case "transaction-log" ⇒ TransactionLog
+                      case "data-grid"       ⇒ DataGrid
+                      case unknown ⇒
+                        throw new ConfigurationException("Config option [" + addressPath +
+                          ".cluster.replication.storage] needs to be either [\"transaction-log\"] or [\"data-grid\"] - was [" +
+                          unknown + "]")
+                    }
+                    val strategy = replicationConfig.getString("strategy", "write-through") match {
+                      case "write-through" ⇒ WriteThrough
+                      case "write-behind"  ⇒ WriteBehind
+                      case unknown ⇒
+                        throw new ConfigurationException("Config option [" + addressPath +
+                          ".cluster.replication.strategy] needs to be either [\"write-through\"] or [\"write-behind\"] - was [" +
+                          unknown + "]")
+                    }
+                    Some(Deploy(address, recipe, router, failureDetector, ClusterScope(preferredNodes, replicationFactor, Replication(storage, strategy))))
                 }
-                val strategy = replicationConfig.getString("strategy", "write-through") match {
-                  case "write-through" ⇒ WriteThrough
-                  case "write-behind"  ⇒ WriteBehind
-                  case unknown ⇒
-                    throw new ConfigurationException("Config option [" + addressPath +
-                      ".cluster.replication.strategy] needs to be either [\"write-through\"] or [\"write-behind\"] - was [" +
-                      unknown + "]")
-                }
-                Some(Deploy(address, recipe, router, failureDetector, Clustered(preferredNodes, replicationFactor, Replication(storage, strategy))))
             }
         }
     }
diff --git a/akka-actor/src/main/scala/akka/actor/DeploymentConfig.scala b/akka-actor/src/main/scala/akka/actor/DeploymentConfig.scala
index 73e1067239..8f33e300a6 100644
--- a/akka-actor/src/main/scala/akka/actor/DeploymentConfig.scala
+++ b/akka-actor/src/main/scala/akka/actor/DeploymentConfig.scala
@@ -24,7 +24,7 @@ object DeploymentConfig {
     recipe: Option[ActorRecipe],
     routing: Routing = Direct,
     failureDetector: FailureDetector = RemoveConnectionOnFirstFailureLocalFailureDetector,
-    scope: Scope = Local) {
+    scope: Scope = LocalScope) {
     Address.validate(address)
   }
 
@@ -59,30 +59,35 @@ object DeploymentConfig {
   // --- FailureDetector
   // --------------------------------
   sealed trait FailureDetector
+  case class BannagePeriodFailureDetector(timeToBan: Long) extends FailureDetector
   case class CustomFailureDetector(className: String) extends FailureDetector
 
   // For Java API
   case class RemoveConnectionOnFirstFailureLocalFailureDetector() extends FailureDetector
-  case class RemoveConnectionOnFirstFailureRemoteFailureDetector() extends FailureDetector
+  case class RemoveConnectionOnFirstFailureFailureDetector() extends FailureDetector
 
   // For Scala API
   case object RemoveConnectionOnFirstFailureLocalFailureDetector extends FailureDetector
-  case object RemoveConnectionOnFirstFailureRemoteFailureDetector extends FailureDetector
+  case object RemoveConnectionOnFirstFailureFailureDetector extends FailureDetector
 
   // --------------------------------
   // --- Scope
   // --------------------------------
   sealed trait Scope
-  case class Clustered(
+  case class ClusterScope(
     preferredNodes: Iterable[Home] = Vector(Node(Config.nodename)),
     replicas: ReplicationFactor = ZeroReplicationFactor,
     replication: ReplicationScheme = Transient) extends Scope
 
+  case class RemoteScope(
+    hostname: String = "localhost",
+    port: Int = 2552) extends Scope
+
   // For Java API
-  case class Local() extends Scope
+  case class LocalScope() extends Scope
 
   // For Scala API
-  case object Local extends Scope
+  case object LocalScope extends Scope
 
   // --------------------------------
   // --- Home
@@ -175,10 +180,11 @@ object DeploymentConfig {
   def isHomeNode(homes: Iterable[Home]): Boolean = homes exists (home ⇒ nodeNameFor(home) == Config.nodename)
 
   def failureDetectorTypeFor(failureDetector: FailureDetector): FailureDetectorType = failureDetector match {
+    case BannagePeriodFailureDetector(timeToBan) ⇒ FailureDetectorType.BannagePeriodFailureDetector(timeToBan)
     case RemoveConnectionOnFirstFailureLocalFailureDetector ⇒ FailureDetectorType.RemoveConnectionOnFirstFailureLocalFailureDetector
     case RemoveConnectionOnFirstFailureLocalFailureDetector() ⇒ FailureDetectorType.RemoveConnectionOnFirstFailureLocalFailureDetector
-    case RemoveConnectionOnFirstFailureRemoteFailureDetector ⇒ FailureDetectorType.RemoveConnectionOnFirstFailureRemoteFailureDetector
-    case RemoveConnectionOnFirstFailureRemoteFailureDetector() ⇒ FailureDetectorType.RemoveConnectionOnFirstFailureRemoteFailureDetector
+    case RemoveConnectionOnFirstFailureFailureDetector ⇒ FailureDetectorType.RemoveConnectionOnFirstFailureFailureDetector
+    case RemoveConnectionOnFirstFailureFailureDetector() ⇒ FailureDetectorType.RemoveConnectionOnFirstFailureFailureDetector
     case CustomFailureDetector(implClass) ⇒ FailureDetectorType.CustomFailureDetector(implClass)
     case unknown ⇒ throw new UnsupportedOperationException("Unknown FailureDetector [" + unknown + "]")
   }
@@ -200,7 +206,7 @@ object DeploymentConfig {
   }
 
   def replicationSchemeFor(deployment: Deploy): Option[ReplicationScheme] = deployment match {
-    case Deploy(_, _, _, _, Clustered(_, _, replicationScheme)) ⇒ Some(replicationScheme)
+    case Deploy(_, _, _, _, ClusterScope(_, _, replicationScheme)) ⇒ Some(replicationScheme)
     case _ ⇒ None
   }
 
diff --git a/akka-actor/src/main/scala/akka/cluster/ClusterInterface.scala b/akka-actor/src/main/scala/akka/cluster/ClusterInterface.scala
index 38ab4ad6df..390f734da1 100644
--- a/akka-actor/src/main/scala/akka/cluster/ClusterInterface.scala
+++ b/akka-actor/src/main/scala/akka/cluster/ClusterInterface.scala
@@ -197,10 +197,6 @@ trait ClusterNode {
 
   def zkServerAddresses: String
 
-  def remoteService: RemoteSupport
-
-  def remoteServerAddress: InetSocketAddress
-
   def start()
 
   def shutdown()
@@ -390,12 +386,6 @@ trait ClusterNode {
    */
   def use[T <: Actor](actorAddress: String): Option[LocalActorRef]
 
-  /**
-   * Checks out an actor for use on this node, e.g. checked out as a 'LocalActorRef' but it makes it available
-   * for remote access through lookup by its UUID.
-   */
-  def use[T <: Actor](actorAddress: String, serializer: Serializer): Option[LocalActorRef]
-
   /**
    * Using (checking out) actor on a specific set of nodes.
    */
diff --git a/akka-actor/src/main/scala/akka/config/Config.scala b/akka-actor/src/main/scala/akka/config/Config.scala
index e9c2e21be4..dff1edd09f 100644
--- a/akka-actor/src/main/scala/akka/config/Config.scala
+++ b/akka-actor/src/main/scala/akka/config/Config.scala
@@ -103,27 +103,27 @@ object Config {
 
   val isClusterEnabled = config.getList("akka.enabled-modules").exists(_ == "cluster")
 
-  lazy val nodename = System.getProperty("akka.cluster.nodename") match {
+  val clusterName = config.getString("akka.cluster.name", "default")
+
+  val nodename = System.getProperty("akka.cluster.nodename") match {
     case null | "" ⇒ new UUID().toString
     case value     ⇒ value
   }
 
-  lazy val hostname = System.getProperty("akka.cluster.hostname") match {
+  val hostname = System.getProperty("akka.remote.hostname") match {
     case null | "" ⇒ InetAddress.getLocalHost.getHostName
     case value     ⇒ value
   }
 
-  val remoteServerPort = System.getProperty("akka.cluster.port") match {
+  val remoteServerPort = System.getProperty("akka.remote.port") match {
     case null | "" ⇒
-      System.getProperty("akka.cluster.remote-server-port") match {
-        case null | "" ⇒ config.getInt("akka.cluster.remote-server-port", 2552)
+      System.getProperty("akka.remote.server.port") match {
+        case null | "" ⇒ config.getInt("akka.remote.server.port", 2552)
         case value     ⇒ value.toInt
       }
     case value ⇒ value.toInt
   }
 
-  val clusterName = config.getString("akka.cluster.name", "default")
-
   val startTime = System.currentTimeMillis
   def uptime = (System.currentTimeMillis - startTime) / 1000
 }
diff --git a/akka-actor/src/main/scala/akka/dispatch/Future.scala b/akka-actor/src/main/scala/akka/dispatch/Future.scala
index 1d3b9c1368..c3fc38a92d 100644
--- a/akka-actor/src/main/scala/akka/dispatch/Future.scala
+++ b/akka-actor/src/main/scala/akka/dispatch/Future.scala
@@ -1,3 +1,4 @@
+
 /**
  *  Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
  */
@@ -775,7 +776,6 @@ trait Promise[T] extends Future[T] {
     }
     fr
   }
-
 }
 
 //Companion object to FState, just to provide a cheap, immutable default entry
diff --git a/akka-actor/src/main/scala/akka/cluster/RemoteEventHandler.scala b/akka-actor/src/main/scala/akka/remote/RemoteEventHandler.scala
similarity index 99%
rename from akka-actor/src/main/scala/akka/cluster/RemoteEventHandler.scala
rename to akka-actor/src/main/scala/akka/remote/RemoteEventHandler.scala
index e570b778a1..4d122a1447 100644
--- a/akka-actor/src/main/scala/akka/cluster/RemoteEventHandler.scala
+++ b/akka-actor/src/main/scala/akka/remote/RemoteEventHandler.scala
@@ -2,7 +2,7 @@
  * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.cluster
+package akka.remote
 
 import akka.actor.Actor
 import akka.event.EventHandler
diff --git a/akka-actor/src/main/scala/akka/cluster/RemoteInterface.scala b/akka-actor/src/main/scala/akka/remote/RemoteInterface.scala
similarity index 98%
rename from akka-actor/src/main/scala/akka/cluster/RemoteInterface.scala
rename to akka-actor/src/main/scala/akka/remote/RemoteInterface.scala
index be56c3b0b0..f4671d617d 100644
--- a/akka-actor/src/main/scala/akka/cluster/RemoteInterface.scala
+++ b/akka-actor/src/main/scala/akka/remote/RemoteInterface.scala
@@ -2,7 +2,7 @@
  * Copyright (C) 2009-2010 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.cluster
+package akka.remote
 
 import akka.japi.Creator
 import akka.actor._
@@ -19,6 +19,13 @@ import java.util.concurrent.ConcurrentHashMap
 import java.io.{ PrintWriter, PrintStream }
 import java.lang.reflect.InvocationTargetException
 
+class RemoteException(message: String) extends AkkaException(message)
+
+trait RemoteService {
+  def server: RemoteSupport
+  def address: InetSocketAddress
+}
+
 trait RemoteModule {
   val UUID_PREFIX = "uuid:".intern
 
@@ -49,7 +56,7 @@ trait RemoteModule {
     else {
       val actorRef =
         Deployer.lookupDeploymentFor(address) match {
-          case Some(Deploy(_, router, _, Clustered(home, _, _))) ⇒
+          case Some(Deploy(_, router, _, Cluster(home, _, _))) ⇒
 
             if (DeploymentConfig.isHomeNode(home)) { // on home node
               Actor.registry.actorFor(address) match { // try to look up in actor registry
diff --git a/akka-actor/src/main/scala/akka/routing/FailureDetector.scala b/akka-actor/src/main/scala/akka/routing/FailureDetector.scala
index daf6f29067..bccbd33b0b 100644
--- a/akka-actor/src/main/scala/akka/routing/FailureDetector.scala
+++ b/akka-actor/src/main/scala/akka/routing/FailureDetector.scala
@@ -18,6 +18,20 @@ import java.util.concurrent.atomic.{ AtomicReference, AtomicInteger }
 
 import scala.annotation.tailrec
 
+sealed trait FailureDetectorType
+
+/**
+ * Used for declarative configuration of failure detection.
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+object FailureDetectorType {
+  case object RemoveConnectionOnFirstFailureLocalFailureDetector extends FailureDetectorType
+  case object RemoveConnectionOnFirstFailureFailureDetector extends FailureDetectorType
+  case class BannagePeriodFailureDetector(timeToBan: Long) extends FailureDetectorType
+  case class CustomFailureDetector(className: String) extends FailureDetectorType
+}
+
 /**
  * Misc helper and factory methods for failure detection.
  */
@@ -59,6 +73,8 @@ object FailureDetector {
  *      the Router can indicate that some happened happened with a actor ref, e.g. the actor ref dying.
  *   </li>
  * </ol>
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 trait FailureDetector {
 
@@ -120,6 +136,11 @@ trait FailureDetector {
    */
   def remove(deadRef: ActorRef)
 
+  /**
+   * TODO: document
+   */
+  def putIfAbsent(address: InetSocketAddress, newConnectionFactory: () ⇒ ActorRef): ActorRef
+
   /**
    * Fails over connections from one address to another.
    */
diff --git a/akka-actor/src/main/scala/akka/routing/Pool.scala b/akka-actor/src/main/scala/akka/routing/Pool.scala
index ebfe64e946..69a9164543 100644
--- a/akka-actor/src/main/scala/akka/routing/Pool.scala
+++ b/akka-actor/src/main/scala/akka/routing/Pool.scala
@@ -62,7 +62,7 @@ trait ActorPool {
 /**
  * A default implementation of a pool that:
  *  First, invokes the pool's capacitor that tells it, based on the current delegate count
- *  and it's own heuristic by how many delegates the pool should be resized.  Resizing can
+ *  and its own heuristic by how many delegates the pool should be resized.  Resizing can
  *  can be incremental, decremental or flat.  If there is a change to capacity, new delegates
  *  are added or existing ones are removed. Removed actors are sent the PoisonPill message.
  *  New actors are automatically started and linked.  The pool supervises the actors and will
@@ -78,9 +78,10 @@ trait ActorPool {
  *  Second, invokes the pool's selector that returns a list of delegates that are to receive
  *  the incoming message.  Selectors may return more than one actor.  If <i>partialFill</i>
  *  is true then it might also the case that fewer than number of desired actors will be
- *  returned.
+ *  returned. If <i>partialFill</i> is false, the selector may return duplicate actors to
+ *  reach the desired <i>selectionCount</i>.
  *
- *  Lastly, routes by forwarding, the incoming message to each delegate in the selected set.
+ *  Lastly, routes by forwarding the incoming message to each delegate in the selected set.
  */
 trait DefaultActorPool extends ActorPool { this: Actor ⇒
   import ActorPool._
@@ -144,7 +145,18 @@ trait DefaultActorPool extends ActorPool { this: Actor ⇒
  * Returns the set of delegates with the least amount of message backlog.
  */
 trait SmallestMailboxSelector {
+  /**
+   * @return the number of delegates that will receive each message
+   */
   def selectionCount: Int
+  /**
+   * If there aren't enough delegates to provide the selectionCount, either
+   * send the message to fewer, or send the message selectionCount times
+   * including more than once to some of the delegates. This setting does
+   * not matter if you configure selectionCount to always be less than or
+   * equal to the number of delegates in the pool.
+   * @return true to send to fewer delegates or false to send to duplicate delegates
+   */
   def partialFill: Boolean
 
   def select(delegates: Seq[ActorRef]): Seq[ActorRef] = {
@@ -170,8 +182,18 @@ trait SmallestMailboxSelector {
  */
 trait RoundRobinSelector {
   private var _last: Int = -1;
-
+  /**
+   * @return the number of delegates that will receive each message
+   */
   def selectionCount: Int
+  /**
+   * If there aren't enough delegates to provide the selectionCount, either
+   * send the message to fewer, or send the message selectionCount times
+   * including more than once to some of the delegates. This setting does
+   * not matter if you configure selectionCount to always be less than or
+   * equal to the number of delegates in the pool.
+   * @return true to send to fewer delegates or false to send to duplicate delegates
+   */
   def partialFill: Boolean
 
   def select(delegates: Seq[ActorRef]): Seq[ActorRef] = {
@@ -201,21 +223,29 @@ trait RoundRobinSelector {
  * Ensures a fixed number of delegates in the pool
  */
 trait FixedSizeCapacitor {
+  /**
+   * @return the fixed number of delegates the pool should have
+   */
   def limit: Int
   def capacity(delegates: Seq[ActorRef]): Int = (limit - delegates.size) max 0
 }
 
 /**
- * Constrains the pool capacity to a bounded range.
- * This capacitor employs 'pressure capacitors' (sorry for the unforunate confusing naming)
- * to feed a 'pressure' delta into the capacity function.  This measure is
- * basically the difference between the current pressure level and a pre-established threshhold.
- * When using this capacitor you must provide a method called 'pressure' or mix-in
- * one of the PressureCapacitor traits below.
- *
+ * Constrains the number of delegates to a bounded range.
+ * You probably don't want to use this trait directly,
+ * instead look at [[akka.routing.CapacityStrategy]] and [[akka.routing.BoundedCapacityStrategy]].
+ * To use this trait you have to implement _eval() which is provided by
+ * [[akka.routing.BoundedCapacityStrategy]] in terms of pressure() and filter()
+ * methods.
  */
 trait BoundedCapacitor {
+  /**
+   * @return the fewest delegates the pool should ever have
+   */
   def lowerBound: Int
+  /**
+   * @return the most delegates the pool should ever have
+   */
   def upperBound: Int
 
   def capacity(delegates: Seq[ActorRef]): Int = {
@@ -228,13 +258,26 @@ trait BoundedCapacitor {
     else delta
   }
 
+  /**
+   * This method is defined when you mix in [[akka.routing.CapacityStrategy]]; it
+   * returns the "raw" proposed delta which is then clamped by
+   * lowerBound and upperBound.
+   * @return proposed delta ignoring bounds
+   */
   protected def _eval(delegates: Seq[ActorRef]): Int
 }
 
 /**
- * Returns the number of delegates required to manage the current message backlogs
+ * Implements pressure() to return the number of delegates with overly-full mailboxes,
+ * where the pressureThreshold method defines what counts as overly-full.
  */
 trait MailboxPressureCapacitor {
+
+  /**
+   * The pressure will be the number of delegates with at least
+   * pressureThreshold messages in their mailbox.
+   * @return mailbox size that counts as pressure
+   */
   def pressureThreshold: Int
   def pressure(delegates: Seq[ActorRef]): Int =
     delegates count {
@@ -244,7 +287,12 @@ trait MailboxPressureCapacitor {
 }
 
 /**
- * Returns the number of delegates required to respond to the number of pending futures
+ * Implements pressure() to return the number of actors currently processing a
+ * message whose reply will be sent to a [[akka.dispatch.Future]].
+ * In other words, this capacitor counts how many
+ * delegates are tied up actively processing a message, as long as the
+ * messages have somebody waiting on the result. "One way" messages with
+ * no reply would not be counted.
  */
 trait ActiveFuturesPressureCapacitor {
   def pressure(delegates: Seq[ActorRef]): Int =
@@ -255,24 +303,39 @@ trait ActiveFuturesPressureCapacitor {
 }
 
 /**
- *
+ * A [[akka.routing.CapacityStrategy]] implements methods pressure() and filter(), where
+ * pressure() returns the number of "busy" delegates, and filter() computes
+ * a proposed delta (positive, negative, or zero) in the size of the delegate
+ * pool.
  */
 trait CapacityStrategy {
   import ActorPool._
 
   /**
-   * This method returns a 'pressure level' that will be fed into the capacitor and
-   * evaluated against the established threshhold.  For instance, in general, if
-   * the current pressure level exceeds the capacity of the pool, new delegates will
-   * be added.
+   * This method returns the number of delegates considered busy, or 'pressure level',
+   * which will be fed into the capacitor and evaluated against the established threshhold.
+   * For instance, in general, if the current pressure level exceeds the capacity of the
+   * pool, new delegates will be added.
+   * @param delegates the current pool of delegates
+   * @return number of busy delegates, between 0 and delegates.length
    */
   def pressure(delegates: Seq[ActorRef]): Int
   /**
    * This method can be used to smooth the response of the capacitor by considering
    * the current pressure and current capacity.
+   *
+   * @param pressure current number of busy delegates
+   * @param capacity current number of delegates
+   * @return proposed change in the capacity
    */
   def filter(pressure: Int, capacity: Int): Int
 
+  /**
+   * Overrides the _eval() method in [[akka.routing.BoundedCapacity]],
+   * using filter and pressure to compute a proposed delta.
+   * @param delegates current delegates
+   * @return proposed delta in capacity
+   */
   protected def _eval(delegates: Seq[ActorRef]): Int = filter(pressure(delegates), delegates.size)
 }
 
@@ -292,14 +355,28 @@ trait BoundedCapacityStrategy extends CapacityStrategy with BoundedCapacitor
 
 /**
  * Filters
- *  These traits refine the raw pressure reading into a more appropriate capacity delta.
+ *  These traits compute a proposed capacity delta from the pressure (pressure
+ *  is the number of busy delegates) and the current capacity.
  */
 
 /**
  * The basic filter trait that composes ramp-up and and back-off subfiltering.
+ * filter() is defined to be the sum of rampup() and backoff().
  */
 trait Filter {
+  /**
+   * Computes a proposed positive (or zero) capacity delta.
+   * @param pressure the current number of busy delegates
+   * @param capacity the current number of total delegates
+   * @return proposed increase in capacity
+   */
   def rampup(pressure: Int, capacity: Int): Int
+  /**
+   * Computes a proposed negative (or zero) capacity delta.
+   * @param pressure the current number of busy delegates
+   * @param capacity the current number of total delegates
+   * @return proposed decrease in capacity (as a negative number)
+   */
   def backoff(pressure: Int, capacity: Int): Int
 
   // pass through both filters just to be sure any internal counters
@@ -309,19 +386,31 @@ trait Filter {
     rampup(pressure, capacity) + backoff(pressure, capacity)
 }
 
+/**
+ * This trait is a convenient shorthand to use the [[akka.routing.BasicRampup]]
+ * and [[akka.routing.BasicBackoff]] subfilters together.
+ */
 trait BasicFilter extends Filter with BasicRampup with BasicBackoff
 
 /**
- * Filter performs steady incremental growth using only the basic ramp-up subfilter
+ * Filter performs steady incremental growth using only the basic ramp-up subfilter.
+ * The pool of delegates never gets smaller, only larger.
  */
 trait BasicNoBackoffFilter extends BasicRampup {
   def filter(pressure: Int, capacity: Int): Int = rampup(pressure, capacity)
 }
 
 /**
- * Basic incremental growth as a percentage of the current pool capacity
+ * Basic incremental growth as a percentage of the current pool capacity.
+ * Whenever pressure reaches capacity (i.e. all delegates are busy),
+ * the capacity is increased by a percentage.
  */
 trait BasicRampup {
+  /**
+   * Percentage to increase capacity whenever all delegates are busy.
+   * For example, 0.2 would increase 20%, etc.
+   * @return percentage increase in capacity when delegates are all busy.
+   */
   def rampupRate: Double
 
   def rampup(pressure: Int, capacity: Int): Int =
@@ -329,10 +418,23 @@ trait BasicRampup {
 }
 
 /**
- * Basic decrement as a percentage of the current pool capacity
+ * Basic decrement as a percentage of the current pool capacity.
+ * Whenever pressure as a percentage of capacity falls below the
+ * backoffThreshold, capacity is reduced by the backoffRate.
  */
 trait BasicBackoff {
+  /**
+   * Fraction of capacity the pool has to fall below before backing off.
+   * For example, if this is 0.7, then we'll remove some delegates when
+   * less than 70% of delegates are busy.
+   * @return fraction of busy delegates where we start to backoff
+   */
   def backoffThreshold: Double
+  /**
+   * Fraction of delegates to be removed when the pool reaches the
+   * backoffThreshold.
+   * @return percentage of delegates to remove
+   */
   def backoffRate: Double
 
   def backoff(pressure: Int, capacity: Int): Int =
@@ -343,9 +445,24 @@ trait BasicBackoff {
  * will begin to reduce capacity once this value drops below the provided threshold.  The number of
  * delegates to cull from the pool is determined by some scaling factor (the backoffRate) multiplied
  * by the difference in capacity and pressure.
+ *
+ * In essence, [[akka.routing.RunningMeanBackoff]] works the same way as [[akka.routing.BasicBackoff]]
+ * except that it uses
+ * a running mean pressure and capacity rather than the current pressure and capacity.
  */
 trait RunningMeanBackoff {
+  /**
+   * Fraction of mean capacity the pool has to fall below before backing off.
+   * For example, if this is 0.7, then we'll remove some delegates when
+   * less than 70% of delegates are busy on average.
+   * @return fraction of busy delegates where we start to backoff
+   */
   def backoffThreshold: Double
+  /**
+   * The fraction of delegates to be removed when the running mean reaches the
+   * backoffThreshold.
+   * @return percentage reduction in capacity
+   */
   def backoffRate: Double
 
   private var _pressure: Double = 0.0
@@ -361,6 +478,12 @@ trait RunningMeanBackoff {
     else 0
   }
 
+  /**
+   * Resets the running mean pressure and capacity.
+   * This is never invoked by the library, you have to do
+   * it by hand if there are points in time where it makes
+   * sense.
+   */
   def backoffReset {
     _pressure = 0.0
     _capacity = 0.0
diff --git a/akka-actor/src/main/scala/akka/routing/RoutedProps.scala b/akka-actor/src/main/scala/akka/routing/RoutedProps.scala
index 5d113d34c2..4515101609 100644
--- a/akka-actor/src/main/scala/akka/routing/RoutedProps.scala
+++ b/akka-actor/src/main/scala/akka/routing/RoutedProps.scala
@@ -11,19 +11,6 @@ import java.net.InetSocketAddress
 
 import scala.collection.JavaConversions.iterableAsScalaIterable
 
-sealed trait FailureDetectorType
-
-/**
- * Used for declarative configuration of failure detection in Routing.
- *
- * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
- */
-object FailureDetectorType {
-  case object RemoveConnectionOnFirstFailureLocalFailureDetector extends FailureDetectorType
-  case object RemoveConnectionOnFirstFailureRemoteFailureDetector extends FailureDetectorType
-  case class CustomFailureDetector(className: String) extends FailureDetectorType
-}
-
 sealed trait RouterType
 
 /**
diff --git a/akka-actor/src/main/scala/akka/routing/Routing.scala b/akka-actor/src/main/scala/akka/routing/Routing.scala
index 7618883f5b..c9e4ca2979 100644
--- a/akka-actor/src/main/scala/akka/routing/Routing.scala
+++ b/akka-actor/src/main/scala/akka/routing/Routing.scala
@@ -103,8 +103,6 @@ class RemoveConnectionOnFirstFailureLocalFailureDetector extends FailureDetector
     state.get.iterable foreach (_.stop())
   }
 
-  def failOver(from: InetSocketAddress, to: InetSocketAddress) {} // do nothing here
-
   @tailrec
   final def remove(ref: ActorRef) = {
     val oldState = state.get
@@ -120,6 +118,12 @@ class RemoveConnectionOnFirstFailureLocalFailureDetector extends FailureDetector
       if (!state.compareAndSet(oldState, newState)) remove(ref)
     }
   }
+
+  def failOver(from: InetSocketAddress, to: InetSocketAddress) {} // do nothing here
+
+  def putIfAbsent(address: InetSocketAddress, newConnectionFactory: () ⇒ ActorRef): ActorRef = {
+    throw new UnsupportedOperationException("Not supported")
+  }
 }
 
 /**
@@ -262,23 +266,24 @@ trait BasicRouter extends Router {
   def route(message: Any)(implicit sender: Option[ActorRef]) = message match {
     case Routing.Broadcast(message) ⇒
       //it is a broadcast message, we are going to send to message to all connections.
-      connections.versionedIterable.iterable.foreach(actor ⇒
+      connections.versionedIterable.iterable foreach { connection ⇒
         try {
-          actor.!(message)(sender) // we use original sender, so this is essentially a 'forward'
+          connection.!(message)(sender) // we use original sender, so this is essentially a 'forward'
         } catch {
           case e: Exception ⇒
-            connections.remove(actor)
+            connections.remove(connection)
             throw e
-        })
+        }
+      }
     case _ ⇒
       //it no broadcast message, we are going to select an actor from the connections and send the message to him.
       next match {
-        case Some(actor) ⇒
+        case Some(connection) ⇒
           try {
-            actor.!(message)(sender) // we use original sender, so this is essentially a 'forward'
+            connection.!(message)(sender) // we use original sender, so this is essentially a 'forward'
           } catch {
             case e: Exception ⇒
-              connections.remove(actor)
+              connections.remove(connection)
               throw e
           }
         case None ⇒
@@ -292,13 +297,13 @@ trait BasicRouter extends Router {
     case _ ⇒
       //it no broadcast message, we are going to select an actor from the connections and send the message to him.
       next match {
-        case Some(actor) ⇒
+        case Some(connection) ⇒
           try {
             // FIXME is this not wrong? it will not pass on and use the original Future but create a new one. Should reuse 'channel: UntypedChannel' in the AbstractRoutedActorRef
-            actor.?(message, timeout)(sender).asInstanceOf[Future[T]]
+            connection.?(message, timeout)(sender).asInstanceOf[Future[T]]
           } catch {
             case e: Exception ⇒
-              connections.remove(actor)
+              connections.remove(connection)
               throw e
           }
         case None ⇒
diff --git a/akka-actor/src/main/scala/akka/util/ReflectiveAccess.scala b/akka-actor/src/main/scala/akka/util/ReflectiveAccess.scala
index 3bf47e1c8d..9a29405a52 100644
--- a/akka-actor/src/main/scala/akka/util/ReflectiveAccess.scala
+++ b/akka-actor/src/main/scala/akka/util/ReflectiveAccess.scala
@@ -3,17 +3,17 @@
  */
 
 package akka.util
-
 import akka.dispatch.Envelope
 import akka.config.{ Config, ModuleNotAvailableException }
-import akka.cluster.RemoteSupport
 import akka.actor._
 import DeploymentConfig.ReplicationScheme
+import akka.config.{ Config, ModuleNotAvailableException }
 import akka.event.EventHandler
 import akka.cluster.ClusterNode
+import akka.remote.{ RemoteSupport, RemoteService }
+import akka.routing.{ RoutedProps, Router }
 
 import java.net.InetSocketAddress
-import akka.routing.{ RoutedProps, Router }
 
 /**
  * Helper class for reflective access to different modules in order to allow optional loading of modules.
@@ -138,7 +138,7 @@ object ReflectiveAccess {
    * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
    */
   object RemoteModule {
-    val TRANSPORT = Config.config.getString("akka.cluster.layer", "akka.cluster.netty.NettyRemoteSupport")
+    val TRANSPORT = Config.config.getString("akka.remote.layer", "akka.remote.netty.NettyRemoteSupport")
 
     val configDefaultAddress = new InetSocketAddress(Config.hostname, Config.remoteServerPort)
 
@@ -146,12 +146,25 @@ object ReflectiveAccess {
 
     def ensureEnabled() = {
       if (!isEnabled) {
-        val e = new ModuleNotAvailableException("Can't load the remoting module, make sure that akka-remote.jar is on the classpath")
+        val e = new ModuleNotAvailableException(
+          "Can't load the remote module, make sure it is enabled in the config ('akka.enabled-modules = [\"remote\"])' and that akka-remote.jar is on the classpath")
         EventHandler.debug(this, e.toString)
         throw e
       }
     }
 
+    lazy val remoteInstance: Option[RemoteService] = getObjectFor("akka.remote.Remote$") match {
+      case Right(value) ⇒ Some(value)
+      case Left(exception) ⇒
+        EventHandler.debug(this, exception.toString)
+        None
+    }
+
+    lazy val remoteService: RemoteService = {
+      ensureEnabled()
+      remoteInstance.get
+    }
+
     val remoteSupportClass = getClassFor[RemoteSupport](TRANSPORT) match {
       case Right(value) ⇒ Some(value)
       case Left(exception) ⇒
diff --git a/akka-cluster/src/main/scala/akka/cluster/Cluster.scala b/akka-cluster/src/main/scala/akka/cluster/Cluster.scala
index 4d56fa1e2b..66fafde7e7 100644
--- a/akka-cluster/src/main/scala/akka/cluster/Cluster.scala
+++ b/akka-cluster/src/main/scala/akka/cluster/Cluster.scala
@@ -150,14 +150,14 @@ object Cluster {
   // config options
   val name = Config.clusterName
   val zooKeeperServers = config.getString("akka.cluster.zookeeper-server-addresses", "localhost:2181")
-  val remoteServerPort = config.getInt("akka.cluster.remote-server-port", 2552)
+  val remoteServerPort = config.getInt("akka.remote.server.port", 2552)
   val sessionTimeout = Duration(config.getInt("akka.cluster.session-timeout", 60), TIME_UNIT).toMillis.toInt
   val metricsRefreshInterval = Duration(config.getInt("akka.cluster.metrics-refresh-timeout", 2), TIME_UNIT)
   val connectionTimeout = Duration(config.getInt("akka.cluster.connection-timeout", 60), TIME_UNIT).toMillis.toInt
   val maxTimeToWaitUntilConnected = Duration(config.getInt("akka.cluster.max-time-to-wait-until-connected", 30), TIME_UNIT).toMillis.toInt
-  val shouldCompressData = config.getBool("akka.cluster.use-compression", false)
+  val shouldCompressData = config.getBool("akka.remote.use-compression", false)
   val enableJMX = config.getBool("akka.enable-jmx", true)
-  val remoteDaemonAckTimeout = Duration(config.getInt("akka.cluster.remote-daemon-ack-timeout", 30), TIME_UNIT).toMillis.toInt
+  val remoteDaemonAckTimeout = Duration(config.getInt("akka.remote.remote-daemon-ack-timeout", 30), TIME_UNIT).toMillis.toInt
   val includeRefNodeInReplicaSet = config.getBool("akka.cluster.include-ref-node-in-replica-set", true)
 
   @volatile
@@ -168,8 +168,8 @@ object Cluster {
    * Currently supported options are:
    * <pre>
    *   Cluster setProperty ("akka.cluster.nodename", "node1")
-   *   Cluster setProperty ("akka.cluster.hostname", "darkstar.lan")
-   *   Cluster setProperty ("akka.cluster.port", "1234")
+   *   Cluster setProperty ("akka.remote.hostname", "darkstar.lan")
+   *   Cluster setProperty ("akka.remote.port", "1234")
    * </pre>
    */
   def setProperty(property: (String, String)) {
@@ -181,12 +181,12 @@ object Cluster {
     case None           ⇒ Config.nodename
   }
 
-  private def hostname: String = properties.get("akka.cluster.hostname") match {
+  private def hostname: String = properties.get("akka.remote.hostname") match {
     case Some(uberride) ⇒ uberride
     case None           ⇒ Config.hostname
   }
 
-  private def port: Int = properties.get("akka.cluster.port") match {
+  private def port: Int = properties.get("akka.remote.port") match {
     case Some(uberride) ⇒ uberride.toInt
     case None           ⇒ Config.remoteServerPort
   }
@@ -734,13 +734,7 @@ class DefaultClusterNode private[akka] (
    * Checks out an actor for use on this node, e.g. checked out as a 'LocalActorRef' but it makes it available
    * for remote access through lookup by its UUID.
    */
-  def use[T <: Actor](actorAddress: String): Option[LocalActorRef] = use(actorAddress, serializerForActor(actorAddress))
-
-  /**
-   * Checks out an actor for use on this node, e.g. checked out as a 'LocalActorRef' but it makes it available
-   * for remote access through lookup by its UUID.
-   */
-  def use[T <: Actor](actorAddress: String, serializer: Serializer): Option[LocalActorRef] = {
+  def use[T <: Actor](actorAddress: String): Option[LocalActorRef] = {
     val nodeName = nodeAddress.nodeName
 
     val actorFactoryPath = actorAddressRegistryPathFor(actorAddress)
@@ -1233,7 +1227,7 @@ class DefaultClusterNode private[akka] (
       if (actorAddress.isDefined) {
         // use 'preferred-nodes' in deployment config for the actor
         Deployer.deploymentFor(actorAddress.get) match {
-          case Deploy(_, _, _, _, Clustered(nodes, _, _)) ⇒
+          case Deploy(_, _, _, _, Cluster(nodes, _, _)) ⇒
             nodes map (node ⇒ DeploymentConfig.nodeNameFor(node)) take replicationFactor
           case _ ⇒
             throw new ClusterException("Actor [" + actorAddress.get + "] is not configured as clustered")
diff --git a/akka-cluster/src/main/scala/akka/cluster/ClusterDeployer.scala b/akka-cluster/src/main/scala/akka/cluster/ClusterDeployer.scala
index cd2ee02b8e..c9ac211821 100644
--- a/akka-cluster/src/main/scala/akka/cluster/ClusterDeployer.scala
+++ b/akka-cluster/src/main/scala/akka/cluster/ClusterDeployer.scala
@@ -54,11 +54,11 @@ object ClusterDeployer extends ActorDeployer {
 
   private val deploymentInProgressLockListener = new LockListener {
     def lockAcquired() {
-      EventHandler.debug(this, "Clustered deployment started")
+      EventHandler.info(this, "Clustered deployment started")
     }
 
     def lockReleased() {
-      EventHandler.debug(this, "Clustered deployment completed")
+      EventHandler.info(this, "Clustered deployment completed")
       deploymentCompleted.countDown()
     }
   }
@@ -121,13 +121,13 @@ object ClusterDeployer extends ActorDeployer {
     val deployments = addresses map { address ⇒
       zkClient.readData(deploymentAddressPath.format(address)).asInstanceOf[Deploy]
     }
-    EventHandler.info(this, "Fetched deployment plan from cluster [\n\t%s\n]" format deployments.mkString("\n\t"))
+    EventHandler.info(this, "Fetched deployment plans from cluster [\n\t%s\n]" format deployments.mkString("\n\t"))
     deployments
   }
 
   private[akka] def init(deployments: Seq[Deploy]) {
     isConnected switchOn {
-      EventHandler.info(this, "Initializing cluster deployer")
+      EventHandler.info(this, "Initializing ClusterDeployer")
 
       basePaths foreach { path ⇒
         try {
@@ -146,7 +146,7 @@ object ClusterDeployer extends ActorDeployer {
       if (!isDeploymentCompletedInCluster) {
         if (deploymentInProgressLock.lock()) {
           // try to be the one doing the clustered deployment
-          EventHandler.info(this, "Pushing deployment plan cluster [\n\t" + allDeployments.mkString("\n\t") + "\n]")
+          EventHandler.info(this, "Pushing clustered deployment plans [\n\t" + allDeployments.mkString("\n\t") + "\n]")
           allDeployments foreach (deploy(_)) // deploy
           markDeploymentCompletedInCluster()
           deploymentInProgressLock.unlock() // signal deployment complete
@@ -176,9 +176,11 @@ object ClusterDeployer extends ActorDeployer {
             zkClient.writeData(path, deployment)
           } catch {
             case e: NullPointerException ⇒
-              handleError(new DeploymentException("Could not store deployment data [" + deployment + "] in ZooKeeper since client session is closed"))
+              handleError(new DeploymentException(
+                "Could not store deployment data [" + deployment + "] in ZooKeeper since client session is closed"))
             case e: Exception ⇒
-              handleError(new DeploymentException("Could not store deployment data [" + deployment + "] in ZooKeeper due to: " + e))
+              handleError(new DeploymentException(
+                "Could not store deployment data [" + deployment + "] in ZooKeeper due to: " + e))
           }
       }
     }
diff --git a/akka-cluster/src/main/scala/akka/cluster/TransactionLog.scala b/akka-cluster/src/main/scala/akka/cluster/TransactionLog.scala
index a99fedaa74..f2ebceb7f8 100644
--- a/akka-cluster/src/main/scala/akka/cluster/TransactionLog.scala
+++ b/akka-cluster/src/main/scala/akka/cluster/TransactionLog.scala
@@ -371,7 +371,7 @@ object TransactionLog {
   val quorumSize = config.getInt("akka.cluster.replication.quorum-size", 2)
   val snapshotFrequency = config.getInt("akka.cluster.replication.snapshot-frequency", 1000)
   val timeout = Duration(config.getInt("akka.cluster.replication.timeout", 30), TIME_UNIT).toMillis
-  val shouldCompressData = config.getBool("akka.cluster.use-compression", false)
+  val shouldCompressData = config.getBool("akka.remote.use-compression", false)
 
   private[akka] val transactionLogNode = "/transaction-log-ids"
 
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/newleader/NewLeaderChangeListenerMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/newleader/NewLeaderChangeListenerMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/newleader/NewLeaderChangeListenerMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/newleader/NewLeaderChangeListenerMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/newleader/NewLeaderChangeListenerMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/newleader/NewLeaderChangeListenerMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/newleader/NewLeaderChangeListenerMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/newleader/NewLeaderChangeListenerMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodeconnected/NodeConnectedChangeListenerMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodeconnected/NodeConnectedChangeListenerMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodeconnected/NodeConnectedChangeListenerMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodeconnected/NodeConnectedChangeListenerMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodeconnected/NodeConnectedChangeListenerMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodeconnected/NodeConnectedChangeListenerMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodeconnected/NodeConnectedChangeListenerMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodeconnected/NodeConnectedChangeListenerMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodedisconnected/NodeDisconnectedChangeListenerMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodedisconnected/NodeDisconnectedChangeListenerMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodedisconnected/NodeDisconnectedChangeListenerMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodedisconnected/NodeDisconnectedChangeListenerMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodedisconnected/NodeDisconnectedChangeListenerMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodedisconnected/NodeDisconnectedChangeListenerMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodedisconnected/NodeDisconnectedChangeListenerMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/changelisteners/nodedisconnected/NodeDisconnectedChangeListenerMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/configuration/ConfigurationStorageMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/configuration/ConfigurationStorageMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/configuration/ConfigurationStorageMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/configuration/ConfigurationStorageMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/configuration/ConfigurationStorageMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/configuration/ConfigurationStorageMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/configuration/ConfigurationStorageMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/configuration/ConfigurationStorageMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/leader/election/LeaderElectionMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/leader/election/LeaderElectionMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/leader/election/LeaderElectionMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/leader/election/LeaderElectionMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/leader/election/LeaderElectionMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/leader/election/LeaderElectionMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/leader/election/LeaderElectionMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/leader/election/LeaderElectionMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/registry/RegistryStoreMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/registry/RegistryStoreMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/registry/RegistryStoreMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/registry/RegistryStoreMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/registry/RegistryStoreMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/registry/RegistryStoreMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/api/registry/RegistryStoreMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/api/registry/RegistryStoreMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/deployment/DeploymentMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/deployment/DeploymentMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/deployment/DeploymentMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/deployment/DeploymentMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/deployment/DeploymentMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/deployment/DeploymentMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/deployment/DeploymentMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/deployment/DeploymentMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/metrics/local/LocalMetricsMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/metrics/local/LocalMetricsMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/metrics/local/LocalMetricsMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/metrics/local/LocalMetricsMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/metrics/remote/RemoteMetricsMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/metrics/remote/RemoteMetricsMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/metrics/remote/RemoteMetricsMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/metrics/remote/RemoteMetricsMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/metrics/remote/RemoteMetricsMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/metrics/remote/RemoteMetricsMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/metrics/remote/RemoteMetricsMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/metrics/remote/RemoteMetricsMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/migration/MigrationExplicitMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/migration/MigrationExplicitMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/migration/MigrationExplicitMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/migration/MigrationExplicitMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/migration/MigrationExplicitMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/migration/MigrationExplicitMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/migration/MigrationExplicitMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/migration/MigrationExplicitMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode1.conf b/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode1.conf
index b3c3a1e35e..1e7ce9e70a 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode1.conf
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode1.conf
@@ -4,4 +4,4 @@ akka.event-handler-level = "WARNING"
 akka.actor.deployment.service-test.router = "round-robin"
 akka.actor.deployment.service-test.cluster.preferred-nodes = ["node:node2","node:node3"]
 akka.actor.deployment.service-test.cluster.replication-factor = 2
-akka.cluster.client.buffering.retry-message-send-on-failure = false
+akka.remote.client.buffering.retry-message-send-on-failure = false
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode2.conf b/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode2.conf
index f7168750bf..7e33e52135 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode2.conf
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode2.conf
@@ -3,4 +3,4 @@ akka.event-handler-level = "WARNING"
 akka.actor.deployment.service-test.router = "round-robin"
 akka.actor.deployment.service-test.cluster.preferred-nodes = ["node:node2","node:node3"]
 akka.actor.deployment.service-test.cluster.replication-factor = 2
-akka.cluster.client.buffering.retry-message-send-on-failure = false
+akka.remote.client.buffering.retry-message-send-on-failure = false
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode3.conf b/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode3.conf
index 0cbec330d6..531bf0f6d2 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode3.conf
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode3.conf
@@ -3,4 +3,4 @@ akka.event-handler-level = "WARNING"
 akka.actor.deployment.service-test.router = "round-robin"
 akka.actor.deployment.service-test.cluster.preferred-nodes = ["node:node2","node:node3"]
 akka.actor.deployment.service-test.cluster.replication-factor = 2
-akka.cluster.client.buffering.retry-message-send-on-failure = false
\ No newline at end of file
+akka.remote.client.buffering.retry-message-send-on-failure = false
\ No newline at end of file
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode3.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode3.opts
index 202496ad31..089e3b7776 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode3.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode3.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node3 -Dakka.cluster.port=9993
+-Dakka.cluster.nodename=node3 -Dakka.remote.port=9993
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/nosnapshot/ReplicationTransactionLogWriteBehindNoSnapshotMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/nosnapshot/ReplicationTransactionLogWriteBehindNoSnapshotMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/nosnapshot/ReplicationTransactionLogWriteBehindNoSnapshotMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/nosnapshot/ReplicationTransactionLogWriteBehindNoSnapshotMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/nosnapshot/ReplicationTransactionLogWriteBehindNoSnapshotMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/nosnapshot/ReplicationTransactionLogWriteBehindNoSnapshotMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/nosnapshot/ReplicationTransactionLogWriteBehindNoSnapshotMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/nosnapshot/ReplicationTransactionLogWriteBehindNoSnapshotMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/snapshot/ReplicationTransactionLogWriteBehindSnapshotMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/snapshot/ReplicationTransactionLogWriteBehindSnapshotMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/snapshot/ReplicationTransactionLogWriteBehindSnapshotMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/snapshot/ReplicationTransactionLogWriteBehindSnapshotMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/snapshot/ReplicationTransactionLogWriteBehindSnapshotMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/snapshot/ReplicationTransactionLogWriteBehindSnapshotMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/snapshot/ReplicationTransactionLogWriteBehindSnapshotMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/snapshot/ReplicationTransactionLogWriteBehindSnapshotMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/nosnapshot/ReplicationTransactionLogWriteThroughNoSnapshotMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/nosnapshot/ReplicationTransactionLogWriteThroughNoSnapshotMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/nosnapshot/ReplicationTransactionLogWriteThroughNoSnapshotMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/nosnapshot/ReplicationTransactionLogWriteThroughNoSnapshotMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/nosnapshot/ReplicationTransactionLogWriteThroughNoSnapshotMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/nosnapshot/ReplicationTransactionLogWriteThroughNoSnapshotMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/nosnapshot/ReplicationTransactionLogWriteThroughNoSnapshotMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/nosnapshot/ReplicationTransactionLogWriteThroughNoSnapshotMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/snapshot/ReplicationTransactionLogWriteThroughSnapshotMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/snapshot/ReplicationTransactionLogWriteThroughSnapshotMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/snapshot/ReplicationTransactionLogWriteThroughSnapshotMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/snapshot/ReplicationTransactionLogWriteThroughSnapshotMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/snapshot/ReplicationTransactionLogWriteThroughSnapshotMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/snapshot/ReplicationTransactionLogWriteThroughSnapshotMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/snapshot/ReplicationTransactionLogWriteThroughSnapshotMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/snapshot/ReplicationTransactionLogWriteThroughSnapshotMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/failover/DirectRoutingFailoverMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/failover/DirectRoutingFailoverMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/failover/DirectRoutingFailoverMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/failover/DirectRoutingFailoverMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/failover/DirectRoutingFailoverMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/failover/DirectRoutingFailoverMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/failover/DirectRoutingFailoverMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/failover/DirectRoutingFailoverMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/homenode/HomeNodeMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/homenode/HomeNodeMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/homenode/HomeNodeMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/homenode/HomeNodeMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/homenode/HomeNodeMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/homenode/HomeNodeMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/homenode/HomeNodeMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/homenode/HomeNodeMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/normalusage/SingleReplicaDirectRoutingMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/normalusage/SingleReplicaDirectRoutingMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/normalusage/SingleReplicaDirectRoutingMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/normalusage/SingleReplicaDirectRoutingMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/normalusage/SingleReplicaDirectRoutingMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/normalusage/SingleReplicaDirectRoutingMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/normalusage/SingleReplicaDirectRoutingMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/normalusage/SingleReplicaDirectRoutingMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode1.opts
index d739389a77..f1306829d9 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991 -Dakka.event.force-sync=true
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991 -Dakka.event.force-sync=true
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode2.opts
index e32c0130f6..897e69f626 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992 -Dakka.event.force-sync=true
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992 -Dakka.event.force-sync=true
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode3.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode3.opts
index eba2597cdb..4127fb94fc 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode3.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode3.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node3 -Dakka.cluster.port=9993 -Dakka.event.force-sync=true
+-Dakka.cluster.nodename=node3 -Dakka.remote.port=9993 -Dakka.event.force-sync=true
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/homenode/HomeNodeMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/homenode/HomeNodeMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/homenode/HomeNodeMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/homenode/HomeNodeMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/homenode/HomeNodeMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/homenode/HomeNodeMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/homenode/HomeNodeMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/homenode/HomeNodeMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_1/Random1ReplicaMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_1/Random1ReplicaMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_1/Random1ReplicaMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_1/Random1ReplicaMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_3/Random3ReplicasMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_3/Random3ReplicasMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_3/Random3ReplicasMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_3/Random3ReplicasMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_3/Random3ReplicasMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_3/Random3ReplicasMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_3/Random3ReplicasMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_3/Random3ReplicasMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_3/Random3ReplicasMultiJvmNode3.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_3/Random3ReplicasMultiJvmNode3.opts
index 202496ad31..089e3b7776 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_3/Random3ReplicasMultiJvmNode3.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/replicationfactor_3/Random3ReplicasMultiJvmNode3.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node3 -Dakka.cluster.port=9993
+-Dakka.cluster.nodename=node3 -Dakka.remote.port=9993
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode1.opts
index d739389a77..f1306829d9 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991 -Dakka.event.force-sync=true
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991 -Dakka.event.force-sync=true
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode2.opts
index e32c0130f6..897e69f626 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992 -Dakka.event.force-sync=true
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992 -Dakka.event.force-sync=true
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode3.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode3.opts
index eba2597cdb..4127fb94fc 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode3.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode3.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node3 -Dakka.cluster.port=9993 -Dakka.event.force-sync=true
+-Dakka.cluster.nodename=node3 -Dakka.remote.port=9993 -Dakka.event.force-sync=true
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/homenode/HomeNodeMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/homenode/HomeNodeMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/homenode/HomeNodeMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/homenode/HomeNodeMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/homenode/HomeNodeMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/homenode/HomeNodeMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/homenode/HomeNodeMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/homenode/HomeNodeMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_1/RoundRobin1ReplicaMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_1/RoundRobin1ReplicaMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_1/RoundRobin1ReplicaMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_1/RoundRobin1ReplicaMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_2/RoundRobin2ReplicasMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_2/RoundRobin2ReplicasMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_2/RoundRobin2ReplicasMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_2/RoundRobin2ReplicasMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_2/RoundRobin2ReplicasMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_2/RoundRobin2ReplicasMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_2/RoundRobin2ReplicasMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_2/RoundRobin2ReplicasMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_2/RoundRobin2ReplicasMultiJvmSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_2/RoundRobin2ReplicasMultiJvmSpec.scala
index 7ad1305056..63a1f04ce7 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_2/RoundRobin2ReplicasMultiJvmSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_2/RoundRobin2ReplicasMultiJvmSpec.scala
@@ -45,7 +45,7 @@ class RoundRobin2ReplicasMultiJvmNode1 extends MasterClusterTestNode {
 
     "create clustered actor, get a 'local' actor on 'home' node and a 'ref' to actor on remote node" in {
       System.getProperty("akka.cluster.nodename", "") must be("node1")
-      System.getProperty("akka.cluster.port", "") must be("9991")
+      System.getProperty("akka.remote.port", "") must be("9991")
 
       //wait till node 1 has started.
       barrier("start-node1", NrOfNodes) {
@@ -76,7 +76,7 @@ class RoundRobin2ReplicasMultiJvmNode2 extends ClusterTestNode {
 
     "create clustered actor, get a 'local' actor on 'home' node and a 'ref' to actor on remote node" in {
       System.getProperty("akka.cluster.nodename", "") must be("node2")
-      System.getProperty("akka.cluster.port", "") must be("9992")
+      System.getProperty("akka.remote.port", "") must be("9992")
 
       //wait till node 1 has started.
       barrier("start-node1", NrOfNodes).await()
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_3/RoundRobin3ReplicasMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_3/RoundRobin3ReplicasMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_3/RoundRobin3ReplicasMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_3/RoundRobin3ReplicasMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_3/RoundRobin3ReplicasMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_3/RoundRobin3ReplicasMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_3/RoundRobin3ReplicasMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_3/RoundRobin3ReplicasMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_3/RoundRobin3ReplicasMultiJvmNode3.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_3/RoundRobin3ReplicasMultiJvmNode3.opts
index 202496ad31..089e3b7776 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_3/RoundRobin3ReplicasMultiJvmNode3.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/replicationfactor_3/RoundRobin3ReplicasMultiJvmNode3.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node3 -Dakka.cluster.port=9993
+-Dakka.cluster.nodename=node3 -Dakka.remote.port=9993
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/scattergather/failover/ScatterGatherFailoverMultiJvmNode1.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/scattergather/failover/ScatterGatherFailoverMultiJvmNode1.opts
index a88c260d8c..dc86c1c9c0 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/scattergather/failover/ScatterGatherFailoverMultiJvmNode1.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/scattergather/failover/ScatterGatherFailoverMultiJvmNode1.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+-Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/scattergather/failover/ScatterGatherFailoverMultiJvmNode2.opts b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/scattergather/failover/ScatterGatherFailoverMultiJvmNode2.opts
index f1e01f253d..bb140941a5 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/scattergather/failover/ScatterGatherFailoverMultiJvmNode2.opts
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/routing/scattergather/failover/ScatterGatherFailoverMultiJvmNode2.opts
@@ -1 +1 @@
--Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+-Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
diff --git a/akka-docs/dev/multi-jvm-testing.rst b/akka-docs/dev/multi-jvm-testing.rst
index 9eb036aea5..7e79f65bfa 100644
--- a/akka-docs/dev/multi-jvm-testing.rst
+++ b/akka-docs/dev/multi-jvm-testing.rst
@@ -160,20 +160,20 @@ a file named after the node in the test with suffix ``.opts`` and put them in th
 directory as the test.
 
 For example, to feed the JVM options ``-Dakka.cluster.nodename=node1`` and
-``-Dakka.cluster.port=9991`` to the ``SampleMultiJvmNode1`` let's create three ``*.opts`` files
+``-Dakka.remote.port=9991`` to the ``SampleMultiJvmNode1`` let's create three ``*.opts`` files
 and add the options to them.
 
 ``SampleMultiJvmNode1.opts``::
 
-    -Dakka.cluster.nodename=node1 -Dakka.cluster.port=9991
+    -Dakka.cluster.nodename=node1 -Dakka.remote.port=9991
 
 ``SampleMultiJvmNode2.opts``::
 
-    -Dakka.cluster.nodename=node2 -Dakka.cluster.port=9992
+    -Dakka.cluster.nodename=node2 -Dakka.remote.port=9992
 
 ``SampleMultiJvmNode3.opts``::
 
-    -Dakka.cluster.nodename=node3 -Dakka.cluster.port=9993
+    -Dakka.cluster.nodename=node3 -Dakka.remote.port=9993
 
 
 Overriding akka.conf options
@@ -278,7 +278,7 @@ something in coordination::
 
         "have jvm options" in {
           System.getProperty("akka.cluster.nodename", "") must be("node1")
-          System.getProperty("akka.cluster.port", "") must be("9991")
+          System.getProperty("akka.remote.port", "") must be("9991")
           akka.config.Config.config.getString("test.name", "") must be("node1")
         }
 
@@ -299,7 +299,7 @@ something in coordination::
 
         "have jvm options" in {
           System.getProperty("akka.cluster.nodename", "") must be("node2")
-          System.getProperty("akka.cluster.port", "") must be("9992")
+          System.getProperty("akka.remote.port", "") must be("9992")
           akka.config.Config.config.getString("test.name", "") must be("node2")
         }
 
diff --git a/akka-docs/modules/spring.rst b/akka-docs/modules/spring.rst
index d8ec97b72c..29bf4632cf 100644
--- a/akka-docs/modules/spring.rst
+++ b/akka-docs/modules/spring.rst
@@ -323,7 +323,7 @@ The Akka configuration can be made available as property placeholders by using a
   <akka:property-placeholder location="akka.conf"/>
 
   <akka:untyped-actor id="actor-1" implementation="com.biz.MyActor" timeout="${akka.actor.timeout}">
-    <akka:remote host="${akka.cluster.server.hostname}" port="${akka.cluster.server.port}"/>
+    <akka:remote host="${akka.remote.server.hostname}" port="${akka.remote.server.port}"/>
   </akka:untyped-actor>
 
 Camel configuration
diff --git a/akka-docs/scala/actors.rst b/akka-docs/scala/actors.rst
index 747efc6d68..8f3ea20094 100644
--- a/akka-docs/scala/actors.rst
+++ b/akka-docs/scala/actors.rst
@@ -34,7 +34,7 @@ Here is an example:
 
   import akka.actor.Actor
   import akka.event.EventHandler
-  
+
   class MyActor extends Actor {
     def receive = {
       case "test" => EventHandler.info(this, "received test")
@@ -149,7 +149,7 @@ mailbox and the hotswap stack are unaffected by the restart, so processing of
 messages will resume after the :meth:`postRestart` hook returns. Any message
 sent to an actor while it is being restarted will be queued to its mailbox as
 usual.
- 
+
 Stop Hook
 ^^^^^^^^^
 
@@ -207,6 +207,8 @@ Messages are sent to an Actor through one of the following methods.
     additionally the old method could defer possible type cast problems into
     seemingly unrelated parts of the code base.
 
+Message ordering is guaranteed on a per-sender basis.
+
 Fire-forget
 ^^^^^^^^^^^
 
@@ -628,16 +630,16 @@ In generic base Actor:
 .. code-block:: scala
 
   import akka.actor.Actor.Receive
-  
+
   abstract class GenericActor extends Actor {
     // to be defined in subclassing actor
     def specificMessageHandler: Receive
-   
+
     // generic message handler
     def genericMessageHandler: Receive = {
       case event => printf("generic: %s\n", event)
     }
-   
+
     def receive = specificMessageHandler orElse genericMessageHandler
   }
 
@@ -650,5 +652,5 @@ In subclassing Actor:
       case event: MyMsg  => printf("specific: %s\n", event.subject)
     }
   }
-  
+
   case class MyMsg(subject: String)
diff --git a/akka-remote/src/main/java/akka/cluster/RemoteProtocol.java b/akka-remote/src/main/java/akka/remote/RemoteProtocol.java
similarity index 78%
rename from akka-remote/src/main/java/akka/cluster/RemoteProtocol.java
rename to akka-remote/src/main/java/akka/remote/RemoteProtocol.java
index 5db4c0f892..308d167217 100644
--- a/akka-remote/src/main/java/akka/cluster/RemoteProtocol.java
+++ b/akka-remote/src/main/java/akka/remote/RemoteProtocol.java
@@ -1,7 +1,7 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: RemoteProtocol.proto
 
-package akka.cluster;
+package akka.remote;
 
 public final class RemoteProtocol {
   private RemoteProtocol() {}
@@ -50,7 +50,7 @@ public final class RemoteProtocol {
     }
     public static final com.google.protobuf.Descriptors.EnumDescriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.getDescriptor().getEnumTypes().get(0);
+      return akka.remote.RemoteProtocol.getDescriptor().getEnumTypes().get(0);
     }
     
     private static final CommandType[] VALUES = {
@@ -122,7 +122,7 @@ public final class RemoteProtocol {
     }
     public static final com.google.protobuf.Descriptors.EnumDescriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.getDescriptor().getEnumTypes().get(1);
+      return akka.remote.RemoteProtocol.getDescriptor().getEnumTypes().get(1);
     }
     
     private static final ReplicationStorageType[] VALUES = {
@@ -191,7 +191,7 @@ public final class RemoteProtocol {
     }
     public static final com.google.protobuf.Descriptors.EnumDescriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.getDescriptor().getEnumTypes().get(2);
+      return akka.remote.RemoteProtocol.getDescriptor().getEnumTypes().get(2);
     }
     
     private static final ReplicationStrategyType[] VALUES = {
@@ -269,7 +269,7 @@ public final class RemoteProtocol {
     }
     public static final com.google.protobuf.Descriptors.EnumDescriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.getDescriptor().getEnumTypes().get(3);
+      return akka.remote.RemoteProtocol.getDescriptor().getEnumTypes().get(3);
     }
     
     private static final SerializationSchemeType[] VALUES = {
@@ -338,7 +338,7 @@ public final class RemoteProtocol {
     }
     public static final com.google.protobuf.Descriptors.EnumDescriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.getDescriptor().getEnumTypes().get(4);
+      return akka.remote.RemoteProtocol.getDescriptor().getEnumTypes().get(4);
     }
     
     private static final LifeCycleType[] VALUES = {
@@ -440,7 +440,7 @@ public final class RemoteProtocol {
     }
     public static final com.google.protobuf.Descriptors.EnumDescriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.getDescriptor().getEnumTypes().get(5);
+      return akka.remote.RemoteProtocol.getDescriptor().getEnumTypes().get(5);
     }
     
     private static final RemoteDaemonMessageType[] VALUES = {
@@ -472,13 +472,13 @@ public final class RemoteProtocol {
     
     // optional .RemoteMessageProtocol message = 1;
     boolean hasMessage();
-    akka.cluster.RemoteProtocol.RemoteMessageProtocol getMessage();
-    akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessageOrBuilder();
+    akka.remote.RemoteProtocol.RemoteMessageProtocol getMessage();
+    akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessageOrBuilder();
     
     // optional .RemoteControlProtocol instruction = 2;
     boolean hasInstruction();
-    akka.cluster.RemoteProtocol.RemoteControlProtocol getInstruction();
-    akka.cluster.RemoteProtocol.RemoteControlProtocolOrBuilder getInstructionOrBuilder();
+    akka.remote.RemoteProtocol.RemoteControlProtocol getInstruction();
+    akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder getInstructionOrBuilder();
   }
   public static final class AkkaRemoteProtocol extends
       com.google.protobuf.GeneratedMessage
@@ -500,44 +500,44 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_AkkaRemoteProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_AkkaRemoteProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_AkkaRemoteProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_AkkaRemoteProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
     // optional .RemoteMessageProtocol message = 1;
     public static final int MESSAGE_FIELD_NUMBER = 1;
-    private akka.cluster.RemoteProtocol.RemoteMessageProtocol message_;
+    private akka.remote.RemoteProtocol.RemoteMessageProtocol message_;
     public boolean hasMessage() {
       return ((bitField0_ & 0x00000001) == 0x00000001);
     }
-    public akka.cluster.RemoteProtocol.RemoteMessageProtocol getMessage() {
+    public akka.remote.RemoteProtocol.RemoteMessageProtocol getMessage() {
       return message_;
     }
-    public akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessageOrBuilder() {
+    public akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessageOrBuilder() {
       return message_;
     }
     
     // optional .RemoteControlProtocol instruction = 2;
     public static final int INSTRUCTION_FIELD_NUMBER = 2;
-    private akka.cluster.RemoteProtocol.RemoteControlProtocol instruction_;
+    private akka.remote.RemoteProtocol.RemoteControlProtocol instruction_;
     public boolean hasInstruction() {
       return ((bitField0_ & 0x00000002) == 0x00000002);
     }
-    public akka.cluster.RemoteProtocol.RemoteControlProtocol getInstruction() {
+    public akka.remote.RemoteProtocol.RemoteControlProtocol getInstruction() {
       return instruction_;
     }
-    public akka.cluster.RemoteProtocol.RemoteControlProtocolOrBuilder getInstructionOrBuilder() {
+    public akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder getInstructionOrBuilder() {
       return instruction_;
     }
     
     private void initFields() {
-      message_ = akka.cluster.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
-      instruction_ = akka.cluster.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
+      message_ = akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
+      instruction_ = akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
     }
     private byte memoizedIsInitialized = -1;
     public final boolean isInitialized() {
@@ -598,41 +598,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.AkkaRemoteProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.AkkaRemoteProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AkkaRemoteProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.AkkaRemoteProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AkkaRemoteProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.AkkaRemoteProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AkkaRemoteProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.AkkaRemoteProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AkkaRemoteProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.AkkaRemoteProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AkkaRemoteProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.AkkaRemoteProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AkkaRemoteProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.AkkaRemoteProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -641,7 +641,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.AkkaRemoteProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.AkkaRemoteProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -652,12 +652,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.AkkaRemoteProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.AkkaRemoteProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AkkaRemoteProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.AkkaRemoteProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -667,7 +667,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.AkkaRemoteProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.AkkaRemoteProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -680,23 +680,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.AkkaRemoteProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.AkkaRemoteProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_AkkaRemoteProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_AkkaRemoteProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_AkkaRemoteProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_AkkaRemoteProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.AkkaRemoteProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.AkkaRemoteProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -713,13 +713,13 @@ public final class RemoteProtocol {
       public Builder clear() {
         super.clear();
         if (messageBuilder_ == null) {
-          message_ = akka.cluster.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
+          message_ = akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
         } else {
           messageBuilder_.clear();
         }
         bitField0_ = (bitField0_ & ~0x00000001);
         if (instructionBuilder_ == null) {
-          instruction_ = akka.cluster.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
+          instruction_ = akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
         } else {
           instructionBuilder_.clear();
         }
@@ -733,24 +733,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.AkkaRemoteProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.AkkaRemoteProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.AkkaRemoteProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.AkkaRemoteProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.AkkaRemoteProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.AkkaRemoteProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.AkkaRemoteProtocol build() {
-        akka.cluster.RemoteProtocol.AkkaRemoteProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.AkkaRemoteProtocol build() {
+        akka.remote.RemoteProtocol.AkkaRemoteProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.AkkaRemoteProtocol buildParsed()
+      private akka.remote.RemoteProtocol.AkkaRemoteProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.AkkaRemoteProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.AkkaRemoteProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -758,8 +758,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.AkkaRemoteProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.AkkaRemoteProtocol result = new akka.cluster.RemoteProtocol.AkkaRemoteProtocol(this);
+      public akka.remote.RemoteProtocol.AkkaRemoteProtocol buildPartial() {
+        akka.remote.RemoteProtocol.AkkaRemoteProtocol result = new akka.remote.RemoteProtocol.AkkaRemoteProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -784,16 +784,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.AkkaRemoteProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.AkkaRemoteProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.AkkaRemoteProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.AkkaRemoteProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.AkkaRemoteProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.AkkaRemoteProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.AkkaRemoteProtocol other) {
+        if (other == akka.remote.RemoteProtocol.AkkaRemoteProtocol.getDefaultInstance()) return this;
         if (other.hasMessage()) {
           mergeMessage(other.getMessage());
         }
@@ -844,7 +844,7 @@ public final class RemoteProtocol {
               break;
             }
             case 10: {
-              akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.RemoteMessageProtocol.newBuilder();
+              akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder subBuilder = akka.remote.RemoteProtocol.RemoteMessageProtocol.newBuilder();
               if (hasMessage()) {
                 subBuilder.mergeFrom(getMessage());
               }
@@ -853,7 +853,7 @@ public final class RemoteProtocol {
               break;
             }
             case 18: {
-              akka.cluster.RemoteProtocol.RemoteControlProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.RemoteControlProtocol.newBuilder();
+              akka.remote.RemoteProtocol.RemoteControlProtocol.Builder subBuilder = akka.remote.RemoteProtocol.RemoteControlProtocol.newBuilder();
               if (hasInstruction()) {
                 subBuilder.mergeFrom(getInstruction());
               }
@@ -868,20 +868,20 @@ public final class RemoteProtocol {
       private int bitField0_;
       
       // optional .RemoteMessageProtocol message = 1;
-      private akka.cluster.RemoteProtocol.RemoteMessageProtocol message_ = akka.cluster.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.RemoteMessageProtocol message_ = akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.RemoteMessageProtocol, akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder, akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder> messageBuilder_;
+          akka.remote.RemoteProtocol.RemoteMessageProtocol, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder, akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder> messageBuilder_;
       public boolean hasMessage() {
         return ((bitField0_ & 0x00000001) == 0x00000001);
       }
-      public akka.cluster.RemoteProtocol.RemoteMessageProtocol getMessage() {
+      public akka.remote.RemoteProtocol.RemoteMessageProtocol getMessage() {
         if (messageBuilder_ == null) {
           return message_;
         } else {
           return messageBuilder_.getMessage();
         }
       }
-      public Builder setMessage(akka.cluster.RemoteProtocol.RemoteMessageProtocol value) {
+      public Builder setMessage(akka.remote.RemoteProtocol.RemoteMessageProtocol value) {
         if (messageBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -895,7 +895,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setMessage(
-          akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
         if (messageBuilder_ == null) {
           message_ = builderForValue.build();
           onChanged();
@@ -905,12 +905,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000001;
         return this;
       }
-      public Builder mergeMessage(akka.cluster.RemoteProtocol.RemoteMessageProtocol value) {
+      public Builder mergeMessage(akka.remote.RemoteProtocol.RemoteMessageProtocol value) {
         if (messageBuilder_ == null) {
           if (((bitField0_ & 0x00000001) == 0x00000001) &&
-              message_ != akka.cluster.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance()) {
+              message_ != akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance()) {
             message_ =
-              akka.cluster.RemoteProtocol.RemoteMessageProtocol.newBuilder(message_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.RemoteMessageProtocol.newBuilder(message_).mergeFrom(value).buildPartial();
           } else {
             message_ = value;
           }
@@ -923,7 +923,7 @@ public final class RemoteProtocol {
       }
       public Builder clearMessage() {
         if (messageBuilder_ == null) {
-          message_ = akka.cluster.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
+          message_ = akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
           onChanged();
         } else {
           messageBuilder_.clear();
@@ -931,12 +931,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000001);
         return this;
       }
-      public akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder getMessageBuilder() {
+      public akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder getMessageBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getMessageFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessageOrBuilder() {
+      public akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessageOrBuilder() {
         if (messageBuilder_ != null) {
           return messageBuilder_.getMessageOrBuilder();
         } else {
@@ -944,11 +944,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.RemoteMessageProtocol, akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder, akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.RemoteMessageProtocol, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder, akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder> 
           getMessageFieldBuilder() {
         if (messageBuilder_ == null) {
           messageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.RemoteMessageProtocol, akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder, akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.RemoteMessageProtocol, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder, akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder>(
                   message_,
                   getParentForChildren(),
                   isClean());
@@ -958,20 +958,20 @@ public final class RemoteProtocol {
       }
       
       // optional .RemoteControlProtocol instruction = 2;
-      private akka.cluster.RemoteProtocol.RemoteControlProtocol instruction_ = akka.cluster.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.RemoteControlProtocol instruction_ = akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.RemoteControlProtocol, akka.cluster.RemoteProtocol.RemoteControlProtocol.Builder, akka.cluster.RemoteProtocol.RemoteControlProtocolOrBuilder> instructionBuilder_;
+          akka.remote.RemoteProtocol.RemoteControlProtocol, akka.remote.RemoteProtocol.RemoteControlProtocol.Builder, akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder> instructionBuilder_;
       public boolean hasInstruction() {
         return ((bitField0_ & 0x00000002) == 0x00000002);
       }
-      public akka.cluster.RemoteProtocol.RemoteControlProtocol getInstruction() {
+      public akka.remote.RemoteProtocol.RemoteControlProtocol getInstruction() {
         if (instructionBuilder_ == null) {
           return instruction_;
         } else {
           return instructionBuilder_.getMessage();
         }
       }
-      public Builder setInstruction(akka.cluster.RemoteProtocol.RemoteControlProtocol value) {
+      public Builder setInstruction(akka.remote.RemoteProtocol.RemoteControlProtocol value) {
         if (instructionBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -985,7 +985,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setInstruction(
-          akka.cluster.RemoteProtocol.RemoteControlProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.RemoteControlProtocol.Builder builderForValue) {
         if (instructionBuilder_ == null) {
           instruction_ = builderForValue.build();
           onChanged();
@@ -995,12 +995,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000002;
         return this;
       }
-      public Builder mergeInstruction(akka.cluster.RemoteProtocol.RemoteControlProtocol value) {
+      public Builder mergeInstruction(akka.remote.RemoteProtocol.RemoteControlProtocol value) {
         if (instructionBuilder_ == null) {
           if (((bitField0_ & 0x00000002) == 0x00000002) &&
-              instruction_ != akka.cluster.RemoteProtocol.RemoteControlProtocol.getDefaultInstance()) {
+              instruction_ != akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance()) {
             instruction_ =
-              akka.cluster.RemoteProtocol.RemoteControlProtocol.newBuilder(instruction_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.RemoteControlProtocol.newBuilder(instruction_).mergeFrom(value).buildPartial();
           } else {
             instruction_ = value;
           }
@@ -1013,7 +1013,7 @@ public final class RemoteProtocol {
       }
       public Builder clearInstruction() {
         if (instructionBuilder_ == null) {
-          instruction_ = akka.cluster.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
+          instruction_ = akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
           onChanged();
         } else {
           instructionBuilder_.clear();
@@ -1021,12 +1021,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000002);
         return this;
       }
-      public akka.cluster.RemoteProtocol.RemoteControlProtocol.Builder getInstructionBuilder() {
+      public akka.remote.RemoteProtocol.RemoteControlProtocol.Builder getInstructionBuilder() {
         bitField0_ |= 0x00000002;
         onChanged();
         return getInstructionFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.RemoteControlProtocolOrBuilder getInstructionOrBuilder() {
+      public akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder getInstructionOrBuilder() {
         if (instructionBuilder_ != null) {
           return instructionBuilder_.getMessageOrBuilder();
         } else {
@@ -1034,11 +1034,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.RemoteControlProtocol, akka.cluster.RemoteProtocol.RemoteControlProtocol.Builder, akka.cluster.RemoteProtocol.RemoteControlProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.RemoteControlProtocol, akka.remote.RemoteProtocol.RemoteControlProtocol.Builder, akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder> 
           getInstructionFieldBuilder() {
         if (instructionBuilder_ == null) {
           instructionBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.RemoteControlProtocol, akka.cluster.RemoteProtocol.RemoteControlProtocol.Builder, akka.cluster.RemoteProtocol.RemoteControlProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.RemoteControlProtocol, akka.remote.RemoteProtocol.RemoteControlProtocol.Builder, akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder>(
                   instruction_,
                   getParentForChildren(),
                   isClean());
@@ -1063,13 +1063,13 @@ public final class RemoteProtocol {
     
     // required .UuidProtocol uuid = 1;
     boolean hasUuid();
-    akka.cluster.RemoteProtocol.UuidProtocol getUuid();
-    akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder();
+    akka.remote.RemoteProtocol.UuidProtocol getUuid();
+    akka.remote.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder();
     
     // required .ActorInfoProtocol actorInfo = 2;
     boolean hasActorInfo();
-    akka.cluster.RemoteProtocol.ActorInfoProtocol getActorInfo();
-    akka.cluster.RemoteProtocol.ActorInfoProtocolOrBuilder getActorInfoOrBuilder();
+    akka.remote.RemoteProtocol.ActorInfoProtocol getActorInfo();
+    akka.remote.RemoteProtocol.ActorInfoProtocolOrBuilder getActorInfoOrBuilder();
     
     // required bool oneWay = 3;
     boolean hasOneWay();
@@ -1077,32 +1077,32 @@ public final class RemoteProtocol {
     
     // optional .MessageProtocol message = 4;
     boolean hasMessage();
-    akka.cluster.RemoteProtocol.MessageProtocol getMessage();
-    akka.cluster.RemoteProtocol.MessageProtocolOrBuilder getMessageOrBuilder();
+    akka.remote.RemoteProtocol.MessageProtocol getMessage();
+    akka.remote.RemoteProtocol.MessageProtocolOrBuilder getMessageOrBuilder();
     
     // optional .ExceptionProtocol exception = 5;
     boolean hasException();
-    akka.cluster.RemoteProtocol.ExceptionProtocol getException();
-    akka.cluster.RemoteProtocol.ExceptionProtocolOrBuilder getExceptionOrBuilder();
+    akka.remote.RemoteProtocol.ExceptionProtocol getException();
+    akka.remote.RemoteProtocol.ExceptionProtocolOrBuilder getExceptionOrBuilder();
     
     // optional .UuidProtocol supervisorUuid = 6;
     boolean hasSupervisorUuid();
-    akka.cluster.RemoteProtocol.UuidProtocol getSupervisorUuid();
-    akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getSupervisorUuidOrBuilder();
+    akka.remote.RemoteProtocol.UuidProtocol getSupervisorUuid();
+    akka.remote.RemoteProtocol.UuidProtocolOrBuilder getSupervisorUuidOrBuilder();
     
     // optional .RemoteActorRefProtocol sender = 7;
     boolean hasSender();
-    akka.cluster.RemoteProtocol.RemoteActorRefProtocol getSender();
-    akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder getSenderOrBuilder();
+    akka.remote.RemoteProtocol.RemoteActorRefProtocol getSender();
+    akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder getSenderOrBuilder();
     
     // repeated .MetadataEntryProtocol metadata = 8;
-    java.util.List<akka.cluster.RemoteProtocol.MetadataEntryProtocol> 
+    java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> 
         getMetadataList();
-    akka.cluster.RemoteProtocol.MetadataEntryProtocol getMetadata(int index);
+    akka.remote.RemoteProtocol.MetadataEntryProtocol getMetadata(int index);
     int getMetadataCount();
-    java.util.List<? extends akka.cluster.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
+    java.util.List<? extends akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
         getMetadataOrBuilderList();
-    akka.cluster.RemoteProtocol.MetadataEntryProtocolOrBuilder getMetadataOrBuilder(
+    akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder getMetadataOrBuilder(
         int index);
   }
   public static final class RemoteMessageProtocol extends
@@ -1125,38 +1125,38 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_RemoteMessageProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_RemoteMessageProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_RemoteMessageProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_RemoteMessageProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
     // required .UuidProtocol uuid = 1;
     public static final int UUID_FIELD_NUMBER = 1;
-    private akka.cluster.RemoteProtocol.UuidProtocol uuid_;
+    private akka.remote.RemoteProtocol.UuidProtocol uuid_;
     public boolean hasUuid() {
       return ((bitField0_ & 0x00000001) == 0x00000001);
     }
-    public akka.cluster.RemoteProtocol.UuidProtocol getUuid() {
+    public akka.remote.RemoteProtocol.UuidProtocol getUuid() {
       return uuid_;
     }
-    public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder() {
+    public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder() {
       return uuid_;
     }
     
     // required .ActorInfoProtocol actorInfo = 2;
     public static final int ACTORINFO_FIELD_NUMBER = 2;
-    private akka.cluster.RemoteProtocol.ActorInfoProtocol actorInfo_;
+    private akka.remote.RemoteProtocol.ActorInfoProtocol actorInfo_;
     public boolean hasActorInfo() {
       return ((bitField0_ & 0x00000002) == 0x00000002);
     }
-    public akka.cluster.RemoteProtocol.ActorInfoProtocol getActorInfo() {
+    public akka.remote.RemoteProtocol.ActorInfoProtocol getActorInfo() {
       return actorInfo_;
     }
-    public akka.cluster.RemoteProtocol.ActorInfoProtocolOrBuilder getActorInfoOrBuilder() {
+    public akka.remote.RemoteProtocol.ActorInfoProtocolOrBuilder getActorInfoOrBuilder() {
       return actorInfo_;
     }
     
@@ -1172,85 +1172,85 @@ public final class RemoteProtocol {
     
     // optional .MessageProtocol message = 4;
     public static final int MESSAGE_FIELD_NUMBER = 4;
-    private akka.cluster.RemoteProtocol.MessageProtocol message_;
+    private akka.remote.RemoteProtocol.MessageProtocol message_;
     public boolean hasMessage() {
       return ((bitField0_ & 0x00000008) == 0x00000008);
     }
-    public akka.cluster.RemoteProtocol.MessageProtocol getMessage() {
+    public akka.remote.RemoteProtocol.MessageProtocol getMessage() {
       return message_;
     }
-    public akka.cluster.RemoteProtocol.MessageProtocolOrBuilder getMessageOrBuilder() {
+    public akka.remote.RemoteProtocol.MessageProtocolOrBuilder getMessageOrBuilder() {
       return message_;
     }
     
     // optional .ExceptionProtocol exception = 5;
     public static final int EXCEPTION_FIELD_NUMBER = 5;
-    private akka.cluster.RemoteProtocol.ExceptionProtocol exception_;
+    private akka.remote.RemoteProtocol.ExceptionProtocol exception_;
     public boolean hasException() {
       return ((bitField0_ & 0x00000010) == 0x00000010);
     }
-    public akka.cluster.RemoteProtocol.ExceptionProtocol getException() {
+    public akka.remote.RemoteProtocol.ExceptionProtocol getException() {
       return exception_;
     }
-    public akka.cluster.RemoteProtocol.ExceptionProtocolOrBuilder getExceptionOrBuilder() {
+    public akka.remote.RemoteProtocol.ExceptionProtocolOrBuilder getExceptionOrBuilder() {
       return exception_;
     }
     
     // optional .UuidProtocol supervisorUuid = 6;
     public static final int SUPERVISORUUID_FIELD_NUMBER = 6;
-    private akka.cluster.RemoteProtocol.UuidProtocol supervisorUuid_;
+    private akka.remote.RemoteProtocol.UuidProtocol supervisorUuid_;
     public boolean hasSupervisorUuid() {
       return ((bitField0_ & 0x00000020) == 0x00000020);
     }
-    public akka.cluster.RemoteProtocol.UuidProtocol getSupervisorUuid() {
+    public akka.remote.RemoteProtocol.UuidProtocol getSupervisorUuid() {
       return supervisorUuid_;
     }
-    public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getSupervisorUuidOrBuilder() {
+    public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getSupervisorUuidOrBuilder() {
       return supervisorUuid_;
     }
     
     // optional .RemoteActorRefProtocol sender = 7;
     public static final int SENDER_FIELD_NUMBER = 7;
-    private akka.cluster.RemoteProtocol.RemoteActorRefProtocol sender_;
+    private akka.remote.RemoteProtocol.RemoteActorRefProtocol sender_;
     public boolean hasSender() {
       return ((bitField0_ & 0x00000040) == 0x00000040);
     }
-    public akka.cluster.RemoteProtocol.RemoteActorRefProtocol getSender() {
+    public akka.remote.RemoteProtocol.RemoteActorRefProtocol getSender() {
       return sender_;
     }
-    public akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder getSenderOrBuilder() {
+    public akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder getSenderOrBuilder() {
       return sender_;
     }
     
     // repeated .MetadataEntryProtocol metadata = 8;
     public static final int METADATA_FIELD_NUMBER = 8;
-    private java.util.List<akka.cluster.RemoteProtocol.MetadataEntryProtocol> metadata_;
-    public java.util.List<akka.cluster.RemoteProtocol.MetadataEntryProtocol> getMetadataList() {
+    private java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> metadata_;
+    public java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> getMetadataList() {
       return metadata_;
     }
-    public java.util.List<? extends akka.cluster.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
+    public java.util.List<? extends akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
         getMetadataOrBuilderList() {
       return metadata_;
     }
     public int getMetadataCount() {
       return metadata_.size();
     }
-    public akka.cluster.RemoteProtocol.MetadataEntryProtocol getMetadata(int index) {
+    public akka.remote.RemoteProtocol.MetadataEntryProtocol getMetadata(int index) {
       return metadata_.get(index);
     }
-    public akka.cluster.RemoteProtocol.MetadataEntryProtocolOrBuilder getMetadataOrBuilder(
+    public akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder getMetadataOrBuilder(
         int index) {
       return metadata_.get(index);
     }
     
     private void initFields() {
-      uuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
-      actorInfo_ = akka.cluster.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
+      uuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      actorInfo_ = akka.remote.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
       oneWay_ = false;
-      message_ = akka.cluster.RemoteProtocol.MessageProtocol.getDefaultInstance();
-      exception_ = akka.cluster.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
-      supervisorUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
-      sender_ = akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
+      message_ = akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
+      exception_ = akka.remote.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
+      supervisorUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      sender_ = akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
       metadata_ = java.util.Collections.emptyList();
     }
     private byte memoizedIsInitialized = -1;
@@ -1392,41 +1392,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.RemoteMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteMessageProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteMessageProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteMessageProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.RemoteMessageProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteMessageProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteMessageProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.RemoteMessageProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteMessageProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteMessageProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.RemoteMessageProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -1435,7 +1435,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.RemoteMessageProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.RemoteMessageProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -1446,12 +1446,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.RemoteMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteMessageProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteMessageProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -1461,7 +1461,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.RemoteMessageProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.RemoteMessageProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -1474,23 +1474,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_RemoteMessageProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_RemoteMessageProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_RemoteMessageProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_RemoteMessageProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.RemoteMessageProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.RemoteMessageProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -1512,13 +1512,13 @@ public final class RemoteProtocol {
       public Builder clear() {
         super.clear();
         if (uuidBuilder_ == null) {
-          uuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          uuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
         } else {
           uuidBuilder_.clear();
         }
         bitField0_ = (bitField0_ & ~0x00000001);
         if (actorInfoBuilder_ == null) {
-          actorInfo_ = akka.cluster.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
+          actorInfo_ = akka.remote.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
         } else {
           actorInfoBuilder_.clear();
         }
@@ -1526,25 +1526,25 @@ public final class RemoteProtocol {
         oneWay_ = false;
         bitField0_ = (bitField0_ & ~0x00000004);
         if (messageBuilder_ == null) {
-          message_ = akka.cluster.RemoteProtocol.MessageProtocol.getDefaultInstance();
+          message_ = akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
         } else {
           messageBuilder_.clear();
         }
         bitField0_ = (bitField0_ & ~0x00000008);
         if (exceptionBuilder_ == null) {
-          exception_ = akka.cluster.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
+          exception_ = akka.remote.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
         } else {
           exceptionBuilder_.clear();
         }
         bitField0_ = (bitField0_ & ~0x00000010);
         if (supervisorUuidBuilder_ == null) {
-          supervisorUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          supervisorUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
         } else {
           supervisorUuidBuilder_.clear();
         }
         bitField0_ = (bitField0_ & ~0x00000020);
         if (senderBuilder_ == null) {
-          sender_ = akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
+          sender_ = akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
         } else {
           senderBuilder_.clear();
         }
@@ -1564,24 +1564,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.RemoteMessageProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.RemoteMessageProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.RemoteMessageProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.RemoteMessageProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.RemoteMessageProtocol build() {
-        akka.cluster.RemoteProtocol.RemoteMessageProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.RemoteMessageProtocol build() {
+        akka.remote.RemoteProtocol.RemoteMessageProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.RemoteMessageProtocol buildParsed()
+      private akka.remote.RemoteProtocol.RemoteMessageProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.RemoteMessageProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.RemoteMessageProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -1589,8 +1589,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.RemoteMessageProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.RemoteMessageProtocol result = new akka.cluster.RemoteProtocol.RemoteMessageProtocol(this);
+      public akka.remote.RemoteProtocol.RemoteMessageProtocol buildPartial() {
+        akka.remote.RemoteProtocol.RemoteMessageProtocol result = new akka.remote.RemoteProtocol.RemoteMessageProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -1660,16 +1660,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.RemoteMessageProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.RemoteMessageProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.RemoteMessageProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.RemoteMessageProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.RemoteMessageProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.RemoteMessageProtocol other) {
+        if (other == akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance()) return this;
         if (other.hasUuid()) {
           mergeUuid(other.getUuid());
         }
@@ -1799,7 +1799,7 @@ public final class RemoteProtocol {
               break;
             }
             case 10: {
-              akka.cluster.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.UuidProtocol.newBuilder();
+              akka.remote.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.RemoteProtocol.UuidProtocol.newBuilder();
               if (hasUuid()) {
                 subBuilder.mergeFrom(getUuid());
               }
@@ -1808,7 +1808,7 @@ public final class RemoteProtocol {
               break;
             }
             case 18: {
-              akka.cluster.RemoteProtocol.ActorInfoProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.ActorInfoProtocol.newBuilder();
+              akka.remote.RemoteProtocol.ActorInfoProtocol.Builder subBuilder = akka.remote.RemoteProtocol.ActorInfoProtocol.newBuilder();
               if (hasActorInfo()) {
                 subBuilder.mergeFrom(getActorInfo());
               }
@@ -1822,7 +1822,7 @@ public final class RemoteProtocol {
               break;
             }
             case 34: {
-              akka.cluster.RemoteProtocol.MessageProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.MessageProtocol.newBuilder();
+              akka.remote.RemoteProtocol.MessageProtocol.Builder subBuilder = akka.remote.RemoteProtocol.MessageProtocol.newBuilder();
               if (hasMessage()) {
                 subBuilder.mergeFrom(getMessage());
               }
@@ -1831,7 +1831,7 @@ public final class RemoteProtocol {
               break;
             }
             case 42: {
-              akka.cluster.RemoteProtocol.ExceptionProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.ExceptionProtocol.newBuilder();
+              akka.remote.RemoteProtocol.ExceptionProtocol.Builder subBuilder = akka.remote.RemoteProtocol.ExceptionProtocol.newBuilder();
               if (hasException()) {
                 subBuilder.mergeFrom(getException());
               }
@@ -1840,7 +1840,7 @@ public final class RemoteProtocol {
               break;
             }
             case 50: {
-              akka.cluster.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.UuidProtocol.newBuilder();
+              akka.remote.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.RemoteProtocol.UuidProtocol.newBuilder();
               if (hasSupervisorUuid()) {
                 subBuilder.mergeFrom(getSupervisorUuid());
               }
@@ -1849,7 +1849,7 @@ public final class RemoteProtocol {
               break;
             }
             case 58: {
-              akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.RemoteActorRefProtocol.newBuilder();
+              akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder subBuilder = akka.remote.RemoteProtocol.RemoteActorRefProtocol.newBuilder();
               if (hasSender()) {
                 subBuilder.mergeFrom(getSender());
               }
@@ -1858,7 +1858,7 @@ public final class RemoteProtocol {
               break;
             }
             case 66: {
-              akka.cluster.RemoteProtocol.MetadataEntryProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.MetadataEntryProtocol.newBuilder();
+              akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder subBuilder = akka.remote.RemoteProtocol.MetadataEntryProtocol.newBuilder();
               input.readMessage(subBuilder, extensionRegistry);
               addMetadata(subBuilder.buildPartial());
               break;
@@ -1870,20 +1870,20 @@ public final class RemoteProtocol {
       private int bitField0_;
       
       // required .UuidProtocol uuid = 1;
-      private akka.cluster.RemoteProtocol.UuidProtocol uuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.UuidProtocol uuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> uuidBuilder_;
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> uuidBuilder_;
       public boolean hasUuid() {
         return ((bitField0_ & 0x00000001) == 0x00000001);
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol getUuid() {
+      public akka.remote.RemoteProtocol.UuidProtocol getUuid() {
         if (uuidBuilder_ == null) {
           return uuid_;
         } else {
           return uuidBuilder_.getMessage();
         }
       }
-      public Builder setUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder setUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (uuidBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -1897,7 +1897,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setUuid(
-          akka.cluster.RemoteProtocol.UuidProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.UuidProtocol.Builder builderForValue) {
         if (uuidBuilder_ == null) {
           uuid_ = builderForValue.build();
           onChanged();
@@ -1907,12 +1907,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000001;
         return this;
       }
-      public Builder mergeUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder mergeUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (uuidBuilder_ == null) {
           if (((bitField0_ & 0x00000001) == 0x00000001) &&
-              uuid_ != akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
+              uuid_ != akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
             uuid_ =
-              akka.cluster.RemoteProtocol.UuidProtocol.newBuilder(uuid_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.UuidProtocol.newBuilder(uuid_).mergeFrom(value).buildPartial();
           } else {
             uuid_ = value;
           }
@@ -1925,7 +1925,7 @@ public final class RemoteProtocol {
       }
       public Builder clearUuid() {
         if (uuidBuilder_ == null) {
-          uuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          uuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
           onChanged();
         } else {
           uuidBuilder_.clear();
@@ -1933,12 +1933,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000001);
         return this;
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol.Builder getUuidBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocol.Builder getUuidBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getUuidFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder() {
         if (uuidBuilder_ != null) {
           return uuidBuilder_.getMessageOrBuilder();
         } else {
@@ -1946,11 +1946,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> 
           getUuidFieldBuilder() {
         if (uuidBuilder_ == null) {
           uuidBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder>(
                   uuid_,
                   getParentForChildren(),
                   isClean());
@@ -1960,20 +1960,20 @@ public final class RemoteProtocol {
       }
       
       // required .ActorInfoProtocol actorInfo = 2;
-      private akka.cluster.RemoteProtocol.ActorInfoProtocol actorInfo_ = akka.cluster.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.ActorInfoProtocol actorInfo_ = akka.remote.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.ActorInfoProtocol, akka.cluster.RemoteProtocol.ActorInfoProtocol.Builder, akka.cluster.RemoteProtocol.ActorInfoProtocolOrBuilder> actorInfoBuilder_;
+          akka.remote.RemoteProtocol.ActorInfoProtocol, akka.remote.RemoteProtocol.ActorInfoProtocol.Builder, akka.remote.RemoteProtocol.ActorInfoProtocolOrBuilder> actorInfoBuilder_;
       public boolean hasActorInfo() {
         return ((bitField0_ & 0x00000002) == 0x00000002);
       }
-      public akka.cluster.RemoteProtocol.ActorInfoProtocol getActorInfo() {
+      public akka.remote.RemoteProtocol.ActorInfoProtocol getActorInfo() {
         if (actorInfoBuilder_ == null) {
           return actorInfo_;
         } else {
           return actorInfoBuilder_.getMessage();
         }
       }
-      public Builder setActorInfo(akka.cluster.RemoteProtocol.ActorInfoProtocol value) {
+      public Builder setActorInfo(akka.remote.RemoteProtocol.ActorInfoProtocol value) {
         if (actorInfoBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -1987,7 +1987,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setActorInfo(
-          akka.cluster.RemoteProtocol.ActorInfoProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.ActorInfoProtocol.Builder builderForValue) {
         if (actorInfoBuilder_ == null) {
           actorInfo_ = builderForValue.build();
           onChanged();
@@ -1997,12 +1997,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000002;
         return this;
       }
-      public Builder mergeActorInfo(akka.cluster.RemoteProtocol.ActorInfoProtocol value) {
+      public Builder mergeActorInfo(akka.remote.RemoteProtocol.ActorInfoProtocol value) {
         if (actorInfoBuilder_ == null) {
           if (((bitField0_ & 0x00000002) == 0x00000002) &&
-              actorInfo_ != akka.cluster.RemoteProtocol.ActorInfoProtocol.getDefaultInstance()) {
+              actorInfo_ != akka.remote.RemoteProtocol.ActorInfoProtocol.getDefaultInstance()) {
             actorInfo_ =
-              akka.cluster.RemoteProtocol.ActorInfoProtocol.newBuilder(actorInfo_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.ActorInfoProtocol.newBuilder(actorInfo_).mergeFrom(value).buildPartial();
           } else {
             actorInfo_ = value;
           }
@@ -2015,7 +2015,7 @@ public final class RemoteProtocol {
       }
       public Builder clearActorInfo() {
         if (actorInfoBuilder_ == null) {
-          actorInfo_ = akka.cluster.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
+          actorInfo_ = akka.remote.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
           onChanged();
         } else {
           actorInfoBuilder_.clear();
@@ -2023,12 +2023,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000002);
         return this;
       }
-      public akka.cluster.RemoteProtocol.ActorInfoProtocol.Builder getActorInfoBuilder() {
+      public akka.remote.RemoteProtocol.ActorInfoProtocol.Builder getActorInfoBuilder() {
         bitField0_ |= 0x00000002;
         onChanged();
         return getActorInfoFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.ActorInfoProtocolOrBuilder getActorInfoOrBuilder() {
+      public akka.remote.RemoteProtocol.ActorInfoProtocolOrBuilder getActorInfoOrBuilder() {
         if (actorInfoBuilder_ != null) {
           return actorInfoBuilder_.getMessageOrBuilder();
         } else {
@@ -2036,11 +2036,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.ActorInfoProtocol, akka.cluster.RemoteProtocol.ActorInfoProtocol.Builder, akka.cluster.RemoteProtocol.ActorInfoProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.ActorInfoProtocol, akka.remote.RemoteProtocol.ActorInfoProtocol.Builder, akka.remote.RemoteProtocol.ActorInfoProtocolOrBuilder> 
           getActorInfoFieldBuilder() {
         if (actorInfoBuilder_ == null) {
           actorInfoBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.ActorInfoProtocol, akka.cluster.RemoteProtocol.ActorInfoProtocol.Builder, akka.cluster.RemoteProtocol.ActorInfoProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.ActorInfoProtocol, akka.remote.RemoteProtocol.ActorInfoProtocol.Builder, akka.remote.RemoteProtocol.ActorInfoProtocolOrBuilder>(
                   actorInfo_,
                   getParentForChildren(),
                   isClean());
@@ -2071,20 +2071,20 @@ public final class RemoteProtocol {
       }
       
       // optional .MessageProtocol message = 4;
-      private akka.cluster.RemoteProtocol.MessageProtocol message_ = akka.cluster.RemoteProtocol.MessageProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.MessageProtocol message_ = akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.MessageProtocol, akka.cluster.RemoteProtocol.MessageProtocol.Builder, akka.cluster.RemoteProtocol.MessageProtocolOrBuilder> messageBuilder_;
+          akka.remote.RemoteProtocol.MessageProtocol, akka.remote.RemoteProtocol.MessageProtocol.Builder, akka.remote.RemoteProtocol.MessageProtocolOrBuilder> messageBuilder_;
       public boolean hasMessage() {
         return ((bitField0_ & 0x00000008) == 0x00000008);
       }
-      public akka.cluster.RemoteProtocol.MessageProtocol getMessage() {
+      public akka.remote.RemoteProtocol.MessageProtocol getMessage() {
         if (messageBuilder_ == null) {
           return message_;
         } else {
           return messageBuilder_.getMessage();
         }
       }
-      public Builder setMessage(akka.cluster.RemoteProtocol.MessageProtocol value) {
+      public Builder setMessage(akka.remote.RemoteProtocol.MessageProtocol value) {
         if (messageBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -2098,7 +2098,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setMessage(
-          akka.cluster.RemoteProtocol.MessageProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.MessageProtocol.Builder builderForValue) {
         if (messageBuilder_ == null) {
           message_ = builderForValue.build();
           onChanged();
@@ -2108,12 +2108,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000008;
         return this;
       }
-      public Builder mergeMessage(akka.cluster.RemoteProtocol.MessageProtocol value) {
+      public Builder mergeMessage(akka.remote.RemoteProtocol.MessageProtocol value) {
         if (messageBuilder_ == null) {
           if (((bitField0_ & 0x00000008) == 0x00000008) &&
-              message_ != akka.cluster.RemoteProtocol.MessageProtocol.getDefaultInstance()) {
+              message_ != akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance()) {
             message_ =
-              akka.cluster.RemoteProtocol.MessageProtocol.newBuilder(message_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.MessageProtocol.newBuilder(message_).mergeFrom(value).buildPartial();
           } else {
             message_ = value;
           }
@@ -2126,7 +2126,7 @@ public final class RemoteProtocol {
       }
       public Builder clearMessage() {
         if (messageBuilder_ == null) {
-          message_ = akka.cluster.RemoteProtocol.MessageProtocol.getDefaultInstance();
+          message_ = akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
           onChanged();
         } else {
           messageBuilder_.clear();
@@ -2134,12 +2134,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000008);
         return this;
       }
-      public akka.cluster.RemoteProtocol.MessageProtocol.Builder getMessageBuilder() {
+      public akka.remote.RemoteProtocol.MessageProtocol.Builder getMessageBuilder() {
         bitField0_ |= 0x00000008;
         onChanged();
         return getMessageFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.MessageProtocolOrBuilder getMessageOrBuilder() {
+      public akka.remote.RemoteProtocol.MessageProtocolOrBuilder getMessageOrBuilder() {
         if (messageBuilder_ != null) {
           return messageBuilder_.getMessageOrBuilder();
         } else {
@@ -2147,11 +2147,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.MessageProtocol, akka.cluster.RemoteProtocol.MessageProtocol.Builder, akka.cluster.RemoteProtocol.MessageProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.MessageProtocol, akka.remote.RemoteProtocol.MessageProtocol.Builder, akka.remote.RemoteProtocol.MessageProtocolOrBuilder> 
           getMessageFieldBuilder() {
         if (messageBuilder_ == null) {
           messageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.MessageProtocol, akka.cluster.RemoteProtocol.MessageProtocol.Builder, akka.cluster.RemoteProtocol.MessageProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.MessageProtocol, akka.remote.RemoteProtocol.MessageProtocol.Builder, akka.remote.RemoteProtocol.MessageProtocolOrBuilder>(
                   message_,
                   getParentForChildren(),
                   isClean());
@@ -2161,20 +2161,20 @@ public final class RemoteProtocol {
       }
       
       // optional .ExceptionProtocol exception = 5;
-      private akka.cluster.RemoteProtocol.ExceptionProtocol exception_ = akka.cluster.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.ExceptionProtocol exception_ = akka.remote.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.ExceptionProtocol, akka.cluster.RemoteProtocol.ExceptionProtocol.Builder, akka.cluster.RemoteProtocol.ExceptionProtocolOrBuilder> exceptionBuilder_;
+          akka.remote.RemoteProtocol.ExceptionProtocol, akka.remote.RemoteProtocol.ExceptionProtocol.Builder, akka.remote.RemoteProtocol.ExceptionProtocolOrBuilder> exceptionBuilder_;
       public boolean hasException() {
         return ((bitField0_ & 0x00000010) == 0x00000010);
       }
-      public akka.cluster.RemoteProtocol.ExceptionProtocol getException() {
+      public akka.remote.RemoteProtocol.ExceptionProtocol getException() {
         if (exceptionBuilder_ == null) {
           return exception_;
         } else {
           return exceptionBuilder_.getMessage();
         }
       }
-      public Builder setException(akka.cluster.RemoteProtocol.ExceptionProtocol value) {
+      public Builder setException(akka.remote.RemoteProtocol.ExceptionProtocol value) {
         if (exceptionBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -2188,7 +2188,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setException(
-          akka.cluster.RemoteProtocol.ExceptionProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.ExceptionProtocol.Builder builderForValue) {
         if (exceptionBuilder_ == null) {
           exception_ = builderForValue.build();
           onChanged();
@@ -2198,12 +2198,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000010;
         return this;
       }
-      public Builder mergeException(akka.cluster.RemoteProtocol.ExceptionProtocol value) {
+      public Builder mergeException(akka.remote.RemoteProtocol.ExceptionProtocol value) {
         if (exceptionBuilder_ == null) {
           if (((bitField0_ & 0x00000010) == 0x00000010) &&
-              exception_ != akka.cluster.RemoteProtocol.ExceptionProtocol.getDefaultInstance()) {
+              exception_ != akka.remote.RemoteProtocol.ExceptionProtocol.getDefaultInstance()) {
             exception_ =
-              akka.cluster.RemoteProtocol.ExceptionProtocol.newBuilder(exception_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.ExceptionProtocol.newBuilder(exception_).mergeFrom(value).buildPartial();
           } else {
             exception_ = value;
           }
@@ -2216,7 +2216,7 @@ public final class RemoteProtocol {
       }
       public Builder clearException() {
         if (exceptionBuilder_ == null) {
-          exception_ = akka.cluster.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
+          exception_ = akka.remote.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
           onChanged();
         } else {
           exceptionBuilder_.clear();
@@ -2224,12 +2224,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000010);
         return this;
       }
-      public akka.cluster.RemoteProtocol.ExceptionProtocol.Builder getExceptionBuilder() {
+      public akka.remote.RemoteProtocol.ExceptionProtocol.Builder getExceptionBuilder() {
         bitField0_ |= 0x00000010;
         onChanged();
         return getExceptionFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.ExceptionProtocolOrBuilder getExceptionOrBuilder() {
+      public akka.remote.RemoteProtocol.ExceptionProtocolOrBuilder getExceptionOrBuilder() {
         if (exceptionBuilder_ != null) {
           return exceptionBuilder_.getMessageOrBuilder();
         } else {
@@ -2237,11 +2237,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.ExceptionProtocol, akka.cluster.RemoteProtocol.ExceptionProtocol.Builder, akka.cluster.RemoteProtocol.ExceptionProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.ExceptionProtocol, akka.remote.RemoteProtocol.ExceptionProtocol.Builder, akka.remote.RemoteProtocol.ExceptionProtocolOrBuilder> 
           getExceptionFieldBuilder() {
         if (exceptionBuilder_ == null) {
           exceptionBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.ExceptionProtocol, akka.cluster.RemoteProtocol.ExceptionProtocol.Builder, akka.cluster.RemoteProtocol.ExceptionProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.ExceptionProtocol, akka.remote.RemoteProtocol.ExceptionProtocol.Builder, akka.remote.RemoteProtocol.ExceptionProtocolOrBuilder>(
                   exception_,
                   getParentForChildren(),
                   isClean());
@@ -2251,20 +2251,20 @@ public final class RemoteProtocol {
       }
       
       // optional .UuidProtocol supervisorUuid = 6;
-      private akka.cluster.RemoteProtocol.UuidProtocol supervisorUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.UuidProtocol supervisorUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> supervisorUuidBuilder_;
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> supervisorUuidBuilder_;
       public boolean hasSupervisorUuid() {
         return ((bitField0_ & 0x00000020) == 0x00000020);
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol getSupervisorUuid() {
+      public akka.remote.RemoteProtocol.UuidProtocol getSupervisorUuid() {
         if (supervisorUuidBuilder_ == null) {
           return supervisorUuid_;
         } else {
           return supervisorUuidBuilder_.getMessage();
         }
       }
-      public Builder setSupervisorUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder setSupervisorUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (supervisorUuidBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -2278,7 +2278,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setSupervisorUuid(
-          akka.cluster.RemoteProtocol.UuidProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.UuidProtocol.Builder builderForValue) {
         if (supervisorUuidBuilder_ == null) {
           supervisorUuid_ = builderForValue.build();
           onChanged();
@@ -2288,12 +2288,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000020;
         return this;
       }
-      public Builder mergeSupervisorUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder mergeSupervisorUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (supervisorUuidBuilder_ == null) {
           if (((bitField0_ & 0x00000020) == 0x00000020) &&
-              supervisorUuid_ != akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
+              supervisorUuid_ != akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
             supervisorUuid_ =
-              akka.cluster.RemoteProtocol.UuidProtocol.newBuilder(supervisorUuid_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.UuidProtocol.newBuilder(supervisorUuid_).mergeFrom(value).buildPartial();
           } else {
             supervisorUuid_ = value;
           }
@@ -2306,7 +2306,7 @@ public final class RemoteProtocol {
       }
       public Builder clearSupervisorUuid() {
         if (supervisorUuidBuilder_ == null) {
-          supervisorUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          supervisorUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
           onChanged();
         } else {
           supervisorUuidBuilder_.clear();
@@ -2314,12 +2314,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000020);
         return this;
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol.Builder getSupervisorUuidBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocol.Builder getSupervisorUuidBuilder() {
         bitField0_ |= 0x00000020;
         onChanged();
         return getSupervisorUuidFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getSupervisorUuidOrBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getSupervisorUuidOrBuilder() {
         if (supervisorUuidBuilder_ != null) {
           return supervisorUuidBuilder_.getMessageOrBuilder();
         } else {
@@ -2327,11 +2327,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> 
           getSupervisorUuidFieldBuilder() {
         if (supervisorUuidBuilder_ == null) {
           supervisorUuidBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder>(
                   supervisorUuid_,
                   getParentForChildren(),
                   isClean());
@@ -2341,20 +2341,20 @@ public final class RemoteProtocol {
       }
       
       // optional .RemoteActorRefProtocol sender = 7;
-      private akka.cluster.RemoteProtocol.RemoteActorRefProtocol sender_ = akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.RemoteActorRefProtocol sender_ = akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.RemoteActorRefProtocol, akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder, akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder> senderBuilder_;
+          akka.remote.RemoteProtocol.RemoteActorRefProtocol, akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder, akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder> senderBuilder_;
       public boolean hasSender() {
         return ((bitField0_ & 0x00000040) == 0x00000040);
       }
-      public akka.cluster.RemoteProtocol.RemoteActorRefProtocol getSender() {
+      public akka.remote.RemoteProtocol.RemoteActorRefProtocol getSender() {
         if (senderBuilder_ == null) {
           return sender_;
         } else {
           return senderBuilder_.getMessage();
         }
       }
-      public Builder setSender(akka.cluster.RemoteProtocol.RemoteActorRefProtocol value) {
+      public Builder setSender(akka.remote.RemoteProtocol.RemoteActorRefProtocol value) {
         if (senderBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -2368,7 +2368,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setSender(
-          akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder builderForValue) {
         if (senderBuilder_ == null) {
           sender_ = builderForValue.build();
           onChanged();
@@ -2378,12 +2378,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000040;
         return this;
       }
-      public Builder mergeSender(akka.cluster.RemoteProtocol.RemoteActorRefProtocol value) {
+      public Builder mergeSender(akka.remote.RemoteProtocol.RemoteActorRefProtocol value) {
         if (senderBuilder_ == null) {
           if (((bitField0_ & 0x00000040) == 0x00000040) &&
-              sender_ != akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) {
+              sender_ != akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) {
             sender_ =
-              akka.cluster.RemoteProtocol.RemoteActorRefProtocol.newBuilder(sender_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.RemoteActorRefProtocol.newBuilder(sender_).mergeFrom(value).buildPartial();
           } else {
             sender_ = value;
           }
@@ -2396,7 +2396,7 @@ public final class RemoteProtocol {
       }
       public Builder clearSender() {
         if (senderBuilder_ == null) {
-          sender_ = akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
+          sender_ = akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
           onChanged();
         } else {
           senderBuilder_.clear();
@@ -2404,12 +2404,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000040);
         return this;
       }
-      public akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder getSenderBuilder() {
+      public akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder getSenderBuilder() {
         bitField0_ |= 0x00000040;
         onChanged();
         return getSenderFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder getSenderOrBuilder() {
+      public akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder getSenderOrBuilder() {
         if (senderBuilder_ != null) {
           return senderBuilder_.getMessageOrBuilder();
         } else {
@@ -2417,11 +2417,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.RemoteActorRefProtocol, akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder, akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.RemoteActorRefProtocol, akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder, akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder> 
           getSenderFieldBuilder() {
         if (senderBuilder_ == null) {
           senderBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.RemoteActorRefProtocol, akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder, akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.RemoteActorRefProtocol, akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder, akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder>(
                   sender_,
                   getParentForChildren(),
                   isClean());
@@ -2431,19 +2431,19 @@ public final class RemoteProtocol {
       }
       
       // repeated .MetadataEntryProtocol metadata = 8;
-      private java.util.List<akka.cluster.RemoteProtocol.MetadataEntryProtocol> metadata_ =
+      private java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> metadata_ =
         java.util.Collections.emptyList();
       private void ensureMetadataIsMutable() {
         if (!((bitField0_ & 0x00000080) == 0x00000080)) {
-          metadata_ = new java.util.ArrayList<akka.cluster.RemoteProtocol.MetadataEntryProtocol>(metadata_);
+          metadata_ = new java.util.ArrayList<akka.remote.RemoteProtocol.MetadataEntryProtocol>(metadata_);
           bitField0_ |= 0x00000080;
          }
       }
       
       private com.google.protobuf.RepeatedFieldBuilder<
-          akka.cluster.RemoteProtocol.MetadataEntryProtocol, akka.cluster.RemoteProtocol.MetadataEntryProtocol.Builder, akka.cluster.RemoteProtocol.MetadataEntryProtocolOrBuilder> metadataBuilder_;
+          akka.remote.RemoteProtocol.MetadataEntryProtocol, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder, akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> metadataBuilder_;
       
-      public java.util.List<akka.cluster.RemoteProtocol.MetadataEntryProtocol> getMetadataList() {
+      public java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> getMetadataList() {
         if (metadataBuilder_ == null) {
           return java.util.Collections.unmodifiableList(metadata_);
         } else {
@@ -2457,7 +2457,7 @@ public final class RemoteProtocol {
           return metadataBuilder_.getCount();
         }
       }
-      public akka.cluster.RemoteProtocol.MetadataEntryProtocol getMetadata(int index) {
+      public akka.remote.RemoteProtocol.MetadataEntryProtocol getMetadata(int index) {
         if (metadataBuilder_ == null) {
           return metadata_.get(index);
         } else {
@@ -2465,7 +2465,7 @@ public final class RemoteProtocol {
         }
       }
       public Builder setMetadata(
-          int index, akka.cluster.RemoteProtocol.MetadataEntryProtocol value) {
+          int index, akka.remote.RemoteProtocol.MetadataEntryProtocol value) {
         if (metadataBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -2479,7 +2479,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setMetadata(
-          int index, akka.cluster.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
+          int index, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
         if (metadataBuilder_ == null) {
           ensureMetadataIsMutable();
           metadata_.set(index, builderForValue.build());
@@ -2489,7 +2489,7 @@ public final class RemoteProtocol {
         }
         return this;
       }
-      public Builder addMetadata(akka.cluster.RemoteProtocol.MetadataEntryProtocol value) {
+      public Builder addMetadata(akka.remote.RemoteProtocol.MetadataEntryProtocol value) {
         if (metadataBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -2503,7 +2503,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder addMetadata(
-          int index, akka.cluster.RemoteProtocol.MetadataEntryProtocol value) {
+          int index, akka.remote.RemoteProtocol.MetadataEntryProtocol value) {
         if (metadataBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -2517,7 +2517,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder addMetadata(
-          akka.cluster.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
         if (metadataBuilder_ == null) {
           ensureMetadataIsMutable();
           metadata_.add(builderForValue.build());
@@ -2528,7 +2528,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder addMetadata(
-          int index, akka.cluster.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
+          int index, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
         if (metadataBuilder_ == null) {
           ensureMetadataIsMutable();
           metadata_.add(index, builderForValue.build());
@@ -2539,7 +2539,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder addAllMetadata(
-          java.lang.Iterable<? extends akka.cluster.RemoteProtocol.MetadataEntryProtocol> values) {
+          java.lang.Iterable<? extends akka.remote.RemoteProtocol.MetadataEntryProtocol> values) {
         if (metadataBuilder_ == null) {
           ensureMetadataIsMutable();
           super.addAll(values, metadata_);
@@ -2569,18 +2569,18 @@ public final class RemoteProtocol {
         }
         return this;
       }
-      public akka.cluster.RemoteProtocol.MetadataEntryProtocol.Builder getMetadataBuilder(
+      public akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder getMetadataBuilder(
           int index) {
         return getMetadataFieldBuilder().getBuilder(index);
       }
-      public akka.cluster.RemoteProtocol.MetadataEntryProtocolOrBuilder getMetadataOrBuilder(
+      public akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder getMetadataOrBuilder(
           int index) {
         if (metadataBuilder_ == null) {
           return metadata_.get(index);  } else {
           return metadataBuilder_.getMessageOrBuilder(index);
         }
       }
-      public java.util.List<? extends akka.cluster.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
+      public java.util.List<? extends akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
            getMetadataOrBuilderList() {
         if (metadataBuilder_ != null) {
           return metadataBuilder_.getMessageOrBuilderList();
@@ -2588,25 +2588,25 @@ public final class RemoteProtocol {
           return java.util.Collections.unmodifiableList(metadata_);
         }
       }
-      public akka.cluster.RemoteProtocol.MetadataEntryProtocol.Builder addMetadataBuilder() {
+      public akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder addMetadataBuilder() {
         return getMetadataFieldBuilder().addBuilder(
-            akka.cluster.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance());
+            akka.remote.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance());
       }
-      public akka.cluster.RemoteProtocol.MetadataEntryProtocol.Builder addMetadataBuilder(
+      public akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder addMetadataBuilder(
           int index) {
         return getMetadataFieldBuilder().addBuilder(
-            index, akka.cluster.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance());
+            index, akka.remote.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance());
       }
-      public java.util.List<akka.cluster.RemoteProtocol.MetadataEntryProtocol.Builder> 
+      public java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder> 
            getMetadataBuilderList() {
         return getMetadataFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilder<
-          akka.cluster.RemoteProtocol.MetadataEntryProtocol, akka.cluster.RemoteProtocol.MetadataEntryProtocol.Builder, akka.cluster.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.MetadataEntryProtocol, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder, akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
           getMetadataFieldBuilder() {
         if (metadataBuilder_ == null) {
           metadataBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
-              akka.cluster.RemoteProtocol.MetadataEntryProtocol, akka.cluster.RemoteProtocol.MetadataEntryProtocol.Builder, akka.cluster.RemoteProtocol.MetadataEntryProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.MetadataEntryProtocol, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder, akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder>(
                   metadata_,
                   ((bitField0_ & 0x00000080) == 0x00000080),
                   getParentForChildren(),
@@ -2636,7 +2636,7 @@ public final class RemoteProtocol {
     
     // required .CommandType commandType = 2;
     boolean hasCommandType();
-    akka.cluster.RemoteProtocol.CommandType getCommandType();
+    akka.remote.RemoteProtocol.CommandType getCommandType();
   }
   public static final class RemoteControlProtocol extends
       com.google.protobuf.GeneratedMessage
@@ -2658,12 +2658,12 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_RemoteControlProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_RemoteControlProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_RemoteControlProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_RemoteControlProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
@@ -2701,17 +2701,17 @@ public final class RemoteProtocol {
     
     // required .CommandType commandType = 2;
     public static final int COMMANDTYPE_FIELD_NUMBER = 2;
-    private akka.cluster.RemoteProtocol.CommandType commandType_;
+    private akka.remote.RemoteProtocol.CommandType commandType_;
     public boolean hasCommandType() {
       return ((bitField0_ & 0x00000002) == 0x00000002);
     }
-    public akka.cluster.RemoteProtocol.CommandType getCommandType() {
+    public akka.remote.RemoteProtocol.CommandType getCommandType() {
       return commandType_;
     }
     
     private void initFields() {
       cookie_ = "";
-      commandType_ = akka.cluster.RemoteProtocol.CommandType.CONNECT;
+      commandType_ = akka.remote.RemoteProtocol.CommandType.CONNECT;
     }
     private byte memoizedIsInitialized = -1;
     public final boolean isInitialized() {
@@ -2764,41 +2764,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.RemoteControlProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteControlProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteControlProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteControlProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteControlProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.RemoteControlProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteControlProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteControlProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteControlProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.RemoteControlProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteControlProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteControlProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteControlProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.RemoteControlProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -2807,7 +2807,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.RemoteControlProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.RemoteControlProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -2818,12 +2818,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.RemoteControlProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteControlProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteControlProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteControlProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -2833,7 +2833,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.RemoteControlProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.RemoteControlProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -2846,23 +2846,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.RemoteControlProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_RemoteControlProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_RemoteControlProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_RemoteControlProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_RemoteControlProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.RemoteControlProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.RemoteControlProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -2878,7 +2878,7 @@ public final class RemoteProtocol {
         super.clear();
         cookie_ = "";
         bitField0_ = (bitField0_ & ~0x00000001);
-        commandType_ = akka.cluster.RemoteProtocol.CommandType.CONNECT;
+        commandType_ = akka.remote.RemoteProtocol.CommandType.CONNECT;
         bitField0_ = (bitField0_ & ~0x00000002);
         return this;
       }
@@ -2889,24 +2889,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.RemoteControlProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.RemoteControlProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.RemoteControlProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.RemoteControlProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.RemoteControlProtocol build() {
-        akka.cluster.RemoteProtocol.RemoteControlProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.RemoteControlProtocol build() {
+        akka.remote.RemoteProtocol.RemoteControlProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.RemoteControlProtocol buildParsed()
+      private akka.remote.RemoteProtocol.RemoteControlProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.RemoteControlProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.RemoteControlProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -2914,8 +2914,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.RemoteControlProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.RemoteControlProtocol result = new akka.cluster.RemoteProtocol.RemoteControlProtocol(this);
+      public akka.remote.RemoteProtocol.RemoteControlProtocol buildPartial() {
+        akka.remote.RemoteProtocol.RemoteControlProtocol result = new akka.remote.RemoteProtocol.RemoteControlProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -2932,16 +2932,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.RemoteControlProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.RemoteControlProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.RemoteControlProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.RemoteControlProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.RemoteControlProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.RemoteControlProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.RemoteControlProtocol other) {
+        if (other == akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance()) return this;
         if (other.hasCookie()) {
           setCookie(other.getCookie());
         }
@@ -2990,7 +2990,7 @@ public final class RemoteProtocol {
             }
             case 16: {
               int rawValue = input.readEnum();
-              akka.cluster.RemoteProtocol.CommandType value = akka.cluster.RemoteProtocol.CommandType.valueOf(rawValue);
+              akka.remote.RemoteProtocol.CommandType value = akka.remote.RemoteProtocol.CommandType.valueOf(rawValue);
               if (value == null) {
                 unknownFields.mergeVarintField(2, rawValue);
               } else {
@@ -3042,14 +3042,14 @@ public final class RemoteProtocol {
       }
       
       // required .CommandType commandType = 2;
-      private akka.cluster.RemoteProtocol.CommandType commandType_ = akka.cluster.RemoteProtocol.CommandType.CONNECT;
+      private akka.remote.RemoteProtocol.CommandType commandType_ = akka.remote.RemoteProtocol.CommandType.CONNECT;
       public boolean hasCommandType() {
         return ((bitField0_ & 0x00000002) == 0x00000002);
       }
-      public akka.cluster.RemoteProtocol.CommandType getCommandType() {
+      public akka.remote.RemoteProtocol.CommandType getCommandType() {
         return commandType_;
       }
-      public Builder setCommandType(akka.cluster.RemoteProtocol.CommandType value) {
+      public Builder setCommandType(akka.remote.RemoteProtocol.CommandType value) {
         if (value == null) {
           throw new NullPointerException();
         }
@@ -3060,7 +3060,7 @@ public final class RemoteProtocol {
       }
       public Builder clearCommandType() {
         bitField0_ = (bitField0_ & ~0x00000002);
-        commandType_ = akka.cluster.RemoteProtocol.CommandType.CONNECT;
+        commandType_ = akka.remote.RemoteProtocol.CommandType.CONNECT;
         onChanged();
         return this;
       }
@@ -3111,12 +3111,12 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_RemoteActorRefProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_RemoteActorRefProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_RemoteActorRefProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_RemoteActorRefProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
@@ -3239,41 +3239,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.RemoteActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteActorRefProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteActorRefProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteActorRefProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.RemoteActorRefProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteActorRefProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteActorRefProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.RemoteActorRefProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteActorRefProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.RemoteActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -3282,7 +3282,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.RemoteActorRefProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.RemoteActorRefProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -3293,12 +3293,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.RemoteActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteActorRefProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteActorRefProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -3308,7 +3308,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.RemoteActorRefProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.RemoteActorRefProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -3321,23 +3321,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_RemoteActorRefProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_RemoteActorRefProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_RemoteActorRefProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_RemoteActorRefProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.RemoteActorRefProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.RemoteActorRefProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -3366,24 +3366,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.RemoteActorRefProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.RemoteActorRefProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.RemoteActorRefProtocol build() {
-        akka.cluster.RemoteProtocol.RemoteActorRefProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.RemoteActorRefProtocol build() {
+        akka.remote.RemoteProtocol.RemoteActorRefProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.RemoteActorRefProtocol buildParsed()
+      private akka.remote.RemoteProtocol.RemoteActorRefProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.RemoteActorRefProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.RemoteActorRefProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -3391,8 +3391,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.RemoteActorRefProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.RemoteActorRefProtocol result = new akka.cluster.RemoteProtocol.RemoteActorRefProtocol(this);
+      public akka.remote.RemoteProtocol.RemoteActorRefProtocol buildPartial() {
+        akka.remote.RemoteProtocol.RemoteActorRefProtocol result = new akka.remote.RemoteProtocol.RemoteActorRefProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -3413,16 +3413,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.RemoteActorRefProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.RemoteActorRefProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.RemoteActorRefProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.RemoteActorRefProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.RemoteActorRefProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.RemoteActorRefProtocol other) {
+        if (other == akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) return this;
         if (other.hasAddress()) {
           setAddress(other.getAddress());
         }
@@ -3589,8 +3589,8 @@ public final class RemoteProtocol {
     
     // required .UuidProtocol uuid = 1;
     boolean hasUuid();
-    akka.cluster.RemoteProtocol.UuidProtocol getUuid();
-    akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder();
+    akka.remote.RemoteProtocol.UuidProtocol getUuid();
+    akka.remote.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder();
     
     // required string address = 2;
     boolean hasAddress();
@@ -3618,13 +3618,13 @@ public final class RemoteProtocol {
     
     // optional .LifeCycleProtocol lifeCycle = 8;
     boolean hasLifeCycle();
-    akka.cluster.RemoteProtocol.LifeCycleProtocol getLifeCycle();
-    akka.cluster.RemoteProtocol.LifeCycleProtocolOrBuilder getLifeCycleOrBuilder();
+    akka.remote.RemoteProtocol.LifeCycleProtocol getLifeCycle();
+    akka.remote.RemoteProtocol.LifeCycleProtocolOrBuilder getLifeCycleOrBuilder();
     
     // optional .RemoteActorRefProtocol supervisor = 9;
     boolean hasSupervisor();
-    akka.cluster.RemoteProtocol.RemoteActorRefProtocol getSupervisor();
-    akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder getSupervisorOrBuilder();
+    akka.remote.RemoteProtocol.RemoteActorRefProtocol getSupervisor();
+    akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder getSupervisorOrBuilder();
     
     // optional bytes hotswapStack = 10;
     boolean hasHotswapStack();
@@ -3632,20 +3632,20 @@ public final class RemoteProtocol {
     
     // optional .ReplicationStorageType replicationStorage = 11;
     boolean hasReplicationStorage();
-    akka.cluster.RemoteProtocol.ReplicationStorageType getReplicationStorage();
+    akka.remote.RemoteProtocol.ReplicationStorageType getReplicationStorage();
     
     // optional .ReplicationStrategyType replicationStrategy = 12;
     boolean hasReplicationStrategy();
-    akka.cluster.RemoteProtocol.ReplicationStrategyType getReplicationStrategy();
+    akka.remote.RemoteProtocol.ReplicationStrategyType getReplicationStrategy();
     
     // repeated .RemoteMessageProtocol messages = 13;
-    java.util.List<akka.cluster.RemoteProtocol.RemoteMessageProtocol> 
+    java.util.List<akka.remote.RemoteProtocol.RemoteMessageProtocol> 
         getMessagesList();
-    akka.cluster.RemoteProtocol.RemoteMessageProtocol getMessages(int index);
+    akka.remote.RemoteProtocol.RemoteMessageProtocol getMessages(int index);
     int getMessagesCount();
-    java.util.List<? extends akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder> 
+    java.util.List<? extends akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder> 
         getMessagesOrBuilderList();
-    akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessagesOrBuilder(
+    akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessagesOrBuilder(
         int index);
   }
   public static final class SerializedActorRefProtocol extends
@@ -3668,25 +3668,25 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_SerializedActorRefProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_SerializedActorRefProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_SerializedActorRefProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_SerializedActorRefProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
     // required .UuidProtocol uuid = 1;
     public static final int UUID_FIELD_NUMBER = 1;
-    private akka.cluster.RemoteProtocol.UuidProtocol uuid_;
+    private akka.remote.RemoteProtocol.UuidProtocol uuid_;
     public boolean hasUuid() {
       return ((bitField0_ & 0x00000001) == 0x00000001);
     }
-    public akka.cluster.RemoteProtocol.UuidProtocol getUuid() {
+    public akka.remote.RemoteProtocol.UuidProtocol getUuid() {
       return uuid_;
     }
-    public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder() {
+    public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder() {
       return uuid_;
     }
     
@@ -3818,27 +3818,27 @@ public final class RemoteProtocol {
     
     // optional .LifeCycleProtocol lifeCycle = 8;
     public static final int LIFECYCLE_FIELD_NUMBER = 8;
-    private akka.cluster.RemoteProtocol.LifeCycleProtocol lifeCycle_;
+    private akka.remote.RemoteProtocol.LifeCycleProtocol lifeCycle_;
     public boolean hasLifeCycle() {
       return ((bitField0_ & 0x00000080) == 0x00000080);
     }
-    public akka.cluster.RemoteProtocol.LifeCycleProtocol getLifeCycle() {
+    public akka.remote.RemoteProtocol.LifeCycleProtocol getLifeCycle() {
       return lifeCycle_;
     }
-    public akka.cluster.RemoteProtocol.LifeCycleProtocolOrBuilder getLifeCycleOrBuilder() {
+    public akka.remote.RemoteProtocol.LifeCycleProtocolOrBuilder getLifeCycleOrBuilder() {
       return lifeCycle_;
     }
     
     // optional .RemoteActorRefProtocol supervisor = 9;
     public static final int SUPERVISOR_FIELD_NUMBER = 9;
-    private akka.cluster.RemoteProtocol.RemoteActorRefProtocol supervisor_;
+    private akka.remote.RemoteProtocol.RemoteActorRefProtocol supervisor_;
     public boolean hasSupervisor() {
       return ((bitField0_ & 0x00000100) == 0x00000100);
     }
-    public akka.cluster.RemoteProtocol.RemoteActorRefProtocol getSupervisor() {
+    public akka.remote.RemoteProtocol.RemoteActorRefProtocol getSupervisor() {
       return supervisor_;
     }
-    public akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder getSupervisorOrBuilder() {
+    public akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder getSupervisorOrBuilder() {
       return supervisor_;
     }
     
@@ -3854,58 +3854,58 @@ public final class RemoteProtocol {
     
     // optional .ReplicationStorageType replicationStorage = 11;
     public static final int REPLICATIONSTORAGE_FIELD_NUMBER = 11;
-    private akka.cluster.RemoteProtocol.ReplicationStorageType replicationStorage_;
+    private akka.remote.RemoteProtocol.ReplicationStorageType replicationStorage_;
     public boolean hasReplicationStorage() {
       return ((bitField0_ & 0x00000400) == 0x00000400);
     }
-    public akka.cluster.RemoteProtocol.ReplicationStorageType getReplicationStorage() {
+    public akka.remote.RemoteProtocol.ReplicationStorageType getReplicationStorage() {
       return replicationStorage_;
     }
     
     // optional .ReplicationStrategyType replicationStrategy = 12;
     public static final int REPLICATIONSTRATEGY_FIELD_NUMBER = 12;
-    private akka.cluster.RemoteProtocol.ReplicationStrategyType replicationStrategy_;
+    private akka.remote.RemoteProtocol.ReplicationStrategyType replicationStrategy_;
     public boolean hasReplicationStrategy() {
       return ((bitField0_ & 0x00000800) == 0x00000800);
     }
-    public akka.cluster.RemoteProtocol.ReplicationStrategyType getReplicationStrategy() {
+    public akka.remote.RemoteProtocol.ReplicationStrategyType getReplicationStrategy() {
       return replicationStrategy_;
     }
     
     // repeated .RemoteMessageProtocol messages = 13;
     public static final int MESSAGES_FIELD_NUMBER = 13;
-    private java.util.List<akka.cluster.RemoteProtocol.RemoteMessageProtocol> messages_;
-    public java.util.List<akka.cluster.RemoteProtocol.RemoteMessageProtocol> getMessagesList() {
+    private java.util.List<akka.remote.RemoteProtocol.RemoteMessageProtocol> messages_;
+    public java.util.List<akka.remote.RemoteProtocol.RemoteMessageProtocol> getMessagesList() {
       return messages_;
     }
-    public java.util.List<? extends akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder> 
+    public java.util.List<? extends akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder> 
         getMessagesOrBuilderList() {
       return messages_;
     }
     public int getMessagesCount() {
       return messages_.size();
     }
-    public akka.cluster.RemoteProtocol.RemoteMessageProtocol getMessages(int index) {
+    public akka.remote.RemoteProtocol.RemoteMessageProtocol getMessages(int index) {
       return messages_.get(index);
     }
-    public akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessagesOrBuilder(
+    public akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessagesOrBuilder(
         int index) {
       return messages_.get(index);
     }
     
     private void initFields() {
-      uuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      uuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
       address_ = "";
       actorClassname_ = "";
       actorInstance_ = com.google.protobuf.ByteString.EMPTY;
       serializerClassname_ = "";
       timeout_ = 0L;
       receiveTimeout_ = 0L;
-      lifeCycle_ = akka.cluster.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
-      supervisor_ = akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
+      lifeCycle_ = akka.remote.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
+      supervisor_ = akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
       hotswapStack_ = com.google.protobuf.ByteString.EMPTY;
-      replicationStorage_ = akka.cluster.RemoteProtocol.ReplicationStorageType.TRANSIENT;
-      replicationStrategy_ = akka.cluster.RemoteProtocol.ReplicationStrategyType.WRITE_THROUGH;
+      replicationStorage_ = akka.remote.RemoteProtocol.ReplicationStorageType.TRANSIENT;
+      replicationStrategy_ = akka.remote.RemoteProtocol.ReplicationStrategyType.WRITE_THROUGH;
       messages_ = java.util.Collections.emptyList();
     }
     private byte memoizedIsInitialized = -1;
@@ -4066,41 +4066,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.SerializedActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.SerializedActorRefProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.SerializedActorRefProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedActorRefProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.SerializedActorRefProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.SerializedActorRefProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedActorRefProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.SerializedActorRefProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.SerializedActorRefProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.SerializedActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -4109,7 +4109,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.SerializedActorRefProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.SerializedActorRefProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -4120,12 +4120,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.SerializedActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.SerializedActorRefProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.SerializedActorRefProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -4135,7 +4135,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.SerializedActorRefProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.SerializedActorRefProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -4148,23 +4148,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.SerializedActorRefProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.SerializedActorRefProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_SerializedActorRefProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_SerializedActorRefProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_SerializedActorRefProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_SerializedActorRefProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.SerializedActorRefProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.SerializedActorRefProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -4183,7 +4183,7 @@ public final class RemoteProtocol {
       public Builder clear() {
         super.clear();
         if (uuidBuilder_ == null) {
-          uuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          uuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
         } else {
           uuidBuilder_.clear();
         }
@@ -4201,22 +4201,22 @@ public final class RemoteProtocol {
         receiveTimeout_ = 0L;
         bitField0_ = (bitField0_ & ~0x00000040);
         if (lifeCycleBuilder_ == null) {
-          lifeCycle_ = akka.cluster.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
+          lifeCycle_ = akka.remote.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
         } else {
           lifeCycleBuilder_.clear();
         }
         bitField0_ = (bitField0_ & ~0x00000080);
         if (supervisorBuilder_ == null) {
-          supervisor_ = akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
+          supervisor_ = akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
         } else {
           supervisorBuilder_.clear();
         }
         bitField0_ = (bitField0_ & ~0x00000100);
         hotswapStack_ = com.google.protobuf.ByteString.EMPTY;
         bitField0_ = (bitField0_ & ~0x00000200);
-        replicationStorage_ = akka.cluster.RemoteProtocol.ReplicationStorageType.TRANSIENT;
+        replicationStorage_ = akka.remote.RemoteProtocol.ReplicationStorageType.TRANSIENT;
         bitField0_ = (bitField0_ & ~0x00000400);
-        replicationStrategy_ = akka.cluster.RemoteProtocol.ReplicationStrategyType.WRITE_THROUGH;
+        replicationStrategy_ = akka.remote.RemoteProtocol.ReplicationStrategyType.WRITE_THROUGH;
         bitField0_ = (bitField0_ & ~0x00000800);
         if (messagesBuilder_ == null) {
           messages_ = java.util.Collections.emptyList();
@@ -4233,24 +4233,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.SerializedActorRefProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.SerializedActorRefProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.SerializedActorRefProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.SerializedActorRefProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.SerializedActorRefProtocol build() {
-        akka.cluster.RemoteProtocol.SerializedActorRefProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.SerializedActorRefProtocol build() {
+        akka.remote.RemoteProtocol.SerializedActorRefProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.SerializedActorRefProtocol buildParsed()
+      private akka.remote.RemoteProtocol.SerializedActorRefProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.SerializedActorRefProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.SerializedActorRefProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -4258,8 +4258,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.SerializedActorRefProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.SerializedActorRefProtocol result = new akka.cluster.RemoteProtocol.SerializedActorRefProtocol(this);
+      public akka.remote.RemoteProtocol.SerializedActorRefProtocol buildPartial() {
+        akka.remote.RemoteProtocol.SerializedActorRefProtocol result = new akka.remote.RemoteProtocol.SerializedActorRefProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -4337,16 +4337,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.SerializedActorRefProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.SerializedActorRefProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.SerializedActorRefProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.SerializedActorRefProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.SerializedActorRefProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.SerializedActorRefProtocol other) {
+        if (other == akka.remote.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance()) return this;
         if (other.hasUuid()) {
           mergeUuid(other.getUuid());
         }
@@ -4475,7 +4475,7 @@ public final class RemoteProtocol {
               break;
             }
             case 10: {
-              akka.cluster.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.UuidProtocol.newBuilder();
+              akka.remote.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.RemoteProtocol.UuidProtocol.newBuilder();
               if (hasUuid()) {
                 subBuilder.mergeFrom(getUuid());
               }
@@ -4514,7 +4514,7 @@ public final class RemoteProtocol {
               break;
             }
             case 66: {
-              akka.cluster.RemoteProtocol.LifeCycleProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.LifeCycleProtocol.newBuilder();
+              akka.remote.RemoteProtocol.LifeCycleProtocol.Builder subBuilder = akka.remote.RemoteProtocol.LifeCycleProtocol.newBuilder();
               if (hasLifeCycle()) {
                 subBuilder.mergeFrom(getLifeCycle());
               }
@@ -4523,7 +4523,7 @@ public final class RemoteProtocol {
               break;
             }
             case 74: {
-              akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.RemoteActorRefProtocol.newBuilder();
+              akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder subBuilder = akka.remote.RemoteProtocol.RemoteActorRefProtocol.newBuilder();
               if (hasSupervisor()) {
                 subBuilder.mergeFrom(getSupervisor());
               }
@@ -4538,7 +4538,7 @@ public final class RemoteProtocol {
             }
             case 88: {
               int rawValue = input.readEnum();
-              akka.cluster.RemoteProtocol.ReplicationStorageType value = akka.cluster.RemoteProtocol.ReplicationStorageType.valueOf(rawValue);
+              akka.remote.RemoteProtocol.ReplicationStorageType value = akka.remote.RemoteProtocol.ReplicationStorageType.valueOf(rawValue);
               if (value == null) {
                 unknownFields.mergeVarintField(11, rawValue);
               } else {
@@ -4549,7 +4549,7 @@ public final class RemoteProtocol {
             }
             case 96: {
               int rawValue = input.readEnum();
-              akka.cluster.RemoteProtocol.ReplicationStrategyType value = akka.cluster.RemoteProtocol.ReplicationStrategyType.valueOf(rawValue);
+              akka.remote.RemoteProtocol.ReplicationStrategyType value = akka.remote.RemoteProtocol.ReplicationStrategyType.valueOf(rawValue);
               if (value == null) {
                 unknownFields.mergeVarintField(12, rawValue);
               } else {
@@ -4559,7 +4559,7 @@ public final class RemoteProtocol {
               break;
             }
             case 106: {
-              akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.RemoteMessageProtocol.newBuilder();
+              akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder subBuilder = akka.remote.RemoteProtocol.RemoteMessageProtocol.newBuilder();
               input.readMessage(subBuilder, extensionRegistry);
               addMessages(subBuilder.buildPartial());
               break;
@@ -4571,20 +4571,20 @@ public final class RemoteProtocol {
       private int bitField0_;
       
       // required .UuidProtocol uuid = 1;
-      private akka.cluster.RemoteProtocol.UuidProtocol uuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.UuidProtocol uuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> uuidBuilder_;
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> uuidBuilder_;
       public boolean hasUuid() {
         return ((bitField0_ & 0x00000001) == 0x00000001);
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol getUuid() {
+      public akka.remote.RemoteProtocol.UuidProtocol getUuid() {
         if (uuidBuilder_ == null) {
           return uuid_;
         } else {
           return uuidBuilder_.getMessage();
         }
       }
-      public Builder setUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder setUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (uuidBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -4598,7 +4598,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setUuid(
-          akka.cluster.RemoteProtocol.UuidProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.UuidProtocol.Builder builderForValue) {
         if (uuidBuilder_ == null) {
           uuid_ = builderForValue.build();
           onChanged();
@@ -4608,12 +4608,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000001;
         return this;
       }
-      public Builder mergeUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder mergeUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (uuidBuilder_ == null) {
           if (((bitField0_ & 0x00000001) == 0x00000001) &&
-              uuid_ != akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
+              uuid_ != akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
             uuid_ =
-              akka.cluster.RemoteProtocol.UuidProtocol.newBuilder(uuid_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.UuidProtocol.newBuilder(uuid_).mergeFrom(value).buildPartial();
           } else {
             uuid_ = value;
           }
@@ -4626,7 +4626,7 @@ public final class RemoteProtocol {
       }
       public Builder clearUuid() {
         if (uuidBuilder_ == null) {
-          uuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          uuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
           onChanged();
         } else {
           uuidBuilder_.clear();
@@ -4634,12 +4634,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000001);
         return this;
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol.Builder getUuidBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocol.Builder getUuidBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getUuidFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder() {
         if (uuidBuilder_ != null) {
           return uuidBuilder_.getMessageOrBuilder();
         } else {
@@ -4647,11 +4647,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> 
           getUuidFieldBuilder() {
         if (uuidBuilder_ == null) {
           uuidBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder>(
                   uuid_,
                   getParentForChildren(),
                   isClean());
@@ -4835,20 +4835,20 @@ public final class RemoteProtocol {
       }
       
       // optional .LifeCycleProtocol lifeCycle = 8;
-      private akka.cluster.RemoteProtocol.LifeCycleProtocol lifeCycle_ = akka.cluster.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.LifeCycleProtocol lifeCycle_ = akka.remote.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.LifeCycleProtocol, akka.cluster.RemoteProtocol.LifeCycleProtocol.Builder, akka.cluster.RemoteProtocol.LifeCycleProtocolOrBuilder> lifeCycleBuilder_;
+          akka.remote.RemoteProtocol.LifeCycleProtocol, akka.remote.RemoteProtocol.LifeCycleProtocol.Builder, akka.remote.RemoteProtocol.LifeCycleProtocolOrBuilder> lifeCycleBuilder_;
       public boolean hasLifeCycle() {
         return ((bitField0_ & 0x00000080) == 0x00000080);
       }
-      public akka.cluster.RemoteProtocol.LifeCycleProtocol getLifeCycle() {
+      public akka.remote.RemoteProtocol.LifeCycleProtocol getLifeCycle() {
         if (lifeCycleBuilder_ == null) {
           return lifeCycle_;
         } else {
           return lifeCycleBuilder_.getMessage();
         }
       }
-      public Builder setLifeCycle(akka.cluster.RemoteProtocol.LifeCycleProtocol value) {
+      public Builder setLifeCycle(akka.remote.RemoteProtocol.LifeCycleProtocol value) {
         if (lifeCycleBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -4862,7 +4862,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setLifeCycle(
-          akka.cluster.RemoteProtocol.LifeCycleProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.LifeCycleProtocol.Builder builderForValue) {
         if (lifeCycleBuilder_ == null) {
           lifeCycle_ = builderForValue.build();
           onChanged();
@@ -4872,12 +4872,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000080;
         return this;
       }
-      public Builder mergeLifeCycle(akka.cluster.RemoteProtocol.LifeCycleProtocol value) {
+      public Builder mergeLifeCycle(akka.remote.RemoteProtocol.LifeCycleProtocol value) {
         if (lifeCycleBuilder_ == null) {
           if (((bitField0_ & 0x00000080) == 0x00000080) &&
-              lifeCycle_ != akka.cluster.RemoteProtocol.LifeCycleProtocol.getDefaultInstance()) {
+              lifeCycle_ != akka.remote.RemoteProtocol.LifeCycleProtocol.getDefaultInstance()) {
             lifeCycle_ =
-              akka.cluster.RemoteProtocol.LifeCycleProtocol.newBuilder(lifeCycle_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.LifeCycleProtocol.newBuilder(lifeCycle_).mergeFrom(value).buildPartial();
           } else {
             lifeCycle_ = value;
           }
@@ -4890,7 +4890,7 @@ public final class RemoteProtocol {
       }
       public Builder clearLifeCycle() {
         if (lifeCycleBuilder_ == null) {
-          lifeCycle_ = akka.cluster.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
+          lifeCycle_ = akka.remote.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
           onChanged();
         } else {
           lifeCycleBuilder_.clear();
@@ -4898,12 +4898,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000080);
         return this;
       }
-      public akka.cluster.RemoteProtocol.LifeCycleProtocol.Builder getLifeCycleBuilder() {
+      public akka.remote.RemoteProtocol.LifeCycleProtocol.Builder getLifeCycleBuilder() {
         bitField0_ |= 0x00000080;
         onChanged();
         return getLifeCycleFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.LifeCycleProtocolOrBuilder getLifeCycleOrBuilder() {
+      public akka.remote.RemoteProtocol.LifeCycleProtocolOrBuilder getLifeCycleOrBuilder() {
         if (lifeCycleBuilder_ != null) {
           return lifeCycleBuilder_.getMessageOrBuilder();
         } else {
@@ -4911,11 +4911,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.LifeCycleProtocol, akka.cluster.RemoteProtocol.LifeCycleProtocol.Builder, akka.cluster.RemoteProtocol.LifeCycleProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.LifeCycleProtocol, akka.remote.RemoteProtocol.LifeCycleProtocol.Builder, akka.remote.RemoteProtocol.LifeCycleProtocolOrBuilder> 
           getLifeCycleFieldBuilder() {
         if (lifeCycleBuilder_ == null) {
           lifeCycleBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.LifeCycleProtocol, akka.cluster.RemoteProtocol.LifeCycleProtocol.Builder, akka.cluster.RemoteProtocol.LifeCycleProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.LifeCycleProtocol, akka.remote.RemoteProtocol.LifeCycleProtocol.Builder, akka.remote.RemoteProtocol.LifeCycleProtocolOrBuilder>(
                   lifeCycle_,
                   getParentForChildren(),
                   isClean());
@@ -4925,20 +4925,20 @@ public final class RemoteProtocol {
       }
       
       // optional .RemoteActorRefProtocol supervisor = 9;
-      private akka.cluster.RemoteProtocol.RemoteActorRefProtocol supervisor_ = akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.RemoteActorRefProtocol supervisor_ = akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.RemoteActorRefProtocol, akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder, akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder> supervisorBuilder_;
+          akka.remote.RemoteProtocol.RemoteActorRefProtocol, akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder, akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder> supervisorBuilder_;
       public boolean hasSupervisor() {
         return ((bitField0_ & 0x00000100) == 0x00000100);
       }
-      public akka.cluster.RemoteProtocol.RemoteActorRefProtocol getSupervisor() {
+      public akka.remote.RemoteProtocol.RemoteActorRefProtocol getSupervisor() {
         if (supervisorBuilder_ == null) {
           return supervisor_;
         } else {
           return supervisorBuilder_.getMessage();
         }
       }
-      public Builder setSupervisor(akka.cluster.RemoteProtocol.RemoteActorRefProtocol value) {
+      public Builder setSupervisor(akka.remote.RemoteProtocol.RemoteActorRefProtocol value) {
         if (supervisorBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -4952,7 +4952,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setSupervisor(
-          akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder builderForValue) {
         if (supervisorBuilder_ == null) {
           supervisor_ = builderForValue.build();
           onChanged();
@@ -4962,12 +4962,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000100;
         return this;
       }
-      public Builder mergeSupervisor(akka.cluster.RemoteProtocol.RemoteActorRefProtocol value) {
+      public Builder mergeSupervisor(akka.remote.RemoteProtocol.RemoteActorRefProtocol value) {
         if (supervisorBuilder_ == null) {
           if (((bitField0_ & 0x00000100) == 0x00000100) &&
-              supervisor_ != akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) {
+              supervisor_ != akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) {
             supervisor_ =
-              akka.cluster.RemoteProtocol.RemoteActorRefProtocol.newBuilder(supervisor_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.RemoteActorRefProtocol.newBuilder(supervisor_).mergeFrom(value).buildPartial();
           } else {
             supervisor_ = value;
           }
@@ -4980,7 +4980,7 @@ public final class RemoteProtocol {
       }
       public Builder clearSupervisor() {
         if (supervisorBuilder_ == null) {
-          supervisor_ = akka.cluster.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
+          supervisor_ = akka.remote.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
           onChanged();
         } else {
           supervisorBuilder_.clear();
@@ -4988,12 +4988,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000100);
         return this;
       }
-      public akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder getSupervisorBuilder() {
+      public akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder getSupervisorBuilder() {
         bitField0_ |= 0x00000100;
         onChanged();
         return getSupervisorFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder getSupervisorOrBuilder() {
+      public akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder getSupervisorOrBuilder() {
         if (supervisorBuilder_ != null) {
           return supervisorBuilder_.getMessageOrBuilder();
         } else {
@@ -5001,11 +5001,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.RemoteActorRefProtocol, akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder, akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.RemoteActorRefProtocol, akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder, akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder> 
           getSupervisorFieldBuilder() {
         if (supervisorBuilder_ == null) {
           supervisorBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.RemoteActorRefProtocol, akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder, akka.cluster.RemoteProtocol.RemoteActorRefProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.RemoteActorRefProtocol, akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder, akka.remote.RemoteProtocol.RemoteActorRefProtocolOrBuilder>(
                   supervisor_,
                   getParentForChildren(),
                   isClean());
@@ -5039,14 +5039,14 @@ public final class RemoteProtocol {
       }
       
       // optional .ReplicationStorageType replicationStorage = 11;
-      private akka.cluster.RemoteProtocol.ReplicationStorageType replicationStorage_ = akka.cluster.RemoteProtocol.ReplicationStorageType.TRANSIENT;
+      private akka.remote.RemoteProtocol.ReplicationStorageType replicationStorage_ = akka.remote.RemoteProtocol.ReplicationStorageType.TRANSIENT;
       public boolean hasReplicationStorage() {
         return ((bitField0_ & 0x00000400) == 0x00000400);
       }
-      public akka.cluster.RemoteProtocol.ReplicationStorageType getReplicationStorage() {
+      public akka.remote.RemoteProtocol.ReplicationStorageType getReplicationStorage() {
         return replicationStorage_;
       }
-      public Builder setReplicationStorage(akka.cluster.RemoteProtocol.ReplicationStorageType value) {
+      public Builder setReplicationStorage(akka.remote.RemoteProtocol.ReplicationStorageType value) {
         if (value == null) {
           throw new NullPointerException();
         }
@@ -5057,20 +5057,20 @@ public final class RemoteProtocol {
       }
       public Builder clearReplicationStorage() {
         bitField0_ = (bitField0_ & ~0x00000400);
-        replicationStorage_ = akka.cluster.RemoteProtocol.ReplicationStorageType.TRANSIENT;
+        replicationStorage_ = akka.remote.RemoteProtocol.ReplicationStorageType.TRANSIENT;
         onChanged();
         return this;
       }
       
       // optional .ReplicationStrategyType replicationStrategy = 12;
-      private akka.cluster.RemoteProtocol.ReplicationStrategyType replicationStrategy_ = akka.cluster.RemoteProtocol.ReplicationStrategyType.WRITE_THROUGH;
+      private akka.remote.RemoteProtocol.ReplicationStrategyType replicationStrategy_ = akka.remote.RemoteProtocol.ReplicationStrategyType.WRITE_THROUGH;
       public boolean hasReplicationStrategy() {
         return ((bitField0_ & 0x00000800) == 0x00000800);
       }
-      public akka.cluster.RemoteProtocol.ReplicationStrategyType getReplicationStrategy() {
+      public akka.remote.RemoteProtocol.ReplicationStrategyType getReplicationStrategy() {
         return replicationStrategy_;
       }
-      public Builder setReplicationStrategy(akka.cluster.RemoteProtocol.ReplicationStrategyType value) {
+      public Builder setReplicationStrategy(akka.remote.RemoteProtocol.ReplicationStrategyType value) {
         if (value == null) {
           throw new NullPointerException();
         }
@@ -5081,25 +5081,25 @@ public final class RemoteProtocol {
       }
       public Builder clearReplicationStrategy() {
         bitField0_ = (bitField0_ & ~0x00000800);
-        replicationStrategy_ = akka.cluster.RemoteProtocol.ReplicationStrategyType.WRITE_THROUGH;
+        replicationStrategy_ = akka.remote.RemoteProtocol.ReplicationStrategyType.WRITE_THROUGH;
         onChanged();
         return this;
       }
       
       // repeated .RemoteMessageProtocol messages = 13;
-      private java.util.List<akka.cluster.RemoteProtocol.RemoteMessageProtocol> messages_ =
+      private java.util.List<akka.remote.RemoteProtocol.RemoteMessageProtocol> messages_ =
         java.util.Collections.emptyList();
       private void ensureMessagesIsMutable() {
         if (!((bitField0_ & 0x00001000) == 0x00001000)) {
-          messages_ = new java.util.ArrayList<akka.cluster.RemoteProtocol.RemoteMessageProtocol>(messages_);
+          messages_ = new java.util.ArrayList<akka.remote.RemoteProtocol.RemoteMessageProtocol>(messages_);
           bitField0_ |= 0x00001000;
          }
       }
       
       private com.google.protobuf.RepeatedFieldBuilder<
-          akka.cluster.RemoteProtocol.RemoteMessageProtocol, akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder, akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder> messagesBuilder_;
+          akka.remote.RemoteProtocol.RemoteMessageProtocol, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder, akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder> messagesBuilder_;
       
-      public java.util.List<akka.cluster.RemoteProtocol.RemoteMessageProtocol> getMessagesList() {
+      public java.util.List<akka.remote.RemoteProtocol.RemoteMessageProtocol> getMessagesList() {
         if (messagesBuilder_ == null) {
           return java.util.Collections.unmodifiableList(messages_);
         } else {
@@ -5113,7 +5113,7 @@ public final class RemoteProtocol {
           return messagesBuilder_.getCount();
         }
       }
-      public akka.cluster.RemoteProtocol.RemoteMessageProtocol getMessages(int index) {
+      public akka.remote.RemoteProtocol.RemoteMessageProtocol getMessages(int index) {
         if (messagesBuilder_ == null) {
           return messages_.get(index);
         } else {
@@ -5121,7 +5121,7 @@ public final class RemoteProtocol {
         }
       }
       public Builder setMessages(
-          int index, akka.cluster.RemoteProtocol.RemoteMessageProtocol value) {
+          int index, akka.remote.RemoteProtocol.RemoteMessageProtocol value) {
         if (messagesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5135,7 +5135,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setMessages(
-          int index, akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
+          int index, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
         if (messagesBuilder_ == null) {
           ensureMessagesIsMutable();
           messages_.set(index, builderForValue.build());
@@ -5145,7 +5145,7 @@ public final class RemoteProtocol {
         }
         return this;
       }
-      public Builder addMessages(akka.cluster.RemoteProtocol.RemoteMessageProtocol value) {
+      public Builder addMessages(akka.remote.RemoteProtocol.RemoteMessageProtocol value) {
         if (messagesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5159,7 +5159,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder addMessages(
-          int index, akka.cluster.RemoteProtocol.RemoteMessageProtocol value) {
+          int index, akka.remote.RemoteProtocol.RemoteMessageProtocol value) {
         if (messagesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5173,7 +5173,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder addMessages(
-          akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
         if (messagesBuilder_ == null) {
           ensureMessagesIsMutable();
           messages_.add(builderForValue.build());
@@ -5184,7 +5184,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder addMessages(
-          int index, akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
+          int index, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
         if (messagesBuilder_ == null) {
           ensureMessagesIsMutable();
           messages_.add(index, builderForValue.build());
@@ -5195,7 +5195,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder addAllMessages(
-          java.lang.Iterable<? extends akka.cluster.RemoteProtocol.RemoteMessageProtocol> values) {
+          java.lang.Iterable<? extends akka.remote.RemoteProtocol.RemoteMessageProtocol> values) {
         if (messagesBuilder_ == null) {
           ensureMessagesIsMutable();
           super.addAll(values, messages_);
@@ -5225,18 +5225,18 @@ public final class RemoteProtocol {
         }
         return this;
       }
-      public akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder getMessagesBuilder(
+      public akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder getMessagesBuilder(
           int index) {
         return getMessagesFieldBuilder().getBuilder(index);
       }
-      public akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessagesOrBuilder(
+      public akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder getMessagesOrBuilder(
           int index) {
         if (messagesBuilder_ == null) {
           return messages_.get(index);  } else {
           return messagesBuilder_.getMessageOrBuilder(index);
         }
       }
-      public java.util.List<? extends akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder> 
+      public java.util.List<? extends akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder> 
            getMessagesOrBuilderList() {
         if (messagesBuilder_ != null) {
           return messagesBuilder_.getMessageOrBuilderList();
@@ -5244,25 +5244,25 @@ public final class RemoteProtocol {
           return java.util.Collections.unmodifiableList(messages_);
         }
       }
-      public akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder addMessagesBuilder() {
+      public akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder addMessagesBuilder() {
         return getMessagesFieldBuilder().addBuilder(
-            akka.cluster.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance());
+            akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance());
       }
-      public akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder addMessagesBuilder(
+      public akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder addMessagesBuilder(
           int index) {
         return getMessagesFieldBuilder().addBuilder(
-            index, akka.cluster.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance());
+            index, akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance());
       }
-      public java.util.List<akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder> 
+      public java.util.List<akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder> 
            getMessagesBuilderList() {
         return getMessagesFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilder<
-          akka.cluster.RemoteProtocol.RemoteMessageProtocol, akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder, akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.RemoteMessageProtocol, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder, akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder> 
           getMessagesFieldBuilder() {
         if (messagesBuilder_ == null) {
           messagesBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
-              akka.cluster.RemoteProtocol.RemoteMessageProtocol, akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder, akka.cluster.RemoteProtocol.RemoteMessageProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.RemoteMessageProtocol, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder, akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder>(
                   messages_,
                   ((bitField0_ & 0x00001000) == 0x00001000),
                   getParentForChildren(),
@@ -5288,8 +5288,8 @@ public final class RemoteProtocol {
     
     // required .SerializedActorRefProtocol actorRef = 1;
     boolean hasActorRef();
-    akka.cluster.RemoteProtocol.SerializedActorRefProtocol getActorRef();
-    akka.cluster.RemoteProtocol.SerializedActorRefProtocolOrBuilder getActorRefOrBuilder();
+    akka.remote.RemoteProtocol.SerializedActorRefProtocol getActorRef();
+    akka.remote.RemoteProtocol.SerializedActorRefProtocolOrBuilder getActorRefOrBuilder();
     
     // required string interfaceName = 2;
     boolean hasInterfaceName();
@@ -5315,25 +5315,25 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
     // required .SerializedActorRefProtocol actorRef = 1;
     public static final int ACTORREF_FIELD_NUMBER = 1;
-    private akka.cluster.RemoteProtocol.SerializedActorRefProtocol actorRef_;
+    private akka.remote.RemoteProtocol.SerializedActorRefProtocol actorRef_;
     public boolean hasActorRef() {
       return ((bitField0_ & 0x00000001) == 0x00000001);
     }
-    public akka.cluster.RemoteProtocol.SerializedActorRefProtocol getActorRef() {
+    public akka.remote.RemoteProtocol.SerializedActorRefProtocol getActorRef() {
       return actorRef_;
     }
-    public akka.cluster.RemoteProtocol.SerializedActorRefProtocolOrBuilder getActorRefOrBuilder() {
+    public akka.remote.RemoteProtocol.SerializedActorRefProtocolOrBuilder getActorRefOrBuilder() {
       return actorRef_;
     }
     
@@ -5370,7 +5370,7 @@ public final class RemoteProtocol {
     }
     
     private void initFields() {
-      actorRef_ = akka.cluster.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
+      actorRef_ = akka.remote.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
       interfaceName_ = "";
     }
     private byte memoizedIsInitialized = -1;
@@ -5432,41 +5432,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -5475,7 +5475,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -5486,12 +5486,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -5501,7 +5501,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -5514,23 +5514,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.SerializedTypedActorRefProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -5546,7 +5546,7 @@ public final class RemoteProtocol {
       public Builder clear() {
         super.clear();
         if (actorRefBuilder_ == null) {
-          actorRef_ = akka.cluster.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
+          actorRef_ = akka.remote.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
         } else {
           actorRefBuilder_.clear();
         }
@@ -5562,24 +5562,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol build() {
-        akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol build() {
+        akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol buildParsed()
+      private akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -5587,8 +5587,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol result = new akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol(this);
+      public akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol buildPartial() {
+        akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol result = new akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -5609,16 +5609,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol other) {
+        if (other == akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol.getDefaultInstance()) return this;
         if (other.hasActorRef()) {
           mergeActorRef(other.getActorRef());
         }
@@ -5669,7 +5669,7 @@ public final class RemoteProtocol {
               break;
             }
             case 10: {
-              akka.cluster.RemoteProtocol.SerializedActorRefProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.SerializedActorRefProtocol.newBuilder();
+              akka.remote.RemoteProtocol.SerializedActorRefProtocol.Builder subBuilder = akka.remote.RemoteProtocol.SerializedActorRefProtocol.newBuilder();
               if (hasActorRef()) {
                 subBuilder.mergeFrom(getActorRef());
               }
@@ -5689,20 +5689,20 @@ public final class RemoteProtocol {
       private int bitField0_;
       
       // required .SerializedActorRefProtocol actorRef = 1;
-      private akka.cluster.RemoteProtocol.SerializedActorRefProtocol actorRef_ = akka.cluster.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.SerializedActorRefProtocol actorRef_ = akka.remote.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.SerializedActorRefProtocol, akka.cluster.RemoteProtocol.SerializedActorRefProtocol.Builder, akka.cluster.RemoteProtocol.SerializedActorRefProtocolOrBuilder> actorRefBuilder_;
+          akka.remote.RemoteProtocol.SerializedActorRefProtocol, akka.remote.RemoteProtocol.SerializedActorRefProtocol.Builder, akka.remote.RemoteProtocol.SerializedActorRefProtocolOrBuilder> actorRefBuilder_;
       public boolean hasActorRef() {
         return ((bitField0_ & 0x00000001) == 0x00000001);
       }
-      public akka.cluster.RemoteProtocol.SerializedActorRefProtocol getActorRef() {
+      public akka.remote.RemoteProtocol.SerializedActorRefProtocol getActorRef() {
         if (actorRefBuilder_ == null) {
           return actorRef_;
         } else {
           return actorRefBuilder_.getMessage();
         }
       }
-      public Builder setActorRef(akka.cluster.RemoteProtocol.SerializedActorRefProtocol value) {
+      public Builder setActorRef(akka.remote.RemoteProtocol.SerializedActorRefProtocol value) {
         if (actorRefBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5716,7 +5716,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setActorRef(
-          akka.cluster.RemoteProtocol.SerializedActorRefProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.SerializedActorRefProtocol.Builder builderForValue) {
         if (actorRefBuilder_ == null) {
           actorRef_ = builderForValue.build();
           onChanged();
@@ -5726,12 +5726,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000001;
         return this;
       }
-      public Builder mergeActorRef(akka.cluster.RemoteProtocol.SerializedActorRefProtocol value) {
+      public Builder mergeActorRef(akka.remote.RemoteProtocol.SerializedActorRefProtocol value) {
         if (actorRefBuilder_ == null) {
           if (((bitField0_ & 0x00000001) == 0x00000001) &&
-              actorRef_ != akka.cluster.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance()) {
+              actorRef_ != akka.remote.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance()) {
             actorRef_ =
-              akka.cluster.RemoteProtocol.SerializedActorRefProtocol.newBuilder(actorRef_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.SerializedActorRefProtocol.newBuilder(actorRef_).mergeFrom(value).buildPartial();
           } else {
             actorRef_ = value;
           }
@@ -5744,7 +5744,7 @@ public final class RemoteProtocol {
       }
       public Builder clearActorRef() {
         if (actorRefBuilder_ == null) {
-          actorRef_ = akka.cluster.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
+          actorRef_ = akka.remote.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
           onChanged();
         } else {
           actorRefBuilder_.clear();
@@ -5752,12 +5752,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000001);
         return this;
       }
-      public akka.cluster.RemoteProtocol.SerializedActorRefProtocol.Builder getActorRefBuilder() {
+      public akka.remote.RemoteProtocol.SerializedActorRefProtocol.Builder getActorRefBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getActorRefFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.SerializedActorRefProtocolOrBuilder getActorRefOrBuilder() {
+      public akka.remote.RemoteProtocol.SerializedActorRefProtocolOrBuilder getActorRefOrBuilder() {
         if (actorRefBuilder_ != null) {
           return actorRefBuilder_.getMessageOrBuilder();
         } else {
@@ -5765,11 +5765,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.SerializedActorRefProtocol, akka.cluster.RemoteProtocol.SerializedActorRefProtocol.Builder, akka.cluster.RemoteProtocol.SerializedActorRefProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.SerializedActorRefProtocol, akka.remote.RemoteProtocol.SerializedActorRefProtocol.Builder, akka.remote.RemoteProtocol.SerializedActorRefProtocolOrBuilder> 
           getActorRefFieldBuilder() {
         if (actorRefBuilder_ == null) {
           actorRefBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.SerializedActorRefProtocol, akka.cluster.RemoteProtocol.SerializedActorRefProtocol.Builder, akka.cluster.RemoteProtocol.SerializedActorRefProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.SerializedActorRefProtocol, akka.remote.RemoteProtocol.SerializedActorRefProtocol.Builder, akka.remote.RemoteProtocol.SerializedActorRefProtocolOrBuilder>(
                   actorRef_,
                   getParentForChildren(),
                   isClean());
@@ -5856,12 +5856,12 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_MessageProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_MessageProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_MessageProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_MessageProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
@@ -5940,41 +5940,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.MessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.MessageProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.MessageProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MessageProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.MessageProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.MessageProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MessageProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.MessageProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.MessageProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MessageProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.MessageProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -5983,7 +5983,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.MessageProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.MessageProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -5994,12 +5994,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.MessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.MessageProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.MessageProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -6009,7 +6009,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.MessageProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.MessageProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -6022,23 +6022,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.MessageProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.MessageProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_MessageProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_MessageProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_MessageProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_MessageProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.MessageProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.MessageProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -6065,24 +6065,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.MessageProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.MessageProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.MessageProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.MessageProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.MessageProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.MessageProtocol build() {
-        akka.cluster.RemoteProtocol.MessageProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.MessageProtocol build() {
+        akka.remote.RemoteProtocol.MessageProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.MessageProtocol buildParsed()
+      private akka.remote.RemoteProtocol.MessageProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.MessageProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.MessageProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -6090,8 +6090,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.MessageProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.MessageProtocol result = new akka.cluster.RemoteProtocol.MessageProtocol(this);
+      public akka.remote.RemoteProtocol.MessageProtocol buildPartial() {
+        akka.remote.RemoteProtocol.MessageProtocol result = new akka.remote.RemoteProtocol.MessageProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -6108,16 +6108,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.MessageProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.MessageProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.MessageProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.MessageProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.MessageProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.MessageProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.MessageProtocol other) {
+        if (other == akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance()) return this;
         if (other.hasMessage()) {
           setMessage(other.getMessage());
         }
@@ -6239,8 +6239,8 @@ public final class RemoteProtocol {
     
     // required .UuidProtocol uuid = 1;
     boolean hasUuid();
-    akka.cluster.RemoteProtocol.UuidProtocol getUuid();
-    akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder();
+    akka.remote.RemoteProtocol.UuidProtocol getUuid();
+    akka.remote.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder();
     
     // required uint64 timeout = 2;
     boolean hasTimeout();
@@ -6270,25 +6270,25 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_ActorInfoProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_ActorInfoProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_ActorInfoProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_ActorInfoProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
     // required .UuidProtocol uuid = 1;
     public static final int UUID_FIELD_NUMBER = 1;
-    private akka.cluster.RemoteProtocol.UuidProtocol uuid_;
+    private akka.remote.RemoteProtocol.UuidProtocol uuid_;
     public boolean hasUuid() {
       return ((bitField0_ & 0x00000001) == 0x00000001);
     }
-    public akka.cluster.RemoteProtocol.UuidProtocol getUuid() {
+    public akka.remote.RemoteProtocol.UuidProtocol getUuid() {
       return uuid_;
     }
-    public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder() {
+    public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder() {
       return uuid_;
     }
     
@@ -6335,7 +6335,7 @@ public final class RemoteProtocol {
     }
     
     private void initFields() {
-      uuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      uuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
       timeout_ = 0L;
       address_ = "";
     }
@@ -6405,41 +6405,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.ActorInfoProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.ActorInfoProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ActorInfoProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.ActorInfoProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ActorInfoProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.ActorInfoProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ActorInfoProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.ActorInfoProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ActorInfoProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.ActorInfoProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ActorInfoProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.ActorInfoProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ActorInfoProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.ActorInfoProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -6448,7 +6448,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.ActorInfoProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.ActorInfoProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -6459,12 +6459,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.ActorInfoProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.ActorInfoProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ActorInfoProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.ActorInfoProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -6474,7 +6474,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.ActorInfoProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.ActorInfoProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -6487,23 +6487,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.ActorInfoProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.ActorInfoProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_ActorInfoProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_ActorInfoProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_ActorInfoProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_ActorInfoProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.ActorInfoProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.ActorInfoProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -6519,7 +6519,7 @@ public final class RemoteProtocol {
       public Builder clear() {
         super.clear();
         if (uuidBuilder_ == null) {
-          uuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          uuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
         } else {
           uuidBuilder_.clear();
         }
@@ -6537,24 +6537,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.ActorInfoProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.ActorInfoProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.ActorInfoProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.ActorInfoProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.ActorInfoProtocol build() {
-        akka.cluster.RemoteProtocol.ActorInfoProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.ActorInfoProtocol build() {
+        akka.remote.RemoteProtocol.ActorInfoProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.ActorInfoProtocol buildParsed()
+      private akka.remote.RemoteProtocol.ActorInfoProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.ActorInfoProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.ActorInfoProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -6562,8 +6562,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.ActorInfoProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.ActorInfoProtocol result = new akka.cluster.RemoteProtocol.ActorInfoProtocol(this);
+      public akka.remote.RemoteProtocol.ActorInfoProtocol buildPartial() {
+        akka.remote.RemoteProtocol.ActorInfoProtocol result = new akka.remote.RemoteProtocol.ActorInfoProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -6588,16 +6588,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.ActorInfoProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.ActorInfoProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.ActorInfoProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.ActorInfoProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.ActorInfoProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.ActorInfoProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.ActorInfoProtocol other) {
+        if (other == akka.remote.RemoteProtocol.ActorInfoProtocol.getDefaultInstance()) return this;
         if (other.hasUuid()) {
           mergeUuid(other.getUuid());
         }
@@ -6651,7 +6651,7 @@ public final class RemoteProtocol {
               break;
             }
             case 10: {
-              akka.cluster.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.UuidProtocol.newBuilder();
+              akka.remote.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.RemoteProtocol.UuidProtocol.newBuilder();
               if (hasUuid()) {
                 subBuilder.mergeFrom(getUuid());
               }
@@ -6676,20 +6676,20 @@ public final class RemoteProtocol {
       private int bitField0_;
       
       // required .UuidProtocol uuid = 1;
-      private akka.cluster.RemoteProtocol.UuidProtocol uuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.UuidProtocol uuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> uuidBuilder_;
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> uuidBuilder_;
       public boolean hasUuid() {
         return ((bitField0_ & 0x00000001) == 0x00000001);
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol getUuid() {
+      public akka.remote.RemoteProtocol.UuidProtocol getUuid() {
         if (uuidBuilder_ == null) {
           return uuid_;
         } else {
           return uuidBuilder_.getMessage();
         }
       }
-      public Builder setUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder setUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (uuidBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6703,7 +6703,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setUuid(
-          akka.cluster.RemoteProtocol.UuidProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.UuidProtocol.Builder builderForValue) {
         if (uuidBuilder_ == null) {
           uuid_ = builderForValue.build();
           onChanged();
@@ -6713,12 +6713,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000001;
         return this;
       }
-      public Builder mergeUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder mergeUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (uuidBuilder_ == null) {
           if (((bitField0_ & 0x00000001) == 0x00000001) &&
-              uuid_ != akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
+              uuid_ != akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
             uuid_ =
-              akka.cluster.RemoteProtocol.UuidProtocol.newBuilder(uuid_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.UuidProtocol.newBuilder(uuid_).mergeFrom(value).buildPartial();
           } else {
             uuid_ = value;
           }
@@ -6731,7 +6731,7 @@ public final class RemoteProtocol {
       }
       public Builder clearUuid() {
         if (uuidBuilder_ == null) {
-          uuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          uuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
           onChanged();
         } else {
           uuidBuilder_.clear();
@@ -6739,12 +6739,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000001);
         return this;
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol.Builder getUuidBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocol.Builder getUuidBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getUuidFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getUuidOrBuilder() {
         if (uuidBuilder_ != null) {
           return uuidBuilder_.getMessageOrBuilder();
         } else {
@@ -6752,11 +6752,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> 
           getUuidFieldBuilder() {
         if (uuidBuilder_ == null) {
           uuidBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder>(
                   uuid_,
                   getParentForChildren(),
                   isClean());
@@ -6864,12 +6864,12 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_UuidProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_UuidProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_UuidProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_UuidProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
@@ -6952,41 +6952,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.UuidProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.UuidProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.UuidProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.UuidProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.UuidProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.UuidProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.UuidProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.UuidProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.UuidProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.UuidProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.UuidProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.UuidProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.UuidProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.UuidProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -6995,7 +6995,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.UuidProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.UuidProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -7006,12 +7006,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.UuidProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.UuidProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.UuidProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.UuidProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -7021,7 +7021,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.UuidProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.UuidProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -7034,23 +7034,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.UuidProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.UuidProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_UuidProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_UuidProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_UuidProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_UuidProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.UuidProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.UuidProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -7077,24 +7077,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.UuidProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.UuidProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.UuidProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.UuidProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.UuidProtocol build() {
-        akka.cluster.RemoteProtocol.UuidProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.UuidProtocol build() {
+        akka.remote.RemoteProtocol.UuidProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.UuidProtocol buildParsed()
+      private akka.remote.RemoteProtocol.UuidProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.UuidProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.UuidProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -7102,8 +7102,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.UuidProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.UuidProtocol result = new akka.cluster.RemoteProtocol.UuidProtocol(this);
+      public akka.remote.RemoteProtocol.UuidProtocol buildPartial() {
+        akka.remote.RemoteProtocol.UuidProtocol result = new akka.remote.RemoteProtocol.UuidProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -7120,16 +7120,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.UuidProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.UuidProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.UuidProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.UuidProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.UuidProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.UuidProtocol other) {
+        if (other == akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance()) return this;
         if (other.hasHigh()) {
           setHigh(other.getHigh());
         }
@@ -7275,12 +7275,12 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_MetadataEntryProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_MetadataEntryProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_MetadataEntryProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_MetadataEntryProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
@@ -7385,41 +7385,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.MetadataEntryProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.MetadataEntryProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MetadataEntryProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.MetadataEntryProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MetadataEntryProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.MetadataEntryProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MetadataEntryProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.MetadataEntryProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MetadataEntryProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.MetadataEntryProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MetadataEntryProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.MetadataEntryProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MetadataEntryProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.MetadataEntryProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -7428,7 +7428,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.MetadataEntryProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.MetadataEntryProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -7439,12 +7439,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.MetadataEntryProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.MetadataEntryProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.MetadataEntryProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.MetadataEntryProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -7454,7 +7454,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.MetadataEntryProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.MetadataEntryProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -7467,23 +7467,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.MetadataEntryProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_MetadataEntryProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_MetadataEntryProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_MetadataEntryProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_MetadataEntryProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.MetadataEntryProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.MetadataEntryProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -7510,24 +7510,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.MetadataEntryProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.MetadataEntryProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.MetadataEntryProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.MetadataEntryProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.MetadataEntryProtocol build() {
-        akka.cluster.RemoteProtocol.MetadataEntryProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.MetadataEntryProtocol build() {
+        akka.remote.RemoteProtocol.MetadataEntryProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.MetadataEntryProtocol buildParsed()
+      private akka.remote.RemoteProtocol.MetadataEntryProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.MetadataEntryProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.MetadataEntryProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -7535,8 +7535,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.MetadataEntryProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.MetadataEntryProtocol result = new akka.cluster.RemoteProtocol.MetadataEntryProtocol(this);
+      public akka.remote.RemoteProtocol.MetadataEntryProtocol buildPartial() {
+        akka.remote.RemoteProtocol.MetadataEntryProtocol result = new akka.remote.RemoteProtocol.MetadataEntryProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -7553,16 +7553,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.MetadataEntryProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.MetadataEntryProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.MetadataEntryProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.MetadataEntryProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.MetadataEntryProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.MetadataEntryProtocol other) {
+        if (other == akka.remote.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance()) return this;
         if (other.hasKey()) {
           setKey(other.getKey());
         }
@@ -7700,7 +7700,7 @@ public final class RemoteProtocol {
     
     // required .LifeCycleType lifeCycle = 1;
     boolean hasLifeCycle();
-    akka.cluster.RemoteProtocol.LifeCycleType getLifeCycle();
+    akka.remote.RemoteProtocol.LifeCycleType getLifeCycle();
   }
   public static final class LifeCycleProtocol extends
       com.google.protobuf.GeneratedMessage
@@ -7722,27 +7722,27 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_LifeCycleProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_LifeCycleProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_LifeCycleProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_LifeCycleProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
     // required .LifeCycleType lifeCycle = 1;
     public static final int LIFECYCLE_FIELD_NUMBER = 1;
-    private akka.cluster.RemoteProtocol.LifeCycleType lifeCycle_;
+    private akka.remote.RemoteProtocol.LifeCycleType lifeCycle_;
     public boolean hasLifeCycle() {
       return ((bitField0_ & 0x00000001) == 0x00000001);
     }
-    public akka.cluster.RemoteProtocol.LifeCycleType getLifeCycle() {
+    public akka.remote.RemoteProtocol.LifeCycleType getLifeCycle() {
       return lifeCycle_;
     }
     
     private void initFields() {
-      lifeCycle_ = akka.cluster.RemoteProtocol.LifeCycleType.PERMANENT;
+      lifeCycle_ = akka.remote.RemoteProtocol.LifeCycleType.PERMANENT;
     }
     private byte memoizedIsInitialized = -1;
     public final boolean isInitialized() {
@@ -7788,41 +7788,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.LifeCycleProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.LifeCycleProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.LifeCycleProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.LifeCycleProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.LifeCycleProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.LifeCycleProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.LifeCycleProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.LifeCycleProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.LifeCycleProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.LifeCycleProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.LifeCycleProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.LifeCycleProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.LifeCycleProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.LifeCycleProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -7831,7 +7831,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.LifeCycleProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.LifeCycleProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -7842,12 +7842,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.LifeCycleProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.LifeCycleProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.LifeCycleProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.LifeCycleProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -7857,7 +7857,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.LifeCycleProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.LifeCycleProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -7870,23 +7870,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.LifeCycleProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.LifeCycleProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_LifeCycleProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_LifeCycleProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_LifeCycleProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_LifeCycleProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.LifeCycleProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.LifeCycleProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -7900,7 +7900,7 @@ public final class RemoteProtocol {
       
       public Builder clear() {
         super.clear();
-        lifeCycle_ = akka.cluster.RemoteProtocol.LifeCycleType.PERMANENT;
+        lifeCycle_ = akka.remote.RemoteProtocol.LifeCycleType.PERMANENT;
         bitField0_ = (bitField0_ & ~0x00000001);
         return this;
       }
@@ -7911,24 +7911,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.LifeCycleProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.LifeCycleProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.LifeCycleProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.LifeCycleProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.LifeCycleProtocol build() {
-        akka.cluster.RemoteProtocol.LifeCycleProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.LifeCycleProtocol build() {
+        akka.remote.RemoteProtocol.LifeCycleProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.LifeCycleProtocol buildParsed()
+      private akka.remote.RemoteProtocol.LifeCycleProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.LifeCycleProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.LifeCycleProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -7936,8 +7936,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.LifeCycleProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.LifeCycleProtocol result = new akka.cluster.RemoteProtocol.LifeCycleProtocol(this);
+      public akka.remote.RemoteProtocol.LifeCycleProtocol buildPartial() {
+        akka.remote.RemoteProtocol.LifeCycleProtocol result = new akka.remote.RemoteProtocol.LifeCycleProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -7950,16 +7950,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.LifeCycleProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.LifeCycleProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.LifeCycleProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.LifeCycleProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.LifeCycleProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.LifeCycleProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.LifeCycleProtocol other) {
+        if (other == akka.remote.RemoteProtocol.LifeCycleProtocol.getDefaultInstance()) return this;
         if (other.hasLifeCycle()) {
           setLifeCycle(other.getLifeCycle());
         }
@@ -8000,7 +8000,7 @@ public final class RemoteProtocol {
             }
             case 8: {
               int rawValue = input.readEnum();
-              akka.cluster.RemoteProtocol.LifeCycleType value = akka.cluster.RemoteProtocol.LifeCycleType.valueOf(rawValue);
+              akka.remote.RemoteProtocol.LifeCycleType value = akka.remote.RemoteProtocol.LifeCycleType.valueOf(rawValue);
               if (value == null) {
                 unknownFields.mergeVarintField(1, rawValue);
               } else {
@@ -8016,14 +8016,14 @@ public final class RemoteProtocol {
       private int bitField0_;
       
       // required .LifeCycleType lifeCycle = 1;
-      private akka.cluster.RemoteProtocol.LifeCycleType lifeCycle_ = akka.cluster.RemoteProtocol.LifeCycleType.PERMANENT;
+      private akka.remote.RemoteProtocol.LifeCycleType lifeCycle_ = akka.remote.RemoteProtocol.LifeCycleType.PERMANENT;
       public boolean hasLifeCycle() {
         return ((bitField0_ & 0x00000001) == 0x00000001);
       }
-      public akka.cluster.RemoteProtocol.LifeCycleType getLifeCycle() {
+      public akka.remote.RemoteProtocol.LifeCycleType getLifeCycle() {
         return lifeCycle_;
       }
-      public Builder setLifeCycle(akka.cluster.RemoteProtocol.LifeCycleType value) {
+      public Builder setLifeCycle(akka.remote.RemoteProtocol.LifeCycleType value) {
         if (value == null) {
           throw new NullPointerException();
         }
@@ -8034,7 +8034,7 @@ public final class RemoteProtocol {
       }
       public Builder clearLifeCycle() {
         bitField0_ = (bitField0_ & ~0x00000001);
-        lifeCycle_ = akka.cluster.RemoteProtocol.LifeCycleType.PERMANENT;
+        lifeCycle_ = akka.remote.RemoteProtocol.LifeCycleType.PERMANENT;
         onChanged();
         return this;
       }
@@ -8081,12 +8081,12 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_AddressProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_AddressProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_AddressProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_AddressProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
@@ -8191,41 +8191,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.AddressProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.AddressProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AddressProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.AddressProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AddressProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.AddressProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AddressProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.AddressProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AddressProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.AddressProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AddressProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.AddressProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AddressProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.AddressProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -8234,7 +8234,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.AddressProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.AddressProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -8245,12 +8245,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.AddressProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.AddressProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.AddressProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.AddressProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -8260,7 +8260,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.AddressProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.AddressProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -8273,23 +8273,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.AddressProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.AddressProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_AddressProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_AddressProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_AddressProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_AddressProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.AddressProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.AddressProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -8316,24 +8316,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.AddressProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.AddressProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.AddressProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.AddressProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.AddressProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.AddressProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.AddressProtocol build() {
-        akka.cluster.RemoteProtocol.AddressProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.AddressProtocol build() {
+        akka.remote.RemoteProtocol.AddressProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.AddressProtocol buildParsed()
+      private akka.remote.RemoteProtocol.AddressProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.AddressProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.AddressProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -8341,8 +8341,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.AddressProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.AddressProtocol result = new akka.cluster.RemoteProtocol.AddressProtocol(this);
+      public akka.remote.RemoteProtocol.AddressProtocol buildPartial() {
+        akka.remote.RemoteProtocol.AddressProtocol result = new akka.remote.RemoteProtocol.AddressProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -8359,16 +8359,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.AddressProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.AddressProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.AddressProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.AddressProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.AddressProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.AddressProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.AddressProtocol other) {
+        if (other == akka.remote.RemoteProtocol.AddressProtocol.getDefaultInstance()) return this;
         if (other.hasHostname()) {
           setHostname(other.getHostname());
         }
@@ -8529,12 +8529,12 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_ExceptionProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_ExceptionProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_ExceptionProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_ExceptionProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
@@ -8661,41 +8661,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.ExceptionProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.ExceptionProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ExceptionProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.ExceptionProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ExceptionProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.ExceptionProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ExceptionProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.ExceptionProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ExceptionProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.ExceptionProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ExceptionProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.ExceptionProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ExceptionProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.ExceptionProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -8704,7 +8704,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.ExceptionProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.ExceptionProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -8715,12 +8715,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.ExceptionProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.ExceptionProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.ExceptionProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.ExceptionProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -8730,7 +8730,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.ExceptionProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.ExceptionProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -8743,23 +8743,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.ExceptionProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.ExceptionProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_ExceptionProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_ExceptionProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_ExceptionProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_ExceptionProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.ExceptionProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.ExceptionProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -8786,24 +8786,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.ExceptionProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.ExceptionProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.ExceptionProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.ExceptionProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.ExceptionProtocol build() {
-        akka.cluster.RemoteProtocol.ExceptionProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.ExceptionProtocol build() {
+        akka.remote.RemoteProtocol.ExceptionProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.ExceptionProtocol buildParsed()
+      private akka.remote.RemoteProtocol.ExceptionProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.ExceptionProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.ExceptionProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -8811,8 +8811,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.ExceptionProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.ExceptionProtocol result = new akka.cluster.RemoteProtocol.ExceptionProtocol(this);
+      public akka.remote.RemoteProtocol.ExceptionProtocol buildPartial() {
+        akka.remote.RemoteProtocol.ExceptionProtocol result = new akka.remote.RemoteProtocol.ExceptionProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -8829,16 +8829,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.ExceptionProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.ExceptionProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.ExceptionProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.ExceptionProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.ExceptionProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.ExceptionProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.ExceptionProtocol other) {
+        if (other == akka.remote.RemoteProtocol.ExceptionProtocol.getDefaultInstance()) return this;
         if (other.hasClassname()) {
           setClassname(other.getClassname());
         }
@@ -8988,12 +8988,12 @@ public final class RemoteProtocol {
     
     // required .RemoteDaemonMessageType messageType = 1;
     boolean hasMessageType();
-    akka.cluster.RemoteProtocol.RemoteDaemonMessageType getMessageType();
+    akka.remote.RemoteProtocol.RemoteDaemonMessageType getMessageType();
     
     // optional .UuidProtocol actorUuid = 2;
     boolean hasActorUuid();
-    akka.cluster.RemoteProtocol.UuidProtocol getActorUuid();
-    akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getActorUuidOrBuilder();
+    akka.remote.RemoteProtocol.UuidProtocol getActorUuid();
+    akka.remote.RemoteProtocol.UuidProtocolOrBuilder getActorUuidOrBuilder();
     
     // optional string actorAddress = 3;
     boolean hasActorAddress();
@@ -9005,8 +9005,8 @@ public final class RemoteProtocol {
     
     // optional .UuidProtocol replicateActorFromUuid = 6;
     boolean hasReplicateActorFromUuid();
-    akka.cluster.RemoteProtocol.UuidProtocol getReplicateActorFromUuid();
-    akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getReplicateActorFromUuidOrBuilder();
+    akka.remote.RemoteProtocol.UuidProtocol getReplicateActorFromUuid();
+    akka.remote.RemoteProtocol.UuidProtocolOrBuilder getReplicateActorFromUuidOrBuilder();
   }
   public static final class RemoteDaemonMessageProtocol extends
       com.google.protobuf.GeneratedMessage
@@ -9028,35 +9028,35 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_RemoteDaemonMessageProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_RemoteDaemonMessageProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_RemoteDaemonMessageProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_RemoteDaemonMessageProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
     // required .RemoteDaemonMessageType messageType = 1;
     public static final int MESSAGETYPE_FIELD_NUMBER = 1;
-    private akka.cluster.RemoteProtocol.RemoteDaemonMessageType messageType_;
+    private akka.remote.RemoteProtocol.RemoteDaemonMessageType messageType_;
     public boolean hasMessageType() {
       return ((bitField0_ & 0x00000001) == 0x00000001);
     }
-    public akka.cluster.RemoteProtocol.RemoteDaemonMessageType getMessageType() {
+    public akka.remote.RemoteProtocol.RemoteDaemonMessageType getMessageType() {
       return messageType_;
     }
     
     // optional .UuidProtocol actorUuid = 2;
     public static final int ACTORUUID_FIELD_NUMBER = 2;
-    private akka.cluster.RemoteProtocol.UuidProtocol actorUuid_;
+    private akka.remote.RemoteProtocol.UuidProtocol actorUuid_;
     public boolean hasActorUuid() {
       return ((bitField0_ & 0x00000002) == 0x00000002);
     }
-    public akka.cluster.RemoteProtocol.UuidProtocol getActorUuid() {
+    public akka.remote.RemoteProtocol.UuidProtocol getActorUuid() {
       return actorUuid_;
     }
-    public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getActorUuidOrBuilder() {
+    public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getActorUuidOrBuilder() {
       return actorUuid_;
     }
     
@@ -9104,23 +9104,23 @@ public final class RemoteProtocol {
     
     // optional .UuidProtocol replicateActorFromUuid = 6;
     public static final int REPLICATEACTORFROMUUID_FIELD_NUMBER = 6;
-    private akka.cluster.RemoteProtocol.UuidProtocol replicateActorFromUuid_;
+    private akka.remote.RemoteProtocol.UuidProtocol replicateActorFromUuid_;
     public boolean hasReplicateActorFromUuid() {
       return ((bitField0_ & 0x00000010) == 0x00000010);
     }
-    public akka.cluster.RemoteProtocol.UuidProtocol getReplicateActorFromUuid() {
+    public akka.remote.RemoteProtocol.UuidProtocol getReplicateActorFromUuid() {
       return replicateActorFromUuid_;
     }
-    public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getReplicateActorFromUuidOrBuilder() {
+    public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getReplicateActorFromUuidOrBuilder() {
       return replicateActorFromUuid_;
     }
     
     private void initFields() {
-      messageType_ = akka.cluster.RemoteProtocol.RemoteDaemonMessageType.STOP;
-      actorUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      messageType_ = akka.remote.RemoteProtocol.RemoteDaemonMessageType.STOP;
+      actorUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
       actorAddress_ = "";
       payload_ = com.google.protobuf.ByteString.EMPTY;
-      replicateActorFromUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      replicateActorFromUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
     }
     private byte memoizedIsInitialized = -1;
     public final boolean isInitialized() {
@@ -9206,41 +9206,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -9249,7 +9249,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -9260,12 +9260,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -9275,7 +9275,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -9288,23 +9288,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.RemoteDaemonMessageProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_RemoteDaemonMessageProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_RemoteDaemonMessageProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_RemoteDaemonMessageProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_RemoteDaemonMessageProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -9320,10 +9320,10 @@ public final class RemoteProtocol {
       
       public Builder clear() {
         super.clear();
-        messageType_ = akka.cluster.RemoteProtocol.RemoteDaemonMessageType.STOP;
+        messageType_ = akka.remote.RemoteProtocol.RemoteDaemonMessageType.STOP;
         bitField0_ = (bitField0_ & ~0x00000001);
         if (actorUuidBuilder_ == null) {
-          actorUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          actorUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
         } else {
           actorUuidBuilder_.clear();
         }
@@ -9333,7 +9333,7 @@ public final class RemoteProtocol {
         payload_ = com.google.protobuf.ByteString.EMPTY;
         bitField0_ = (bitField0_ & ~0x00000008);
         if (replicateActorFromUuidBuilder_ == null) {
-          replicateActorFromUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          replicateActorFromUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
         } else {
           replicateActorFromUuidBuilder_.clear();
         }
@@ -9347,24 +9347,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol build() {
-        akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol build() {
+        akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol buildParsed()
+      private akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -9372,8 +9372,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol result = new akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol(this);
+      public akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol buildPartial() {
+        akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol result = new akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -9410,16 +9410,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol other) {
+        if (other == akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol.getDefaultInstance()) return this;
         if (other.hasMessageType()) {
           setMessageType(other.getMessageType());
         }
@@ -9484,7 +9484,7 @@ public final class RemoteProtocol {
             }
             case 8: {
               int rawValue = input.readEnum();
-              akka.cluster.RemoteProtocol.RemoteDaemonMessageType value = akka.cluster.RemoteProtocol.RemoteDaemonMessageType.valueOf(rawValue);
+              akka.remote.RemoteProtocol.RemoteDaemonMessageType value = akka.remote.RemoteProtocol.RemoteDaemonMessageType.valueOf(rawValue);
               if (value == null) {
                 unknownFields.mergeVarintField(1, rawValue);
               } else {
@@ -9494,7 +9494,7 @@ public final class RemoteProtocol {
               break;
             }
             case 18: {
-              akka.cluster.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.UuidProtocol.newBuilder();
+              akka.remote.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.RemoteProtocol.UuidProtocol.newBuilder();
               if (hasActorUuid()) {
                 subBuilder.mergeFrom(getActorUuid());
               }
@@ -9513,7 +9513,7 @@ public final class RemoteProtocol {
               break;
             }
             case 50: {
-              akka.cluster.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.UuidProtocol.newBuilder();
+              akka.remote.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.RemoteProtocol.UuidProtocol.newBuilder();
               if (hasReplicateActorFromUuid()) {
                 subBuilder.mergeFrom(getReplicateActorFromUuid());
               }
@@ -9528,14 +9528,14 @@ public final class RemoteProtocol {
       private int bitField0_;
       
       // required .RemoteDaemonMessageType messageType = 1;
-      private akka.cluster.RemoteProtocol.RemoteDaemonMessageType messageType_ = akka.cluster.RemoteProtocol.RemoteDaemonMessageType.STOP;
+      private akka.remote.RemoteProtocol.RemoteDaemonMessageType messageType_ = akka.remote.RemoteProtocol.RemoteDaemonMessageType.STOP;
       public boolean hasMessageType() {
         return ((bitField0_ & 0x00000001) == 0x00000001);
       }
-      public akka.cluster.RemoteProtocol.RemoteDaemonMessageType getMessageType() {
+      public akka.remote.RemoteProtocol.RemoteDaemonMessageType getMessageType() {
         return messageType_;
       }
-      public Builder setMessageType(akka.cluster.RemoteProtocol.RemoteDaemonMessageType value) {
+      public Builder setMessageType(akka.remote.RemoteProtocol.RemoteDaemonMessageType value) {
         if (value == null) {
           throw new NullPointerException();
         }
@@ -9546,26 +9546,26 @@ public final class RemoteProtocol {
       }
       public Builder clearMessageType() {
         bitField0_ = (bitField0_ & ~0x00000001);
-        messageType_ = akka.cluster.RemoteProtocol.RemoteDaemonMessageType.STOP;
+        messageType_ = akka.remote.RemoteProtocol.RemoteDaemonMessageType.STOP;
         onChanged();
         return this;
       }
       
       // optional .UuidProtocol actorUuid = 2;
-      private akka.cluster.RemoteProtocol.UuidProtocol actorUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.UuidProtocol actorUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> actorUuidBuilder_;
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> actorUuidBuilder_;
       public boolean hasActorUuid() {
         return ((bitField0_ & 0x00000002) == 0x00000002);
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol getActorUuid() {
+      public akka.remote.RemoteProtocol.UuidProtocol getActorUuid() {
         if (actorUuidBuilder_ == null) {
           return actorUuid_;
         } else {
           return actorUuidBuilder_.getMessage();
         }
       }
-      public Builder setActorUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder setActorUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (actorUuidBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -9579,7 +9579,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setActorUuid(
-          akka.cluster.RemoteProtocol.UuidProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.UuidProtocol.Builder builderForValue) {
         if (actorUuidBuilder_ == null) {
           actorUuid_ = builderForValue.build();
           onChanged();
@@ -9589,12 +9589,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000002;
         return this;
       }
-      public Builder mergeActorUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder mergeActorUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (actorUuidBuilder_ == null) {
           if (((bitField0_ & 0x00000002) == 0x00000002) &&
-              actorUuid_ != akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
+              actorUuid_ != akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
             actorUuid_ =
-              akka.cluster.RemoteProtocol.UuidProtocol.newBuilder(actorUuid_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.UuidProtocol.newBuilder(actorUuid_).mergeFrom(value).buildPartial();
           } else {
             actorUuid_ = value;
           }
@@ -9607,7 +9607,7 @@ public final class RemoteProtocol {
       }
       public Builder clearActorUuid() {
         if (actorUuidBuilder_ == null) {
-          actorUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          actorUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
           onChanged();
         } else {
           actorUuidBuilder_.clear();
@@ -9615,12 +9615,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000002);
         return this;
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol.Builder getActorUuidBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocol.Builder getActorUuidBuilder() {
         bitField0_ |= 0x00000002;
         onChanged();
         return getActorUuidFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getActorUuidOrBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getActorUuidOrBuilder() {
         if (actorUuidBuilder_ != null) {
           return actorUuidBuilder_.getMessageOrBuilder();
         } else {
@@ -9628,11 +9628,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> 
           getActorUuidFieldBuilder() {
         if (actorUuidBuilder_ == null) {
           actorUuidBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder>(
                   actorUuid_,
                   getParentForChildren(),
                   isClean());
@@ -9702,20 +9702,20 @@ public final class RemoteProtocol {
       }
       
       // optional .UuidProtocol replicateActorFromUuid = 6;
-      private akka.cluster.RemoteProtocol.UuidProtocol replicateActorFromUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.UuidProtocol replicateActorFromUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> replicateActorFromUuidBuilder_;
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> replicateActorFromUuidBuilder_;
       public boolean hasReplicateActorFromUuid() {
         return ((bitField0_ & 0x00000010) == 0x00000010);
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol getReplicateActorFromUuid() {
+      public akka.remote.RemoteProtocol.UuidProtocol getReplicateActorFromUuid() {
         if (replicateActorFromUuidBuilder_ == null) {
           return replicateActorFromUuid_;
         } else {
           return replicateActorFromUuidBuilder_.getMessage();
         }
       }
-      public Builder setReplicateActorFromUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder setReplicateActorFromUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (replicateActorFromUuidBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -9729,7 +9729,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setReplicateActorFromUuid(
-          akka.cluster.RemoteProtocol.UuidProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.UuidProtocol.Builder builderForValue) {
         if (replicateActorFromUuidBuilder_ == null) {
           replicateActorFromUuid_ = builderForValue.build();
           onChanged();
@@ -9739,12 +9739,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000010;
         return this;
       }
-      public Builder mergeReplicateActorFromUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder mergeReplicateActorFromUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (replicateActorFromUuidBuilder_ == null) {
           if (((bitField0_ & 0x00000010) == 0x00000010) &&
-              replicateActorFromUuid_ != akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
+              replicateActorFromUuid_ != akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
             replicateActorFromUuid_ =
-              akka.cluster.RemoteProtocol.UuidProtocol.newBuilder(replicateActorFromUuid_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.UuidProtocol.newBuilder(replicateActorFromUuid_).mergeFrom(value).buildPartial();
           } else {
             replicateActorFromUuid_ = value;
           }
@@ -9757,7 +9757,7 @@ public final class RemoteProtocol {
       }
       public Builder clearReplicateActorFromUuid() {
         if (replicateActorFromUuidBuilder_ == null) {
-          replicateActorFromUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          replicateActorFromUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
           onChanged();
         } else {
           replicateActorFromUuidBuilder_.clear();
@@ -9765,12 +9765,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000010);
         return this;
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol.Builder getReplicateActorFromUuidBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocol.Builder getReplicateActorFromUuidBuilder() {
         bitField0_ |= 0x00000010;
         onChanged();
         return getReplicateActorFromUuidFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getReplicateActorFromUuidOrBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getReplicateActorFromUuidOrBuilder() {
         if (replicateActorFromUuidBuilder_ != null) {
           return replicateActorFromUuidBuilder_.getMessageOrBuilder();
         } else {
@@ -9778,11 +9778,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> 
           getReplicateActorFromUuidFieldBuilder() {
         if (replicateActorFromUuidBuilder_ == null) {
           replicateActorFromUuidBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder>(
                   replicateActorFromUuid_,
                   getParentForChildren(),
                   isClean());
@@ -9815,8 +9815,8 @@ public final class RemoteProtocol {
     
     // optional .UuidProtocol futureUuid = 3;
     boolean hasFutureUuid();
-    akka.cluster.RemoteProtocol.UuidProtocol getFutureUuid();
-    akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getFutureUuidOrBuilder();
+    akka.remote.RemoteProtocol.UuidProtocol getFutureUuid();
+    akka.remote.RemoteProtocol.UuidProtocolOrBuilder getFutureUuidOrBuilder();
     
     // required bytes message = 4;
     boolean hasMessage();
@@ -9842,12 +9842,12 @@ public final class RemoteProtocol {
     
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.cluster.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_descriptor;
+      return akka.remote.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_descriptor;
     }
     
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.cluster.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_fieldAccessorTable;
+      return akka.remote.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_fieldAccessorTable;
     }
     
     private int bitField0_;
@@ -9917,14 +9917,14 @@ public final class RemoteProtocol {
     
     // optional .UuidProtocol futureUuid = 3;
     public static final int FUTUREUUID_FIELD_NUMBER = 3;
-    private akka.cluster.RemoteProtocol.UuidProtocol futureUuid_;
+    private akka.remote.RemoteProtocol.UuidProtocol futureUuid_;
     public boolean hasFutureUuid() {
       return ((bitField0_ & 0x00000004) == 0x00000004);
     }
-    public akka.cluster.RemoteProtocol.UuidProtocol getFutureUuid() {
+    public akka.remote.RemoteProtocol.UuidProtocol getFutureUuid() {
       return futureUuid_;
     }
-    public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getFutureUuidOrBuilder() {
+    public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getFutureUuidOrBuilder() {
       return futureUuid_;
     }
     
@@ -9941,7 +9941,7 @@ public final class RemoteProtocol {
     private void initFields() {
       ownerActorAddress_ = "";
       senderActorAddress_ = "";
-      futureUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      futureUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
       message_ = com.google.protobuf.ByteString.EMPTY;
     }
     private byte memoizedIsInitialized = -1;
@@ -10019,41 +10019,41 @@ public final class RemoteProtocol {
       return super.writeReplace();
     }
     
-    public static akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(byte[] data)
+    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol parseDelimitedFrom(java.io.InputStream input)
+    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -10062,7 +10062,7 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol parseDelimitedFrom(
+    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -10073,12 +10073,12 @@ public final class RemoteProtocol {
         return null;
       }
     }
-    public static akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
+    public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -10088,7 +10088,7 @@ public final class RemoteProtocol {
     
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol prototype) {
+    public static Builder newBuilder(akka.remote.RemoteProtocol.DurableMailboxMessageProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -10101,23 +10101,23 @@ public final class RemoteProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.cluster.RemoteProtocol.DurableMailboxMessageProtocolOrBuilder {
+       implements akka.remote.RemoteProtocol.DurableMailboxMessageProtocolOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.cluster.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_descriptor;
+        return akka.remote.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_descriptor;
       }
       
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.cluster.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_fieldAccessorTable;
+        return akka.remote.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_fieldAccessorTable;
       }
       
-      // Construct using akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol.newBuilder()
+      // Construct using akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
       
-      private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      private Builder(BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
       }
@@ -10137,7 +10137,7 @@ public final class RemoteProtocol {
         senderActorAddress_ = "";
         bitField0_ = (bitField0_ & ~0x00000002);
         if (futureUuidBuilder_ == null) {
-          futureUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          futureUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
         } else {
           futureUuidBuilder_.clear();
         }
@@ -10153,24 +10153,24 @@ public final class RemoteProtocol {
       
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol.getDescriptor();
+        return akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.getDescriptor();
       }
       
-      public akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol getDefaultInstanceForType() {
-        return akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol.getDefaultInstance();
+      public akka.remote.RemoteProtocol.DurableMailboxMessageProtocol getDefaultInstanceForType() {
+        return akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.getDefaultInstance();
       }
       
-      public akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol build() {
-        akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol result = buildPartial();
+      public akka.remote.RemoteProtocol.DurableMailboxMessageProtocol build() {
+        akka.remote.RemoteProtocol.DurableMailboxMessageProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
         return result;
       }
       
-      private akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol buildParsed()
+      private akka.remote.RemoteProtocol.DurableMailboxMessageProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol result = buildPartial();
+        akka.remote.RemoteProtocol.DurableMailboxMessageProtocol result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(
             result).asInvalidProtocolBufferException();
@@ -10178,8 +10178,8 @@ public final class RemoteProtocol {
         return result;
       }
       
-      public akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol buildPartial() {
-        akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol result = new akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol(this);
+      public akka.remote.RemoteProtocol.DurableMailboxMessageProtocol buildPartial() {
+        akka.remote.RemoteProtocol.DurableMailboxMessageProtocol result = new akka.remote.RemoteProtocol.DurableMailboxMessageProtocol(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -10208,16 +10208,16 @@ public final class RemoteProtocol {
       }
       
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol) {
-          return mergeFrom((akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol)other);
+        if (other instanceof akka.remote.RemoteProtocol.DurableMailboxMessageProtocol) {
+          return mergeFrom((akka.remote.RemoteProtocol.DurableMailboxMessageProtocol)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
       
-      public Builder mergeFrom(akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol other) {
-        if (other == akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol.getDefaultInstance()) return this;
+      public Builder mergeFrom(akka.remote.RemoteProtocol.DurableMailboxMessageProtocol other) {
+        if (other == akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.getDefaultInstance()) return this;
         if (other.hasOwnerActorAddress()) {
           setOwnerActorAddress(other.getOwnerActorAddress());
         }
@@ -10286,7 +10286,7 @@ public final class RemoteProtocol {
               break;
             }
             case 26: {
-              akka.cluster.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.cluster.RemoteProtocol.UuidProtocol.newBuilder();
+              akka.remote.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.RemoteProtocol.UuidProtocol.newBuilder();
               if (hasFutureUuid()) {
                 subBuilder.mergeFrom(getFutureUuid());
               }
@@ -10378,20 +10378,20 @@ public final class RemoteProtocol {
       }
       
       // optional .UuidProtocol futureUuid = 3;
-      private akka.cluster.RemoteProtocol.UuidProtocol futureUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+      private akka.remote.RemoteProtocol.UuidProtocol futureUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> futureUuidBuilder_;
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> futureUuidBuilder_;
       public boolean hasFutureUuid() {
         return ((bitField0_ & 0x00000004) == 0x00000004);
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol getFutureUuid() {
+      public akka.remote.RemoteProtocol.UuidProtocol getFutureUuid() {
         if (futureUuidBuilder_ == null) {
           return futureUuid_;
         } else {
           return futureUuidBuilder_.getMessage();
         }
       }
-      public Builder setFutureUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder setFutureUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (futureUuidBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -10405,7 +10405,7 @@ public final class RemoteProtocol {
         return this;
       }
       public Builder setFutureUuid(
-          akka.cluster.RemoteProtocol.UuidProtocol.Builder builderForValue) {
+          akka.remote.RemoteProtocol.UuidProtocol.Builder builderForValue) {
         if (futureUuidBuilder_ == null) {
           futureUuid_ = builderForValue.build();
           onChanged();
@@ -10415,12 +10415,12 @@ public final class RemoteProtocol {
         bitField0_ |= 0x00000004;
         return this;
       }
-      public Builder mergeFutureUuid(akka.cluster.RemoteProtocol.UuidProtocol value) {
+      public Builder mergeFutureUuid(akka.remote.RemoteProtocol.UuidProtocol value) {
         if (futureUuidBuilder_ == null) {
           if (((bitField0_ & 0x00000004) == 0x00000004) &&
-              futureUuid_ != akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
+              futureUuid_ != akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
             futureUuid_ =
-              akka.cluster.RemoteProtocol.UuidProtocol.newBuilder(futureUuid_).mergeFrom(value).buildPartial();
+              akka.remote.RemoteProtocol.UuidProtocol.newBuilder(futureUuid_).mergeFrom(value).buildPartial();
           } else {
             futureUuid_ = value;
           }
@@ -10433,7 +10433,7 @@ public final class RemoteProtocol {
       }
       public Builder clearFutureUuid() {
         if (futureUuidBuilder_ == null) {
-          futureUuid_ = akka.cluster.RemoteProtocol.UuidProtocol.getDefaultInstance();
+          futureUuid_ = akka.remote.RemoteProtocol.UuidProtocol.getDefaultInstance();
           onChanged();
         } else {
           futureUuidBuilder_.clear();
@@ -10441,12 +10441,12 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000004);
         return this;
       }
-      public akka.cluster.RemoteProtocol.UuidProtocol.Builder getFutureUuidBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocol.Builder getFutureUuidBuilder() {
         bitField0_ |= 0x00000004;
         onChanged();
         return getFutureUuidFieldBuilder().getBuilder();
       }
-      public akka.cluster.RemoteProtocol.UuidProtocolOrBuilder getFutureUuidOrBuilder() {
+      public akka.remote.RemoteProtocol.UuidProtocolOrBuilder getFutureUuidOrBuilder() {
         if (futureUuidBuilder_ != null) {
           return futureUuidBuilder_.getMessageOrBuilder();
         } else {
@@ -10454,11 +10454,11 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder> 
           getFutureUuidFieldBuilder() {
         if (futureUuidBuilder_ == null) {
           futureUuidBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              akka.cluster.RemoteProtocol.UuidProtocol, akka.cluster.RemoteProtocol.UuidProtocol.Builder, akka.cluster.RemoteProtocol.UuidProtocolOrBuilder>(
+              akka.remote.RemoteProtocol.UuidProtocol, akka.remote.RemoteProtocol.UuidProtocol.Builder, akka.remote.RemoteProtocol.UuidProtocolOrBuilder>(
                   futureUuid_,
                   getParentForChildren(),
                   isClean());
@@ -10648,7 +10648,7 @@ public final class RemoteProtocol {
       "\006RESIGN\020\010\022\031\n\025FAIL_OVER_CONNECTIONS\020\t\022\026\n\022",
       "FUNCTION_FUN0_UNIT\020\n\022\025\n\021FUNCTION_FUN0_AN" +
       "Y\020\013\022\032\n\026FUNCTION_FUN1_ARG_UNIT\020\014\022\031\n\025FUNCT" +
-      "ION_FUN1_ARG_ANY\020\rB\020\n\014akka.clusterH\001"
+      "ION_FUN1_ARG_ANY\020\rB\017\n\013akka.remoteH\001"
     };
     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
@@ -10661,120 +10661,120 @@ public final class RemoteProtocol {
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_AkkaRemoteProtocol_descriptor,
               new java.lang.String[] { "Message", "Instruction", },
-              akka.cluster.RemoteProtocol.AkkaRemoteProtocol.class,
-              akka.cluster.RemoteProtocol.AkkaRemoteProtocol.Builder.class);
+              akka.remote.RemoteProtocol.AkkaRemoteProtocol.class,
+              akka.remote.RemoteProtocol.AkkaRemoteProtocol.Builder.class);
           internal_static_RemoteMessageProtocol_descriptor =
             getDescriptor().getMessageTypes().get(1);
           internal_static_RemoteMessageProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_RemoteMessageProtocol_descriptor,
               new java.lang.String[] { "Uuid", "ActorInfo", "OneWay", "Message", "Exception", "SupervisorUuid", "Sender", "Metadata", },
-              akka.cluster.RemoteProtocol.RemoteMessageProtocol.class,
-              akka.cluster.RemoteProtocol.RemoteMessageProtocol.Builder.class);
+              akka.remote.RemoteProtocol.RemoteMessageProtocol.class,
+              akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder.class);
           internal_static_RemoteControlProtocol_descriptor =
             getDescriptor().getMessageTypes().get(2);
           internal_static_RemoteControlProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_RemoteControlProtocol_descriptor,
               new java.lang.String[] { "Cookie", "CommandType", },
-              akka.cluster.RemoteProtocol.RemoteControlProtocol.class,
-              akka.cluster.RemoteProtocol.RemoteControlProtocol.Builder.class);
+              akka.remote.RemoteProtocol.RemoteControlProtocol.class,
+              akka.remote.RemoteProtocol.RemoteControlProtocol.Builder.class);
           internal_static_RemoteActorRefProtocol_descriptor =
             getDescriptor().getMessageTypes().get(3);
           internal_static_RemoteActorRefProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_RemoteActorRefProtocol_descriptor,
               new java.lang.String[] { "Address", "InetSocketAddress", "Timeout", },
-              akka.cluster.RemoteProtocol.RemoteActorRefProtocol.class,
-              akka.cluster.RemoteProtocol.RemoteActorRefProtocol.Builder.class);
+              akka.remote.RemoteProtocol.RemoteActorRefProtocol.class,
+              akka.remote.RemoteProtocol.RemoteActorRefProtocol.Builder.class);
           internal_static_SerializedActorRefProtocol_descriptor =
             getDescriptor().getMessageTypes().get(4);
           internal_static_SerializedActorRefProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_SerializedActorRefProtocol_descriptor,
               new java.lang.String[] { "Uuid", "Address", "ActorClassname", "ActorInstance", "SerializerClassname", "Timeout", "ReceiveTimeout", "LifeCycle", "Supervisor", "HotswapStack", "ReplicationStorage", "ReplicationStrategy", "Messages", },
-              akka.cluster.RemoteProtocol.SerializedActorRefProtocol.class,
-              akka.cluster.RemoteProtocol.SerializedActorRefProtocol.Builder.class);
+              akka.remote.RemoteProtocol.SerializedActorRefProtocol.class,
+              akka.remote.RemoteProtocol.SerializedActorRefProtocol.Builder.class);
           internal_static_SerializedTypedActorRefProtocol_descriptor =
             getDescriptor().getMessageTypes().get(5);
           internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_SerializedTypedActorRefProtocol_descriptor,
               new java.lang.String[] { "ActorRef", "InterfaceName", },
-              akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol.class,
-              akka.cluster.RemoteProtocol.SerializedTypedActorRefProtocol.Builder.class);
+              akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol.class,
+              akka.remote.RemoteProtocol.SerializedTypedActorRefProtocol.Builder.class);
           internal_static_MessageProtocol_descriptor =
             getDescriptor().getMessageTypes().get(6);
           internal_static_MessageProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_MessageProtocol_descriptor,
               new java.lang.String[] { "Message", "MessageManifest", },
-              akka.cluster.RemoteProtocol.MessageProtocol.class,
-              akka.cluster.RemoteProtocol.MessageProtocol.Builder.class);
+              akka.remote.RemoteProtocol.MessageProtocol.class,
+              akka.remote.RemoteProtocol.MessageProtocol.Builder.class);
           internal_static_ActorInfoProtocol_descriptor =
             getDescriptor().getMessageTypes().get(7);
           internal_static_ActorInfoProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_ActorInfoProtocol_descriptor,
               new java.lang.String[] { "Uuid", "Timeout", "Address", },
-              akka.cluster.RemoteProtocol.ActorInfoProtocol.class,
-              akka.cluster.RemoteProtocol.ActorInfoProtocol.Builder.class);
+              akka.remote.RemoteProtocol.ActorInfoProtocol.class,
+              akka.remote.RemoteProtocol.ActorInfoProtocol.Builder.class);
           internal_static_UuidProtocol_descriptor =
             getDescriptor().getMessageTypes().get(8);
           internal_static_UuidProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_UuidProtocol_descriptor,
               new java.lang.String[] { "High", "Low", },
-              akka.cluster.RemoteProtocol.UuidProtocol.class,
-              akka.cluster.RemoteProtocol.UuidProtocol.Builder.class);
+              akka.remote.RemoteProtocol.UuidProtocol.class,
+              akka.remote.RemoteProtocol.UuidProtocol.Builder.class);
           internal_static_MetadataEntryProtocol_descriptor =
             getDescriptor().getMessageTypes().get(9);
           internal_static_MetadataEntryProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_MetadataEntryProtocol_descriptor,
               new java.lang.String[] { "Key", "Value", },
-              akka.cluster.RemoteProtocol.MetadataEntryProtocol.class,
-              akka.cluster.RemoteProtocol.MetadataEntryProtocol.Builder.class);
+              akka.remote.RemoteProtocol.MetadataEntryProtocol.class,
+              akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder.class);
           internal_static_LifeCycleProtocol_descriptor =
             getDescriptor().getMessageTypes().get(10);
           internal_static_LifeCycleProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_LifeCycleProtocol_descriptor,
               new java.lang.String[] { "LifeCycle", },
-              akka.cluster.RemoteProtocol.LifeCycleProtocol.class,
-              akka.cluster.RemoteProtocol.LifeCycleProtocol.Builder.class);
+              akka.remote.RemoteProtocol.LifeCycleProtocol.class,
+              akka.remote.RemoteProtocol.LifeCycleProtocol.Builder.class);
           internal_static_AddressProtocol_descriptor =
             getDescriptor().getMessageTypes().get(11);
           internal_static_AddressProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_AddressProtocol_descriptor,
               new java.lang.String[] { "Hostname", "Port", },
-              akka.cluster.RemoteProtocol.AddressProtocol.class,
-              akka.cluster.RemoteProtocol.AddressProtocol.Builder.class);
+              akka.remote.RemoteProtocol.AddressProtocol.class,
+              akka.remote.RemoteProtocol.AddressProtocol.Builder.class);
           internal_static_ExceptionProtocol_descriptor =
             getDescriptor().getMessageTypes().get(12);
           internal_static_ExceptionProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_ExceptionProtocol_descriptor,
               new java.lang.String[] { "Classname", "Message", },
-              akka.cluster.RemoteProtocol.ExceptionProtocol.class,
-              akka.cluster.RemoteProtocol.ExceptionProtocol.Builder.class);
+              akka.remote.RemoteProtocol.ExceptionProtocol.class,
+              akka.remote.RemoteProtocol.ExceptionProtocol.Builder.class);
           internal_static_RemoteDaemonMessageProtocol_descriptor =
             getDescriptor().getMessageTypes().get(13);
           internal_static_RemoteDaemonMessageProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_RemoteDaemonMessageProtocol_descriptor,
               new java.lang.String[] { "MessageType", "ActorUuid", "ActorAddress", "Payload", "ReplicateActorFromUuid", },
-              akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol.class,
-              akka.cluster.RemoteProtocol.RemoteDaemonMessageProtocol.Builder.class);
+              akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol.class,
+              akka.remote.RemoteProtocol.RemoteDaemonMessageProtocol.Builder.class);
           internal_static_DurableMailboxMessageProtocol_descriptor =
             getDescriptor().getMessageTypes().get(14);
           internal_static_DurableMailboxMessageProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_DurableMailboxMessageProtocol_descriptor,
               new java.lang.String[] { "OwnerActorAddress", "SenderActorAddress", "FutureUuid", "Message", },
-              akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol.class,
-              akka.cluster.RemoteProtocol.DurableMailboxMessageProtocol.Builder.class);
+              akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.class,
+              akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.Builder.class);
           return null;
         }
       };
diff --git a/akka-remote/src/main/protocol/RemoteProtocol.proto b/akka-remote/src/main/protocol/RemoteProtocol.proto
index 7951c7d1c9..1867539676 100644
--- a/akka-remote/src/main/protocol/RemoteProtocol.proto
+++ b/akka-remote/src/main/protocol/RemoteProtocol.proto
@@ -2,12 +2,12 @@
  * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
  */
 
-option java_package = "akka.cluster";
+option java_package = "akka.remote";
 option optimize_for = SPEED;
 
 /******************************************
   Compile with:
-  cd ./akka-cluster/src/main/protocol
+  cd ./akka-remote/src/main/protocol
   protoc RemoteProtocol.proto --java_out ../java
 *******************************************/
 
diff --git a/akka-remote/src/main/scala/akka/cluster/RemoteConfig.scala b/akka-remote/src/main/scala/akka/cluster/RemoteConfig.scala
deleted file mode 100644
index acabf4604a..0000000000
--- a/akka-remote/src/main/scala/akka/cluster/RemoteConfig.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-/**
- * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
- */
-
-package akka.cluster
-
-import akka.util.Duration
-import akka.config.Config._
-import akka.config.ConfigurationException
-
-object RemoteClientSettings {
-  val SECURE_COOKIE: Option[String] = config.getString("akka.cluster.secure-cookie", "") match {
-    case ""     ⇒ None
-    case cookie ⇒ Some(cookie)
-  }
-
-  val RECONNECTION_TIME_WINDOW = Duration(config.getInt("akka.cluster.client.reconnection-time-window", 600), TIME_UNIT).toMillis
-  val READ_TIMEOUT = Duration(config.getInt("akka.cluster.client.read-timeout", 3600), TIME_UNIT)
-  val RECONNECT_DELAY = Duration(config.getInt("akka.cluster.client.reconnect-delay", 5), TIME_UNIT)
-  val REAP_FUTURES_DELAY = Duration(config.getInt("akka.cluster.client.reap-futures-delay", 5), TIME_UNIT)
-  val MESSAGE_FRAME_SIZE = config.getInt("akka.cluster.client.message-frame-size", 1048576)
-}
-
-object RemoteServerSettings {
-  val isRemotingEnabled = config.getList("akka.enabled-modules").exists(_ == "cluster")
-  val MESSAGE_FRAME_SIZE = config.getInt("akka.cluster.server.message-frame-size", 1048576)
-  val SECURE_COOKIE = config.getString("akka.cluster.secure-cookie")
-  val REQUIRE_COOKIE = {
-    val requireCookie = config.getBool("akka.cluster.server.require-cookie", false)
-    if (isRemotingEnabled && requireCookie && SECURE_COOKIE.isEmpty) throw new ConfigurationException(
-      "Configuration option 'akka.cluster.server.require-cookie' is turned on but no secure cookie is defined in 'akka.cluster.secure-cookie'.")
-    requireCookie
-  }
-
-  val UNTRUSTED_MODE = config.getBool("akka.cluster.server.untrusted-mode", false)
-  val PORT = config.getInt("akka.cluster.server.port", 2552)
-  val CONNECTION_TIMEOUT = Duration(config.getInt("akka.cluster.server.connection-timeout", 100), TIME_UNIT)
-
-  val BACKLOG = config.getInt("akka.cluster.server.backlog", 4096)
-
-  val EXECUTION_POOL_KEEPALIVE = Duration(config.getInt("akka.cluster.server.execution-pool-keepalive", 60), TIME_UNIT)
-
-  val EXECUTION_POOL_SIZE = {
-    val sz = config.getInt("akka.cluster.server.execution-pool-size", 16)
-    if (sz < 1) throw new IllegalArgumentException("akka.cluster.server.execution-pool-size is less than 1")
-    sz
-  }
-
-  val MAX_CHANNEL_MEMORY_SIZE = {
-    val sz = config.getInt("akka.cluster.server.max-channel-memory-size", 0)
-    if (sz < 0) throw new IllegalArgumentException("akka.cluster.server.max-channel-memory-size is less than 0")
-    sz
-  }
-
-  val MAX_TOTAL_MEMORY_SIZE = {
-    val sz = config.getInt("akka.cluster.server.max-total-memory-size", 0)
-    if (sz < 0) throw new IllegalArgumentException("akka.cluster.server.max-total-memory-size is less than 0")
-    sz
-  }
-}
diff --git a/akka-remote/src/main/scala/akka/cluster/BootableRemoteActorService.scala b/akka-remote/src/main/scala/akka/remote/BootableRemoteActorService.scala
similarity index 98%
rename from akka-remote/src/main/scala/akka/cluster/BootableRemoteActorService.scala
rename to akka-remote/src/main/scala/akka/remote/BootableRemoteActorService.scala
index 8d72a5e40c..f214e12f52 100644
--- a/akka-remote/src/main/scala/akka/cluster/BootableRemoteActorService.scala
+++ b/akka-remote/src/main/scala/akka/remote/BootableRemoteActorService.scala
@@ -2,7 +2,7 @@
  * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.cluster
+package akka.remote
 
 import akka.actor.{ Actor, BootableActorLoaderService }
 import akka.util.{ ReflectiveAccess, Bootable }
diff --git a/akka-remote/src/main/scala/akka/cluster/MessageSerializer.scala b/akka-remote/src/main/scala/akka/remote/MessageSerializer.scala
similarity index 94%
rename from akka-remote/src/main/scala/akka/cluster/MessageSerializer.scala
rename to akka-remote/src/main/scala/akka/remote/MessageSerializer.scala
index a8a2f15678..2f8750264e 100644
--- a/akka-remote/src/main/scala/akka/cluster/MessageSerializer.scala
+++ b/akka-remote/src/main/scala/akka/remote/MessageSerializer.scala
@@ -2,9 +2,9 @@
  * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.cluster
+package akka.remote
 
-import akka.cluster.RemoteProtocol._
+import akka.remote.RemoteProtocol._
 import akka.serialization.Serialization
 
 import com.google.protobuf.ByteString
diff --git a/akka-remote/src/main/scala/akka/cluster/NetworkEventStream.scala b/akka-remote/src/main/scala/akka/remote/NetworkEventStream.scala
similarity index 89%
rename from akka-remote/src/main/scala/akka/cluster/NetworkEventStream.scala
rename to akka-remote/src/main/scala/akka/remote/NetworkEventStream.scala
index 8db8c6d392..18e09112bd 100644
--- a/akka-remote/src/main/scala/akka/cluster/NetworkEventStream.scala
+++ b/akka-remote/src/main/scala/akka/remote/NetworkEventStream.scala
@@ -2,7 +2,7 @@
  * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.cluster
+package akka.remote
 
 import akka.dispatch.PinnedDispatcher
 
@@ -15,6 +15,8 @@ import akka.actor.Actor._
 /**
  * Stream of all kinds of network events, remote failure and connection events, cluster failure and connection events etc.
  * Also provides API for channel listener management.
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 object NetworkEventStream {
 
@@ -58,7 +60,8 @@ object NetworkEventStream {
     }
   }
 
-  private[akka] val channel = new LocalActorRef(Props[Channel].copy(dispatcher = new PinnedDispatcher()), newUuid.toString, systemService = true)
+  private[akka] val channel = new LocalActorRef(
+    Props[Channel].copy(dispatcher = new PinnedDispatcher()), newUuid.toString, systemService = true)
 
   /**
    * Registers a network event stream listener (asyncronously).
diff --git a/akka-remote/src/main/scala/akka/remote/RemoteActorRefProvider.scala b/akka-remote/src/main/scala/akka/remote/RemoteActorRefProvider.scala
new file mode 100644
index 0000000000..19f3e6fe0b
--- /dev/null
+++ b/akka-remote/src/main/scala/akka/remote/RemoteActorRefProvider.scala
@@ -0,0 +1,120 @@
+/**
+ * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package akka.remote
+
+import akka.actor._
+import DeploymentConfig._
+import Actor._
+import Status._
+import akka.event.EventHandler
+import akka.util.duration._
+import akka.config.ConfigurationException
+import akka.AkkaException
+import RemoteProtocol._
+import RemoteDaemonMessageType._
+import akka.serialization.{ Serialization, Serializer, ActorSerialization, Compression }
+import Compression.LZF
+
+import java.net.InetSocketAddress
+
+import com.google.protobuf.ByteString
+
+/**
+ * Remote ActorRefProvider. Starts up actor on remote node and creates a RemoteActorRef representing it.
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+class RemoteActorRefProvider extends ActorRefProvider {
+
+  private val failureDetector = new BannagePeriodFailureDetector(timeToBan = 60 seconds) // FIXME make timeToBan configurable
+
+  def actorOf(props: Props, address: String): Option[ActorRef] = {
+    Address.validate(address)
+
+    val actorRef = Actor.remote.actors.get(address)
+    if (actorRef ne null) Some(actorRef)
+    else {
+      Deployer.lookupDeploymentFor(address) match {
+        case Some(Deploy(_, _, router, _, RemoteScope(host, port))) ⇒
+          // FIXME create RoutedActorRef if 'router' is specified
+
+          val serverAddress = Remote.address
+          if (serverAddress.getHostName == host && serverAddress.getPort == port) {
+            // home node for this remote actor
+            Some(new LocalActorRef(props, address, false)) // create a local actor
+          } else {
+            // not home node, need to provision it
+            val remoteAddress = new InetSocketAddress(host, port)
+            useActorOnNode(remoteAddress, address, props.creator)
+            Some(RemoteActorRef(remoteAddress, address, Actor.TIMEOUT, None)) // create a remote actor
+          }
+
+        case deploy ⇒ None // non-remote actor
+      }
+    }
+  }
+
+  def findActorRef(address: String): Option[ActorRef] = throw new UnsupportedOperationException
+
+  /**
+   * Using (checking out) actor on a specific node.
+   */
+  def useActorOnNode(remoteAddress: InetSocketAddress, actorAddress: String, actorFactory: () ⇒ Actor) {
+    EventHandler.debug(this, "Instantiating Actor [%s] on node [%s]".format(actorAddress, remoteAddress))
+
+    val actorFactoryBytes =
+      Serialization.serialize(actorFactory) match {
+        case Left(error) ⇒ throw error
+        case Right(bytes) ⇒
+          if (Remote.shouldCompressData) LZF.compress(bytes)
+          else bytes
+      }
+
+    val command = RemoteDaemonMessageProtocol.newBuilder
+      .setMessageType(USE)
+      .setActorAddress(actorAddress)
+      .setPayload(ByteString.copyFrom(actorFactoryBytes))
+      .build()
+
+    val connectionFactory =
+      () ⇒ Remote.server.actorFor(
+        Remote.remoteDaemonServiceName, remoteAddress.getHostName, remoteAddress.getPort)
+
+    // try to get the connection for the remote address, if not already there then create it
+    val connection = failureDetector.putIfAbsent(remoteAddress, connectionFactory)
+
+    sendCommandToRemoteNode(connection, command, withACK = true) // ensure we get an ACK on the USE command
+  }
+
+  private def sendCommandToRemoteNode(
+    connection: ActorRef,
+    command: RemoteDaemonMessageProtocol,
+    withACK: Boolean) {
+
+    if (withACK) {
+      try {
+        (connection ? (command, Remote.remoteDaemonAckTimeout)).as[Status] match {
+          case Some(Success(receiver)) ⇒
+            EventHandler.debug(this, "Remote command sent to [%s] successfully received".format(receiver))
+
+          case Some(Failure(cause)) ⇒
+            EventHandler.error(cause, this, cause.toString)
+            throw cause
+
+          case None ⇒
+            val error = new RemoteException("Remote command to [%s] timed out".format(connection.address))
+            EventHandler.error(error, this, error.toString)
+            throw error
+        }
+      } catch {
+        case e: Exception ⇒
+          EventHandler.error(e, this, "Could not send remote command to [%s] due to: %s".format(connection.address, e.toString))
+          throw e
+      }
+    } else {
+      connection ! command
+    }
+  }
+}
diff --git a/akka-remote/src/main/scala/akka/remote/RemoteConfig.scala b/akka-remote/src/main/scala/akka/remote/RemoteConfig.scala
new file mode 100644
index 0000000000..993af29d99
--- /dev/null
+++ b/akka-remote/src/main/scala/akka/remote/RemoteConfig.scala
@@ -0,0 +1,60 @@
+/**
+ * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package akka.remote
+
+import akka.util.Duration
+import akka.config.Config._
+import akka.config.ConfigurationException
+
+object RemoteClientSettings {
+  val SECURE_COOKIE: Option[String] = config.getString("akka.remote.secure-cookie", "") match {
+    case ""     ⇒ None
+    case cookie ⇒ Some(cookie)
+  }
+
+  val RECONNECTION_TIME_WINDOW = Duration(config.getInt("akka.remote.client.reconnection-time-window", 600), TIME_UNIT).toMillis
+  val READ_TIMEOUT = Duration(config.getInt("akka.remote.client.read-timeout", 3600), TIME_UNIT)
+  val RECONNECT_DELAY = Duration(config.getInt("akka.remote.client.reconnect-delay", 5), TIME_UNIT)
+  val REAP_FUTURES_DELAY = Duration(config.getInt("akka.remote.client.reap-futures-delay", 5), TIME_UNIT)
+  val MESSAGE_FRAME_SIZE = config.getInt("akka.remote.client.message-frame-size", 1048576)
+}
+
+object RemoteServerSettings {
+  val isRemotingEnabled = config.getList("akka.enabled-modules").exists(_ == "cluster")
+  val MESSAGE_FRAME_SIZE = config.getInt("akka.remote.server.message-frame-size", 1048576)
+  val SECURE_COOKIE = config.getString("akka.remote.secure-cookie")
+  val REQUIRE_COOKIE = {
+    val requireCookie = config.getBool("akka.remote.server.require-cookie", false)
+    if (isRemotingEnabled && requireCookie && SECURE_COOKIE.isEmpty) throw new ConfigurationException(
+      "Configuration option 'akka.remote.server.require-cookie' is turned on but no secure cookie is defined in 'akka.remote.secure-cookie'.")
+    requireCookie
+  }
+
+  val UNTRUSTED_MODE = config.getBool("akka.remote.server.untrusted-mode", false)
+  val PORT = config.getInt("akka.remote.server.port", 2552)
+  val CONNECTION_TIMEOUT = Duration(config.getInt("akka.remote.server.connection-timeout", 100), TIME_UNIT)
+
+  val BACKLOG = config.getInt("akka.remote.server.backlog", 4096)
+
+  val EXECUTION_POOL_KEEPALIVE = Duration(config.getInt("akka.remote.server.execution-pool-keepalive", 60), TIME_UNIT)
+
+  val EXECUTION_POOL_SIZE = {
+    val sz = config.getInt("akka.remote.server.execution-pool-size", 16)
+    if (sz < 1) throw new IllegalArgumentException("akka.remote.server.execution-pool-size is less than 1")
+    sz
+  }
+
+  val MAX_CHANNEL_MEMORY_SIZE = {
+    val sz = config.getInt("akka.remote.server.max-channel-memory-size", 0)
+    if (sz < 0) throw new IllegalArgumentException("akka.remote.server.max-channel-memory-size is less than 0")
+    sz
+  }
+
+  val MAX_TOTAL_MEMORY_SIZE = {
+    val sz = config.getInt("akka.remote.server.max-total-memory-size", 0)
+    if (sz < 0) throw new IllegalArgumentException("akka.remote.server.max-total-memory-size is less than 0")
+    sz
+  }
+}
diff --git a/akka-remote/src/main/scala/akka/remote/RemoteDaemon.scala b/akka-remote/src/main/scala/akka/remote/RemoteDaemon.scala
new file mode 100644
index 0000000000..cb083d6597
--- /dev/null
+++ b/akka-remote/src/main/scala/akka/remote/RemoteDaemon.scala
@@ -0,0 +1,218 @@
+/**
+ *  Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package akka.remote
+
+import akka.actor._
+import Actor._
+import akka.event.EventHandler
+import akka.dispatch.{ Dispatchers, Future, PinnedDispatcher }
+import akka.config.{ Config, Supervision }
+import Supervision._
+import Status._
+import Config._
+import akka.util._
+import duration._
+import Helpers._
+import DeploymentConfig._
+import akka.serialization.{ Serialization, Serializer, ActorSerialization, Compression }
+import ActorSerialization._
+import Compression.LZF
+import RemoteProtocol._
+import RemoteDaemonMessageType._
+
+import java.net.InetSocketAddress
+
+import com.eaio.uuid.UUID
+
+/**
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+object Remote extends RemoteService {
+  val shouldCompressData = config.getBool("akka.remote.use-compression", false)
+  val remoteDaemonAckTimeout = Duration(config.getInt("akka.remote.remote-daemon-ack-timeout", 30), TIME_UNIT).toMillis.toInt
+
+  val hostname = Config.hostname
+  val port = Config.remoteServerPort
+
+  val remoteDaemonServiceName = "akka-remote-daemon".intern
+
+  // FIXME configure computeGridDispatcher to what?
+  val computeGridDispatcher = Dispatchers.newDispatcher("akka:compute-grid").build
+
+  private[remote] lazy val remoteDaemon = new LocalActorRef(
+    Props(new RemoteDaemon).copy(dispatcher = new PinnedDispatcher()),
+    Remote.remoteDaemonServiceName,
+    systemService = true)
+
+  private[remote] lazy val remoteDaemonSupervisor = Supervisor(
+    SupervisorConfig(
+      OneForOnePermanentStrategy(List(classOf[Exception]), Int.MaxValue, Int.MaxValue), // is infinite restart what we want?
+      Supervise(
+        remoteDaemon,
+        Permanent)
+        :: Nil))
+
+  private[remote] lazy val remoteClientLifeCycleHandler = actorOf(Props(new Actor {
+    def receive = {
+      case RemoteClientError(cause, client, address) ⇒ client.shutdownClientModule()
+      case RemoteClientDisconnected(client, address) ⇒ client.shutdownClientModule()
+      case _                                         ⇒ //ignore other
+    }
+  }), "akka.cluster.RemoteClientLifeCycleListener")
+
+  lazy val server: RemoteSupport = {
+    val remote = new akka.remote.netty.NettyRemoteSupport
+    remote.start(hostname, port)
+    remote.register(Remote.remoteDaemonServiceName, remoteDaemon)
+    remote.addListener(NetworkEventStream.channel)
+    remote.addListener(remoteClientLifeCycleHandler)
+    Actor.provider.register(ActorRefProvider.RemoteProvider, new RemoteActorRefProvider)
+    remote
+  }
+
+  lazy val address = server.address
+
+  def start() {
+    val triggerLazyServerVal = address.toString
+    EventHandler.info(this, "Starting remote server on [%s]".format(triggerLazyServerVal))
+  }
+
+  def uuidProtocolToUuid(uuid: UuidProtocol): UUID = new UUID(uuid.getHigh, uuid.getLow)
+
+  def uuidToUuidProtocol(uuid: UUID): UuidProtocol =
+    UuidProtocol.newBuilder
+      .setHigh(uuid.getTime)
+      .setLow(uuid.getClockSeqAndNode)
+      .build
+}
+
+/**
+ * Internal "daemon" actor for cluster internal communication.
+ *
+ * It acts as the brain of the cluster that responds to cluster events (messages) and undertakes action.
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+class RemoteDaemon extends Actor {
+
+  import Remote._
+
+  override def preRestart(reason: Throwable, msg: Option[Any]) {
+    EventHandler.debug(this, "RemoteDaemon failed due to [%s] restarting...".format(reason))
+  }
+
+  def receive: Receive = {
+    case message: RemoteDaemonMessageProtocol ⇒
+      EventHandler.debug(this,
+        "Received command [\n%s] to RemoteDaemon on [%s]".format(message, address))
+
+      message.getMessageType match {
+        case USE                    ⇒ handleUse(message)
+        case RELEASE                ⇒ handleRelease(message)
+        // case STOP                   ⇒ cluster.shutdown()
+        // case DISCONNECT             ⇒ cluster.disconnect()
+        // case RECONNECT              ⇒ cluster.reconnect()
+        // case RESIGN                 ⇒ cluster.resign()
+        // case FAIL_OVER_CONNECTIONS  ⇒ handleFailover(message)
+        case FUNCTION_FUN0_UNIT     ⇒ handle_fun0_unit(message)
+        case FUNCTION_FUN0_ANY      ⇒ handle_fun0_any(message)
+        case FUNCTION_FUN1_ARG_UNIT ⇒ handle_fun1_arg_unit(message)
+        case FUNCTION_FUN1_ARG_ANY  ⇒ handle_fun1_arg_any(message)
+        //TODO: should we not deal with unrecognized message types?
+      }
+
+    case unknown ⇒ EventHandler.warning(this, "Unknown message [%s]".format(unknown))
+  }
+
+  def handleUse(message: RemoteProtocol.RemoteDaemonMessageProtocol) {
+    try {
+      if (message.hasActorAddress) {
+
+        val actorFactoryBytes =
+          if (shouldCompressData) LZF.uncompress(message.getPayload.toByteArray)
+          else message.getPayload.toByteArray
+
+        val actorFactory =
+          Serialization.deserialize(actorFactoryBytes, classOf[() ⇒ Actor], None) match {
+            case Left(error)     ⇒ throw error
+            case Right(instance) ⇒ instance.asInstanceOf[() ⇒ Actor]
+          }
+
+        val actorAddress = message.getActorAddress
+        val newActorRef = actorOf(Props(creator = actorFactory), actorAddress)
+
+        Remote.server.register(actorAddress, newActorRef)
+
+      } else {
+        EventHandler.error(this, "Actor 'address' is not defined, ignoring remote daemon command [%s]".format(message))
+      }
+
+      reply(Success(address.toString))
+    } catch {
+      case error: Throwable ⇒
+        reply(Failure(error))
+        throw error
+    }
+  }
+
+  def handleRelease(message: RemoteProtocol.RemoteDaemonMessageProtocol) {
+    // FIXME implement handleRelease without Cluster
+
+    // if (message.hasActorUuid) {
+    //   cluster.actorAddressForUuid(uuidProtocolToUuid(message.getActorUuid)) foreach { address ⇒
+    //     cluster.release(address)
+    //   }
+    // } else if (message.hasActorAddress) {
+    //   cluster release message.getActorAddress
+    // } else {
+    //   EventHandler.warning(this,
+    //     "None of 'uuid' or 'actorAddress'' is specified, ignoring remote cluster daemon command [%s]".format(message))
+    // }
+  }
+
+  def handle_fun0_unit(message: RemoteProtocol.RemoteDaemonMessageProtocol) {
+    new LocalActorRef(
+      Props(
+        self ⇒ {
+          case f: Function0[_] ⇒ try { f() } finally { self.stop() }
+        }).copy(dispatcher = computeGridDispatcher), newUuid.toString, systemService = true) ! payloadFor(message, classOf[Function0[Unit]])
+  }
+
+  def handle_fun0_any(message: RemoteProtocol.RemoteDaemonMessageProtocol) {
+    new LocalActorRef(
+      Props(
+        self ⇒ {
+          case f: Function0[_] ⇒ try { reply(f()) } finally { self.stop() }
+        }).copy(dispatcher = computeGridDispatcher), newUuid.toString, systemService = true) forward payloadFor(message, classOf[Function0[Any]])
+  }
+
+  def handle_fun1_arg_unit(message: RemoteProtocol.RemoteDaemonMessageProtocol) {
+    new LocalActorRef(
+      Props(
+        self ⇒ {
+          case (fun: Function[_, _], param: Any) ⇒ try { fun.asInstanceOf[Any ⇒ Unit].apply(param) } finally { self.stop() }
+        }).copy(dispatcher = computeGridDispatcher), newUuid.toString, systemService = true) ! payloadFor(message, classOf[Tuple2[Function1[Any, Unit], Any]])
+  }
+
+  def handle_fun1_arg_any(message: RemoteProtocol.RemoteDaemonMessageProtocol) {
+    new LocalActorRef(
+      Props(
+        self ⇒ {
+          case (fun: Function[_, _], param: Any) ⇒ try { reply(fun.asInstanceOf[Any ⇒ Any](param)) } finally { self.stop() }
+        }).copy(dispatcher = computeGridDispatcher), newUuid.toString, systemService = true) forward payloadFor(message, classOf[Tuple2[Function1[Any, Any], Any]])
+  }
+
+  def handleFailover(message: RemoteProtocol.RemoteDaemonMessageProtocol) {
+    // val (from, to) = payloadFor(message, classOf[(InetSocketremoteDaemonServiceName, InetSocketremoteDaemonServiceName)])
+    // cluster.failOverClusterActorRefConnections(from, to)
+  }
+
+  private def payloadFor[T](message: RemoteDaemonMessageProtocol, clazz: Class[T]): T = {
+    Serialization.deserialize(message.getPayload.toByteArray, clazz, None) match {
+      case Left(error)     ⇒ throw error
+      case Right(instance) ⇒ instance.asInstanceOf[T]
+    }
+  }
+}
diff --git a/akka-remote/src/main/scala/akka/cluster/RemoteFailureDetector.scala b/akka-remote/src/main/scala/akka/remote/RemoteFailureDetector.scala
similarity index 81%
rename from akka-remote/src/main/scala/akka/cluster/RemoteFailureDetector.scala
rename to akka-remote/src/main/scala/akka/remote/RemoteFailureDetector.scala
index 04aec93ae0..02601be601 100644
--- a/akka-remote/src/main/scala/akka/cluster/RemoteFailureDetector.scala
+++ b/akka-remote/src/main/scala/akka/remote/RemoteFailureDetector.scala
@@ -2,12 +2,12 @@
  * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.cluster
+package akka.remote
 
 import akka.actor._
 import Actor._
-import akka.cluster._
 import akka.routing._
+import akka.dispatch.PinnedDispatcher
 import akka.event.EventHandler
 import akka.util.{ ListenerManagement, Duration }
 
@@ -18,54 +18,11 @@ import scala.annotation.tailrec
 import java.net.InetSocketAddress
 import java.util.concurrent.atomic.AtomicReference
 import System.{ currentTimeMillis ⇒ newTimestamp }
-import akka.dispatch.PinnedDispatcher
-
-/**
- * Holds error event channel Actor instance and provides API for channel listener management.
- */
-object RemoteFailureDetector {
-
-  private sealed trait RemoteFailureDetectorChannelEvent
-
-  private case class Register(listener: RemoteFailureListener, connectionAddress: InetSocketAddress)
-    extends RemoteFailureDetectorChannelEvent
-
-  private case class Unregister(listener: RemoteFailureListener, connectionAddress: InetSocketAddress)
-    extends RemoteFailureDetectorChannelEvent
-
-  private[akka] val channel = new LocalActorRef(Props[Channel].copy(dispatcher = new PinnedDispatcher()), newUuid.toString, systemService = true)
-
-  def register(listener: RemoteFailureListener, connectionAddress: InetSocketAddress) =
-    channel ! Register(listener, connectionAddress)
-
-  def unregister(listener: RemoteFailureListener, connectionAddress: InetSocketAddress) =
-    channel ! Unregister(listener, connectionAddress)
-
-  private class Channel extends Actor {
-
-    val listeners = new mutable.HashMap[InetSocketAddress, mutable.Set[RemoteFailureListener]]() {
-      override def default(k: InetSocketAddress) = mutable.Set.empty[RemoteFailureListener]
-    }
-
-    def receive = {
-      case event: RemoteClientLifeCycleEvent ⇒
-        listeners(event.remoteAddress) foreach (_ notify event)
-
-      case event: RemoteServerLifeCycleEvent ⇒ // FIXME handle RemoteServerLifeCycleEvent
-
-      case Register(listener, connectionAddress) ⇒
-        listeners(connectionAddress) += listener
-
-      case Unregister(listener, connectionAddress) ⇒
-        listeners(connectionAddress) -= listener
-
-      case _ ⇒ //ignore other
-    }
-  }
-}
 
 /**
  * Base class for remote failure detection management.
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 abstract class RemoteFailureDetectorBase(initialConnections: Map[InetSocketAddress, ActorRef])
   extends FailureDetector
@@ -83,6 +40,9 @@ abstract class RemoteFailureDetectorBase(initialConnections: Map[InetSocketAddre
 
   protected val state: AtomicReference[State] = new AtomicReference[State](newState())
 
+  // register all initial connections - e.g listen to events from them
+  initialConnections.keys foreach (NetworkEventStream.register(this, _))
+
   /**
    * State factory. To be defined by subclass that wants to add extra info in the 'meta: T' field.
    */
@@ -123,7 +83,7 @@ abstract class RemoteFailureDetectorBase(initialConnections: Map[InetSocketAddre
 
   @tailrec
   final def failOver(from: InetSocketAddress, to: InetSocketAddress) {
-    EventHandler.debug(this, "ClusterActorRef failover from [%s] to [%s]".format(from, to))
+    EventHandler.debug(this, "RemoteFailureDetector failover from [%s] to [%s]".format(from, to))
 
     val oldState = state.get
     var changed = false
@@ -132,7 +92,7 @@ abstract class RemoteFailureDetectorBase(initialConnections: Map[InetSocketAddre
       case (`from`, actorRef) ⇒
         changed = true
         //actorRef.stop()
-        (to, createRemoteActorRef(actorRef.address, to))
+        (to, newConnection(actorRef.address, to))
       case other ⇒ other
     }
 
@@ -141,24 +101,27 @@ abstract class RemoteFailureDetectorBase(initialConnections: Map[InetSocketAddre
       val newState = oldState copy (version = oldState.version + 1, connections = newMap)
 
       //if we are not able to update, the state, we are going to try again.
-      if (!state.compareAndSet(oldState, newState)) failOver(from, to)
+      if (!state.compareAndSet(oldState, newState)) {
+        failOver(from, to) // recur
+      }
     }
   }
 
   @tailrec
   final def remove(faultyConnection: ActorRef) {
-    EventHandler.debug(this, "ClusterActorRef remove [%s]".format(faultyConnection.uuid))
 
     val oldState = state.get()
     var changed = false
 
-    //remote the faultyConnection from the clustered-connections.
+    var faultyAddress: InetSocketAddress = null
     var newConnections = Map.empty[InetSocketAddress, ActorRef]
+
     oldState.connections.keys foreach { address ⇒
       val actorRef: ActorRef = oldState.connections.get(address).get
       if (actorRef ne faultyConnection) {
         newConnections = newConnections + ((address, actorRef))
       } else {
+        faultyAddress = address
         changed = true
       }
     }
@@ -168,11 +131,45 @@ abstract class RemoteFailureDetectorBase(initialConnections: Map[InetSocketAddre
       val newState = oldState copy (version = oldState.version + 1, connections = newConnections)
 
       //if we are not able to update the state, we just try again.
-      if (!state.compareAndSet(oldState, newState)) remove(faultyConnection)
+      if (!state.compareAndSet(oldState, newState)) {
+        remove(faultyConnection) // recur
+      } else {
+        EventHandler.debug(this, "Removing connection [%s]".format(faultyAddress))
+        NetworkEventStream.unregister(this, faultyAddress) // unregister the connections - e.g stop listen to events from it
+      }
     }
   }
 
-  private[cluster] def createRemoteActorRef(actorAddress: String, inetSocketAddress: InetSocketAddress) = {
+  @tailrec
+  final def putIfAbsent(address: InetSocketAddress, newConnectionFactory: () ⇒ ActorRef): ActorRef = {
+
+    val oldState = state.get()
+    val oldConnections = oldState.connections
+
+    oldConnections.get(address) match {
+      case Some(connection) ⇒ connection // we already had the connection, return it
+      case None ⇒ // we need to create it
+        val newConnection = newConnectionFactory()
+        val newConnections = oldConnections + (address -> newConnection)
+
+        //one or more occurrances of the actorRef were removed, so we need to update the state.
+        val newState = oldState copy (version = oldState.version + 1, connections = newConnections)
+
+        //if we are not able to update the state, we just try again.
+        if (!state.compareAndSet(oldState, newState)) {
+          // we failed, need compensating action
+          newConnection.stop() // stop the new connection actor and try again
+          putIfAbsent(address, newConnectionFactory) // recur
+        } else {
+          // we succeeded
+          EventHandler.debug(this, "Adding connection [%s]".format(address))
+          NetworkEventStream.register(this, address) // register the connection - e.g listen to events from it
+          newConnection // return new connection actor
+        }
+    }
+  }
+
+  private[remote] def newConnection(actorAddress: String, inetSocketAddress: InetSocketAddress) = {
     RemoteActorRef(inetSocketAddress, actorAddress, Actor.TIMEOUT, None)
   }
 }
@@ -181,7 +178,7 @@ abstract class RemoteFailureDetectorBase(initialConnections: Map[InetSocketAddre
  * Simple failure detector that removes the failing connection permanently on first error.
  */
 class RemoveConnectionOnFirstFailureRemoteFailureDetector(
-  initialConnections: Map[InetSocketAddress, ActorRef])
+  initialConnections: Map[InetSocketAddress, ActorRef] = Map.empty[InetSocketAddress, ActorRef])
   extends RemoteFailureDetectorBase(initialConnections) {
 
   protected def newState() = State(Long.MinValue, initialConnections)
@@ -215,9 +212,11 @@ class RemoveConnectionOnFirstFailureRemoteFailureDetector(
 /**
  * Failure detector that bans the failing connection for 'timeToBan: Duration' and will try to use the connection
  * again after the ban period have expired.
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 class BannagePeriodFailureDetector(
-  initialConnections: Map[InetSocketAddress, ActorRef],
+  initialConnections: Map[InetSocketAddress, ActorRef] = Map.empty[InetSocketAddress, ActorRef],
   timeToBan: Duration)
   extends RemoteFailureDetectorBase(initialConnections) {
 
diff --git a/akka-remote/src/main/scala/akka/cluster/netty/NettyRemoteSupport.scala b/akka-remote/src/main/scala/akka/remote/netty/NettyRemoteSupport.scala
similarity index 96%
rename from akka-remote/src/main/scala/akka/cluster/netty/NettyRemoteSupport.scala
rename to akka-remote/src/main/scala/akka/remote/netty/NettyRemoteSupport.scala
index 8d9e0967ec..d5d51ea428 100644
--- a/akka-remote/src/main/scala/akka/cluster/netty/NettyRemoteSupport.scala
+++ b/akka-remote/src/main/scala/akka/remote/netty/NettyRemoteSupport.scala
@@ -2,15 +2,14 @@
  * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.cluster.netty
+package akka.remote.netty
 
 import akka.actor.{ ActorRef, Uuid, newUuid, uuidFrom, IllegalActorStateException, RemoteActorRef, PoisonPill, RemoteActorSystemMessage, AutoReceivedMessage }
 import akka.dispatch.{ ActorPromise, DefaultPromise, Promise }
-import akka.cluster.{ MessageSerializer, RemoteClientSettings, RemoteServerSettings }
-import akka.cluster.RemoteProtocol._
 import akka.serialization.RemoteActorSerialization
 import akka.serialization.RemoteActorSerialization._
-import akka.cluster._
+import akka.remote._
+import RemoteProtocol._
 import akka.actor.Actor._
 import akka.config.Config
 import akka.config.Config._
@@ -148,8 +147,8 @@ abstract class RemoteClient private[akka] (
   val module: NettyRemoteClientModule,
   val remoteAddress: InetSocketAddress) {
 
-  val useTransactionLog = config.getBool("akka.cluster.client.buffering.retry-message-send-on-failure", false)
-  val transactionLogCapacity = config.getInt("akka.cluster.client.buffering.capacity", -1)
+  val useTransactionLog = config.getBool("akka.remote.client.buffering.retry-message-send-on-failure", false)
+  val transactionLogCapacity = config.getInt("akka.remote.client.buffering.capacity", -1)
 
   val name = this.getClass.getSimpleName + "@" +
     remoteAddress.getAddress.getHostAddress + "::" +
@@ -161,9 +160,9 @@ abstract class RemoteClient private[akka] (
     else new LinkedBlockingQueue[(Boolean, Uuid, RemoteMessageProtocol)](transactionLogCapacity)
   }
 
-  private[cluster] val runSwitch = new Switch()
+  private[remote] val runSwitch = new Switch()
 
-  private[cluster] def isRunning = runSwitch.isOn
+  private[remote] def isRunning = runSwitch.isOn
 
   protected def notifyListeners(msg: ⇒ Any): Unit
 
@@ -277,7 +276,7 @@ abstract class RemoteClient private[akka] (
     }
   }
 
-  private[cluster] def sendPendingRequests() = pendingRequests synchronized {
+  private[remote] def sendPendingRequests() = pendingRequests synchronized {
     // ensure only one thread at a time can flush the log
     val nrOfMessages = pendingRequests.size
     if (nrOfMessages > 0) EventHandler.info(this, "Resending [%s] previously failed messages after remote client reconnect" format nrOfMessages)
@@ -319,8 +318,11 @@ abstract class RemoteClient private[akka] (
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 class ActiveRemoteClient private[akka] (
-  module: NettyRemoteClientModule, remoteAddress: InetSocketAddress,
-  val loader: Option[ClassLoader] = None, notifyListenersFun: (⇒ Any) ⇒ Unit) extends RemoteClient(module, remoteAddress) {
+  module: NettyRemoteClientModule,
+  remoteAddress: InetSocketAddress,
+  val loader: Option[ClassLoader] = None,
+  notifyListenersFun: (⇒ Any) ⇒ Unit)
+  extends RemoteClient(module, remoteAddress) {
 
   import RemoteClientSettings._
 
@@ -328,9 +330,9 @@ class ActiveRemoteClient private[akka] (
   @volatile
   private var bootstrap: ClientBootstrap = _
   @volatile
-  private[cluster] var connection: ChannelFuture = _
+  private[remote] var connection: ChannelFuture = _
   @volatile
-  private[cluster] var openChannels: DefaultChannelGroup = _
+  private[remote] var openChannels: DefaultChannelGroup = _
   @volatile
   private var timer: HashedWheelTimer = _
   @volatile
@@ -509,11 +511,13 @@ class ActiveRemoteClientHandler(
         case arp: AkkaRemoteProtocol if arp.hasMessage ⇒
           val reply = arp.getMessage
           val replyUuid = uuidFrom(reply.getActorInfo.getUuid.getHigh, reply.getActorInfo.getUuid.getLow)
-          EventHandler.debug(this, "Remote client received RemoteMessageProtocol[\n%s]\nTrying to map back to future: %s".format(reply, replyUuid))
+          EventHandler.debug(this, "Remote client received RemoteMessageProtocol[\n%s]\nTrying to map back to future [%s]".format(reply, replyUuid))
 
           futures.remove(replyUuid).asInstanceOf[Promise[Any]] match {
             case null ⇒
-              client.notifyListeners(RemoteClientError(new IllegalActorStateException("Future mapped to UUID " + replyUuid + " does not exist"), client.module, client.remoteAddress))
+              client.notifyListeners(RemoteClientError(
+                new IllegalActorStateException("Future mapped to UUID " + replyUuid + " does not exist"), client.module,
+                client.remoteAddress))
 
             case future ⇒
               if (reply.hasMessage) {
@@ -1057,11 +1061,17 @@ class RemoteServerHandler(
       "Looking up a remotely available actor for address [%s] on node [%s]"
         .format(address, Config.nodename))
 
-    val actorRef = createSessionActor(actorInfo, channel)
-
-    if (actorRef eq null) throw new IllegalActorStateException("Could not find a remote actor with address [" + address + "] or uuid [" + uuid + "]")
-
-    actorRef
+    val byAddress = server.actors.get(address) // try actor-by-address
+    if (byAddress eq null) {
+      val byUuid = server.actorsByUuid.get(uuid) // try actor-by-uuid
+      if (byUuid eq null) {
+        val bySession = createSessionActor(actorInfo, channel) // try actor-by-session
+        if (bySession eq null) {
+          throw new IllegalActorStateException(
+            "Could not find a remote actor with address [" + address + "] or uuid [" + uuid + "]")
+        } else bySession
+      } else byUuid
+    } else byAddress
   }
 
   /**
diff --git a/akka-remote/src/main/scala/akka/serialization/SerializationProtocol.scala b/akka-remote/src/main/scala/akka/serialization/SerializationProtocol.scala
index 765e6b01af..70641c0e9f 100644
--- a/akka-remote/src/main/scala/akka/serialization/SerializationProtocol.scala
+++ b/akka-remote/src/main/scala/akka/serialization/SerializationProtocol.scala
@@ -10,19 +10,18 @@ import akka.actor._
 import DeploymentConfig._
 import akka.dispatch.Envelope
 import akka.util.{ ReflectiveAccess, Duration }
-import akka.cluster.{ RemoteClientSettings, MessageSerializer }
-import akka.cluster.RemoteProtocol
+import akka.event.EventHandler
+import akka.remote.{ RemoteProtocol, RemoteClientSettings, MessageSerializer }
 import RemoteProtocol._
 
 import scala.collection.immutable.Stack
 
 import java.net.InetSocketAddress
+import java.util.{ LinkedList, Collections }
 
 import com.google.protobuf.ByteString
 
 import com.eaio.uuid.UUID
-import akka.event.EventHandler
-import java.util.{ LinkedList, Collections }
 
 /**
  * Module for local actor serialization.
diff --git a/akka-remote/src/multi-jvm/scala/akka/cluster/ClusterTestNode.scala b/akka-remote/src/multi-jvm/scala/akka/remote/ClusterTestNode.scala
similarity index 99%
rename from akka-remote/src/multi-jvm/scala/akka/cluster/ClusterTestNode.scala
rename to akka-remote/src/multi-jvm/scala/akka/remote/ClusterTestNode.scala
index 89cb8b18d5..32abd54953 100644
--- a/akka-remote/src/multi-jvm/scala/akka/cluster/ClusterTestNode.scala
+++ b/akka-remote/src/multi-jvm/scala/akka/remote/ClusterTestNode.scala
@@ -2,7 +2,7 @@
  *  Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.cluster
+package akka.remote
 
 import org.scalatest.WordSpec
 import org.scalatest.matchers.MustMatchers
diff --git a/akka-remote/src/multi-jvm/scala/akka/remote/FileBasedBarrier.scala b/akka-remote/src/multi-jvm/scala/akka/remote/FileBasedBarrier.scala
new file mode 100644
index 0000000000..ac8c5211ba
--- /dev/null
+++ b/akka-remote/src/multi-jvm/scala/akka/remote/FileBasedBarrier.scala
@@ -0,0 +1,91 @@
+/**
+ *  Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package akka.remote
+
+import akka.util.duration._
+import akka.util.Duration
+import System.{ currentTimeMillis ⇒ now }
+
+import java.io.File
+
+class BarrierTimeoutException(message: String) extends RuntimeException(message)
+
+object FileBasedBarrier {
+  val HomeDir = ".multi-jvm"
+  val DefaultTimeout = 30.seconds
+  val DefaultSleep = 100.millis
+}
+
+import FileBasedBarrier._
+
+class FileBasedBarrier(
+  name: String,
+  count: Int,
+  group: String,
+  node: String,
+  timeout: Duration = FileBasedBarrier.DefaultTimeout,
+  sleep: Duration = FileBasedBarrier.DefaultSleep) {
+
+  val barrierDir = {
+    val dir = new File(new File(new File(FileBasedBarrier.HomeDir), group), name)
+    dir.mkdirs()
+    dir
+  }
+
+  val nodeFile = new File(barrierDir, node)
+
+  val readyFile = new File(barrierDir, "ready")
+
+  def await() = { enter(); leave() }
+
+  def apply(body: ⇒ Unit) {
+    enter()
+    body
+    leave()
+  }
+
+  def enter() = {
+    createNode()
+    if (nodesPresent >= count) createReady()
+    val ready = waitFor(readyFile.exists, timeout, sleep)
+    if (!ready) expire("entry")
+  }
+
+  def leave() = {
+    removeNode()
+    val empty = waitFor(nodesPresent <= 1, timeout, sleep)
+    removeReady()
+    if (!empty) expire("exit")
+  }
+
+  def nodesPresent = barrierDir.list.size
+
+  def createNode() = nodeFile.createNewFile()
+
+  def removeNode() = nodeFile.delete()
+
+  def createReady() = readyFile.createNewFile()
+
+  def removeReady() = readyFile.delete()
+
+  def waitFor(test: ⇒ Boolean, timeout: Duration, sleep: Duration): Boolean = {
+    val start = now
+    val limit = start + timeout.toMillis
+    var passed = test
+    var expired = false
+    while (!passed && !expired) {
+      if (now > limit) expired = true
+      else {
+        Thread.sleep(sleep.toMillis)
+        passed = test
+      }
+    }
+    passed
+  }
+
+  def expire(barrier: String) = {
+    throw new BarrierTimeoutException("Timeout (%s) waiting for %s barrier" format (timeout, barrier))
+  }
+}
\ No newline at end of file
diff --git a/akka-remote/src/multi-jvm/scala/akka/cluster/MasterClusterTestNode.scala b/akka-remote/src/multi-jvm/scala/akka/remote/MasterClusterTestNode.scala
similarity index 97%
rename from akka-remote/src/multi-jvm/scala/akka/cluster/MasterClusterTestNode.scala
rename to akka-remote/src/multi-jvm/scala/akka/remote/MasterClusterTestNode.scala
index 2bd1523752..eea1bbf9a8 100644
--- a/akka-remote/src/multi-jvm/scala/akka/cluster/MasterClusterTestNode.scala
+++ b/akka-remote/src/multi-jvm/scala/akka/remote/MasterClusterTestNode.scala
@@ -2,7 +2,7 @@
  *  Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.cluster
+package akka.remote
 
 import org.scalatest.WordSpec
 import org.scalatest.matchers.MustMatchers
diff --git a/akka-remote/src/multi-jvm/scala/akka/remote/MultiJvmSync.scala b/akka-remote/src/multi-jvm/scala/akka/remote/MultiJvmSync.scala
new file mode 100644
index 0000000000..eb157d4898
--- /dev/null
+++ b/akka-remote/src/multi-jvm/scala/akka/remote/MultiJvmSync.scala
@@ -0,0 +1,57 @@
+/**
+ *  Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package akka.remote
+
+import org.scalatest.WordSpec
+import org.scalatest.matchers.MustMatchers
+import org.scalatest.BeforeAndAfterAll
+
+import akka.util.Duration
+
+trait MultiJvmSync extends WordSpec with MustMatchers with BeforeAndAfterAll {
+  def nodes: Int
+
+  override def beforeAll() = {
+    onStart()
+    MultiJvmSync.start(getClass.getName, nodes)
+  }
+
+  def onStart(): Unit = {}
+
+  override def afterAll() = {
+    MultiJvmSync.end(getClass.getName, nodes)
+    onEnd()
+  }
+
+  def onEnd(): Unit = {}
+
+  def barrier(name: String, timeout: Duration = FileBasedBarrier.DefaultTimeout) = {
+    MultiJvmSync.barrier(name, nodes, getClass.getName, timeout)
+  }
+}
+
+object MultiJvmSync {
+  val TestMarker = "MultiJvm"
+  val StartBarrier = "multi-jvm-start"
+  val EndBarrier = "multi-jvm-end"
+
+  def start(className: String, count: Int) = barrier(StartBarrier, count, className)
+
+  def end(className: String, count: Int) = barrier(EndBarrier, count, className)
+
+  def testName(className: String) = {
+    val i = className.indexOf(TestMarker)
+    if (i >= 0) className.substring(0, i) else className
+  }
+
+  def nodeName(className: String) = {
+    val i = className.indexOf(TestMarker)
+    if (i >= 0) className.substring(i + TestMarker.length) else className
+  }
+
+  def barrier(name: String, count: Int, className: String, timeout: Duration = FileBasedBarrier.DefaultTimeout) = {
+    new FileBasedBarrier(name, count, testName(className), nodeName(className), timeout).await()
+  }
+}
diff --git a/akka-remote/src/multi-jvm/scala/akka/cluster/QuietReporter.scala b/akka-remote/src/multi-jvm/scala/akka/remote/QuietReporter.scala
similarity index 100%
rename from akka-remote/src/multi-jvm/scala/akka/cluster/QuietReporter.scala
rename to akka-remote/src/multi-jvm/scala/akka/remote/QuietReporter.scala
diff --git a/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmNode1.conf b/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmNode1.conf
new file mode 100644
index 0000000000..61d1ac63e6
--- /dev/null
+++ b/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmNode1.conf
@@ -0,0 +1,4 @@
+akka.enabled-modules = ["remote"]
+akka.event-handler-level = "DEBUG"
+akka.actor.deployment.service-hello.remote.hostname = "localhost"
+akka.actor.deployment.service-hello.remote.port = 9991
diff --git a/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmNode1.opts b/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmNode1.opts
new file mode 100644
index 0000000000..6562171945
--- /dev/null
+++ b/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmNode1.opts
@@ -0,0 +1 @@
+-Dakka.cluster.nodename=node1 -Dakka.remote.hostname=localhost -Dakka.remote.port=9991
diff --git a/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmNode2.conf b/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmNode2.conf
new file mode 100644
index 0000000000..61d1ac63e6
--- /dev/null
+++ b/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmNode2.conf
@@ -0,0 +1,4 @@
+akka.enabled-modules = ["remote"]
+akka.event-handler-level = "DEBUG"
+akka.actor.deployment.service-hello.remote.hostname = "localhost"
+akka.actor.deployment.service-hello.remote.port = 9991
diff --git a/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmNode2.opts b/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmNode2.opts
new file mode 100644
index 0000000000..ba38f5b2ce
--- /dev/null
+++ b/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmNode2.opts
@@ -0,0 +1 @@
+-Dakka.cluster.nodename=node2 -Dakka.remote.hostname=localhost -Dakka.remote.port=9992
diff --git a/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmSpec.scala b/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmSpec.scala
new file mode 100644
index 0000000000..213ce6e482
--- /dev/null
+++ b/akka-remote/src/multi-jvm/scala/akka/remote/new_remote_actor/NewRemoteActorMultiJvmSpec.scala
@@ -0,0 +1,61 @@
+package akka.remote.new_remote_actor
+
+import akka.remote._
+
+import akka.actor.Actor
+import akka.config.Config
+
+object NewRemoteActorMultiJvmSpec {
+  val NrOfNodes = 2
+
+  class SomeActor extends Actor with Serializable {
+    def receive = {
+      case "identify" ⇒ {
+        reply(Config.nodename)
+      }
+    }
+  }
+}
+
+class NewRemoteActorMultiJvmNode1 extends MultiJvmSync {
+
+  import NewRemoteActorMultiJvmSpec._
+
+  val nodes = NrOfNodes
+
+  "___" must {
+    "___" in {
+      barrier("setup")
+
+      Remote.start()
+
+      barrier("start")
+
+      barrier("done")
+    }
+  }
+}
+
+class NewRemoteActorMultiJvmNode2 extends MultiJvmSync {
+
+  import NewRemoteActorMultiJvmSpec._
+
+  val nodes = NrOfNodes
+
+  "A new remote actor" must {
+    "be locally instantiated on a remote node and be able to communicate through its RemoteActorRef" in {
+      barrier("setup")
+
+      Remote.start()
+
+      barrier("start")
+
+      val actor = Actor.actorOf[SomeActor]("service-hello")
+      val result = (actor ? "identify").get
+      result must equal("node1")
+
+      barrier("done")
+    }
+  }
+}
+
diff --git a/akka-remote/src/test/scala/akka/cluster/NetworkFailureSpec.scala b/akka-remote/src/test/scala/akka/remote/NetworkFailureSpec.scala
similarity index 97%
rename from akka-remote/src/test/scala/akka/cluster/NetworkFailureSpec.scala
rename to akka-remote/src/test/scala/akka/remote/NetworkFailureSpec.scala
index f5c08f908c..d81e830116 100644
--- a/akka-remote/src/test/scala/akka/cluster/NetworkFailureSpec.scala
+++ b/akka-remote/src/test/scala/akka/remote/NetworkFailureSpec.scala
@@ -2,7 +2,7 @@
  *  Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.cluster
+package akka.remote
 
 import org.scalatest.{ Spec, WordSpec, BeforeAndAfterAll, BeforeAndAfterEach }
 import org.scalatest.matchers.MustMatchers
@@ -10,7 +10,7 @@ import org.scalatest.junit.JUnitRunner
 
 import org.junit.runner.RunWith
 
-import akka.cluster.netty.NettyRemoteSupport
+import akka.remote.netty.NettyRemoteSupport
 import akka.actor.{ Actor, ActorRegistry }
 
 import java.util.concurrent.{ TimeUnit, CountDownLatch }
diff --git a/akka-spring/src/test/resources/property-config.xml b/akka-spring/src/test/resources/property-config.xml
index 43d36852ed..f199df7074 100644
--- a/akka-spring/src/test/resources/property-config.xml
+++ b/akka-spring/src/test/resources/property-config.xml
@@ -15,7 +15,7 @@ http://akka.io/akka-2.0-SNAPSHOT.xsd">
   <akka:untyped-actor id="actor-1"
                       implementation="akka.spring.foo.PingActor"
                       timeout="${akka.actor.timeout}">
-    <akka:remote host="${akka.cluster.server.hostname}" port="${akka.cluster.server.port}"/>
+    <akka:remote host="${akka.remote.server.hostname}" port="${akka.remote.server.port}"/>
   </akka:untyped-actor>
 
 
diff --git a/config/akka-reference.conf b/config/akka-reference.conf
index 2507e92ce0..02f699c393 100644
--- a/config/akka-reference.conf
+++ b/config/akka-reference.conf
@@ -70,42 +70,58 @@ akka {
                                                                         #     default is "direct";
                                                                         #     if 'replication' is used then the only available router is "direct"
 
-        failure-detector = "remove-connection-on-first-remote-failure"  # failure detection scheme to use
-                                                                        #     available: "remove-connection-on-first-local-failure"
-                                                                        #                "remove-connection-on-first-remote-failure"
-                                                                        #                "circuit-breaker"
-                                                                        #     or:        fully qualified class name of the router class
-                                                                        #     default is "remove-connection-on-first-remote-failure";
+        failure-detector {                                              # failure detection scheme to use
+          bannage-period {                                              #     available: remove-connection-on-first-local-failure {}
+            time-to-ban = 10                                            #                remove-connection-on-first-failure {}
+          }                                                             #                bannage-period { ... }
 
-        cluster {                                                       # defines the actor as a clustered actor
+        # Options:
+        #  remove-connection-on-first-failure {}                        #                threshold { ... }
+        #  custom {                                                     #                custom { ... } - fully qualified class name of the router class
+        #    class = "com.biz.app.MyCustomFailureDetector"
+        #  }
+        #  threshold {
+        #  }
+        }
+
+        #create-as {
+        #  class = "com.biz.app.MyActor"                                # FIXME document 'create-as'
+        #}
+
+        remote {
+          hostname = "localhost"                                        # The remote server hostname or IP address the remote actor should connect to
+          port = 2552                                                   # The remote server port the remote actor should connect to
+        }
+
+        #cluster {                                                       # defines the actor as a clustered actor
                                                                         #     default (if omitted) is local non-clustered actor
 
-          preferred-nodes = ["node:node1"]                              # a list of preferred nodes for instantiating the actor instances on
+        #  preferred-nodes = ["node:node1"]                              # a list of preferred nodes for instantiating the actor instances on
                                                                         #     defined as node name
                                                                         #     available: "node:<node name>"
 
-          replication-factor = 3                                        # number of actor instances in the cluster
+        #  replication-factor = 3                                        # number of actor instances in the cluster
                                                                         #     available: positive integer (0-N) or the string "auto" for auto-scaling
                                                                         #     if "auto" is used then 'home' has no meaning
                                                                         #     default is '0', meaning no replicas;
                                                                         #     if the "direct" router is used then this element is ignored (always '1')
 
-          replication {                                                 # use replication or not? only makes sense for a stateful actor
+        #  replication {                                                 # use replication or not? only makes sense for a stateful actor
 
             # FIXME should we have this config option here? If so, implement it all through.
-            serialize-mailbox = off                                     # should the actor mailbox be part of the serialized snapshot?
+        #    serialize-mailbox = off                                     # should the actor mailbox be part of the serialized snapshot?
                                                                         #     default is 'off'
 
-            storage = "transaction-log"                                 # storage model for replication
+        #    storage = "transaction-log"                                 # storage model for replication
                                                                         #     available: "transaction-log" and "data-grid"
                                                                         #     default is "transaction-log"
 
-            strategy = "write-through"                                  # guaranteees for replication
+        #    strategy = "write-through"                                  # guaranteees for replication
                                                                         #     available: "write-through" and "write-behind"
                                                                         #     default is "write-through"
 
-          }
-        }
+        #  }
+        #}
       }
     }
 
@@ -209,59 +225,59 @@ akka {
     # }
   }
 
-  cluster {
-    name = "test-cluster"
-    zookeeper-server-addresses = "localhost:2181" # comma-separated list of '<hostname>:<port>' elements
-    remote-server-port = 2552
-    max-time-to-wait-until-connected = 30
-    session-timeout = 60
-    connection-timeout = 60
-    use-compression = off
-    remote-daemon-ack-timeout = 30                # Timeout for ACK of cluster operations, lik checking actor out etc.
-    include-ref-node-in-replica-set = on          # Can a replica be instantiated on the same node as the cluster reference to the actor
-                                                  #     Default: on
-
+  remote {
     # FIXME rename to transport
     layer = "akka.cluster.netty.NettyRemoteSupport"
 
     secure-cookie = ""                            # Generate your own with '$AKKA_HOME/scripts/generate_config_with_secure_cookie.sh'
                                                   #     or using 'akka.util.Crypt.generateSecureCookie'
 
-    log-directory = "_akka_cluster"               # Where ZooKeeper should store the logs and data files
-
-    replication {
-      digest-type = "MAC"        # Options: CRC32 (cheap & unsafe), MAC (expensive & secure using password)
-      password = "secret"        # FIXME: store open in file?
-      ensemble-size = 3
-      quorum-size = 2
-      snapshot-frequency = 1000  # The number of messages that should be logged between every actor snapshot
-      timeout = 30               # Timeout for asyncronous (write-behind) operations
-    }
+    remote-daemon-ack-timeout = 30                # Timeout for ACK of cluster operations, lik checking actor out etc.
 
     server {
-      port = 2552                   # The default remote server port clients should connect to. Default is 2552 (AKKA)
-      message-frame-size = 1048576  # Increase this if you want to be able to send messages with large payloads
-      connection-timeout = 120      # Length in time-unit
-      require-cookie = off          # Should the remote server require that it peers share the same secure-cookie (defined in the 'remote' section)?
-      untrusted-mode = off          # Enable untrusted mode for full security of server managed actors, allows untrusted clients to connect.
-      backlog = 4096                # Sets the size of the connection backlog
-      execution-pool-keepalive = 60 # Length in akka.time-unit how long core threads will be kept alive if idling
-      execution-pool-size      = 16 # Size of the core pool of the remote execution unit
-      max-channel-memory-size  = 0  # Maximum channel size, 0 for off
-      max-total-memory-size    = 0  # Maximum total size of all channels, 0 for off
+      port = 2552                                 # The default remote server port clients should connect to. Default is 2552 (AKKA)
+      message-frame-size = 1048576                # Increase this if you want to be able to send messages with large payloads
+      connection-timeout = 120                    # Length in time-unit
+      require-cookie = off                        # Should the remote server require that it peers share the same secure-cookie (defined in the 'remote' section)?
+      untrusted-mode = off                        # Enable untrusted mode for full security of server managed actors, allows untrusted clients to connect.
+      backlog = 4096                              # Sets the size of the connection backlog
+      execution-pool-keepalive = 60               # Length in akka.time-unit how long core threads will be kept alive if idling
+      execution-pool-size      = 16               # Size of the core pool of the remote execution unit
+      max-channel-memory-size  = 0                # Maximum channel size, 0 for off
+      max-total-memory-size    = 0                # Maximum total size of all channels, 0 for off
     }
 
     client {
       buffering {
-        retry-message-send-on-failure = false # Should message buffering on remote client error be used (buffer flushed on successful reconnect)
-        capacity = -1                         # If negative (or zero) then an unbounded mailbox is used (default)
-                                              #     If positive then a bounded mailbox is used and the capacity is set using the property
+        retry-message-send-on-failure = false     # Should message buffering on remote client error be used (buffer flushed on successful reconnect)
+        capacity = -1                             # If negative (or zero) then an unbounded mailbox is used (default)
+                                                  #     If positive then a bounded mailbox is used and the capacity is set using the property
       }
       reconnect-delay = 5
       read-timeout = 3600
       message-frame-size = 1048576
       reap-futures-delay = 5
-      reconnection-time-window = 600       # Maximum time window that a client should try to reconnect for
+      reconnection-time-window = 600              # Maximum time window that a client should try to reconnect for
+    }
+  }
+
+  cluster {
+    name = "test-cluster"
+    zookeeper-server-addresses = "localhost:2181" # comma-separated list of '<hostname>:<port>' elements
+    max-time-to-wait-until-connected = 30
+    session-timeout = 60
+    connection-timeout = 60
+    include-ref-node-in-replica-set = on          # Can a replica be instantiated on the same node as the cluster reference to the actor
+                                                  #     Default: on
+    log-directory = "_akka_cluster"               # Where ZooKeeper should store the logs and data files
+
+    replication {
+      digest-type = "MAC"                         # Options: CRC32 (cheap & unsafe), MAC (expensive & secure using password)
+      password = "secret"                         # FIXME: store open in file?
+      ensemble-size = 3
+      quorum-size = 2
+      snapshot-frequency = 1000                   # The number of messages that should be logged between every actor snapshot
+      timeout = 30                                # Timeout for asyncronous (write-behind) operations
     }
   }
 
diff --git a/project/AkkaBuild.scala b/project/AkkaBuild.scala
index 33705bb857..e81037fe12 100644
--- a/project/AkkaBuild.scala
+++ b/project/AkkaBuild.scala
@@ -1,6 +1,10 @@
+package akka
+
 import sbt._
 import Keys._
+import com.typesafe.sbtmultijvm.MultiJvmPlugin
 import MultiJvmPlugin.{ MultiJvm, extraOptions, jvmOptions, scalatestOptions }
+import com.typesafe.sbtscalariform.ScalariformPlugin
 import ScalariformPlugin.{ format, formatPreferences }
 import java.lang.Boolean.getBoolean
 
@@ -10,7 +14,7 @@ object AkkaBuild extends Build {
   lazy val buildSettings = Seq(
     organization := "se.scalablesolutions.akka",
     version      := "2.0-SNAPSHOT",
-    scalaVersion := "2.9.0-1"
+    scalaVersion := "2.9.1"
   )
 
   lazy val akka = Project(
@@ -364,7 +368,7 @@ object AkkaBuild extends Build {
     (dir, s) => {
       s.log.info("Building reStructuredText documentation...")
       val exitCode = Process(List("make", "clean", "html", "pdf"), dir) ! s.log
-      if (exitCode != 0) error("Failed to build docs.")
+      if (exitCode != 0) sys.error("Failed to build docs.")
       s.log.info("Done building docs.")
       dir
     }
@@ -460,13 +464,13 @@ object Dependency {
   val jsr250        = "javax.annotation"            % "jsr250-api"             % "1.0"        // CDDL v1
   val jsr311        = "javax.ws.rs"                 % "jsr311-api"             % "1.1"        // CDDL v1
   val log4j         = "log4j"                       % "log4j"                  % "1.2.15"     // ApacheV2
-  val mongoAsync    = "com.mongodb.async"           % "mongo-driver_2.9.0-1"   % "0.2.7"      //ApacheV2
+  val mongoAsync    = "com.mongodb.async"           % "mongo-driver_2.9.0-1"   % "0.2.7"      // ApacheV2
   val multiverse    = "org.multiverse"              % "multiverse-alpha"       % V.Multiverse // ApacheV2
   val netty         = "org.jboss.netty"             % "netty"                  % V.Netty      // ApacheV2
   val osgi          = "org.osgi"                    % "org.osgi.core"          % "4.2.0"      // ApacheV2
   val protobuf      = "com.google.protobuf"         % "protobuf-java"          % V.Protobuf   // New BSD
-  val redis         = "net.debasishg"               % "redisclient_2.9.0"      % "2.3.1"      // ApacheV2
-  val sjson         = "net.debasishg"               % "sjson_2.9.0"            % "0.11"       // ApacheV2
+  val redis         = "net.debasishg"               %% "redisclient"           % "2.4.0"      // ApacheV2
+  val sjson         = "net.debasishg"               %% "sjson"                 % "0.15"       // ApacheV2
   val slf4jApi      = "org.slf4j"                   % "slf4j-api"              % V.Slf4j      // MIT
   val springBeans   = "org.springframework"         % "spring-beans"           % V.Spring     // ApacheV2
   val springContext = "org.springframework"         % "spring-context"         % V.Spring     // ApacheV2
@@ -479,9 +483,9 @@ object Dependency {
   // Provided
 
   object Provided {
-    val javaxServlet = "org.apache.geronimo.specs" % "geronimo-servlet_3.0_spec" % "1.0" % "provided" //CDDL v1
-    val jerseyServer = "com.sun.jersey"    % "jersey-server" % V.Jersey       % "provided" // CDDL v1
-    val jetty        = "org.eclipse.jetty" % "jetty-server"  % V.Jetty        % "provided" // Eclipse license
+    val javaxServlet = "org.apache.geronimo.specs" % "geronimo-servlet_3.0_spec" % "1.0" % "provided" // CDDL v1
+    val jerseyServer = "com.sun.jersey"    % "jersey-server" % V.Jersey       % "provided"            // CDDL v1
+    val jetty        = "org.eclipse.jetty" % "jetty-server"  % V.Jetty        % "provided"            // Eclipse license
   }
 
   // Runtime
@@ -505,8 +509,7 @@ object Dependency {
     val logback     = "ch.qos.logback"          % "logback-classic"     % V.Logback    % "test" // EPL 1.0 / LGPL 2.1
     val mockito     = "org.mockito"             % "mockito-all"         % "1.8.1"      % "test" // MIT
     val multiverse  = "org.multiverse"          % "multiverse-alpha"    % V.Multiverse % "test" // ApacheV2
-    val scalatest   = "org.scalatest"           % "scalatest_2.9.0"     % V.Scalatest  % "test" // ApacheV2
-    val scalacheck  = "org.scala-tools.testing" % "scalacheck_2.9.0"    % "1.9"        % "test" // New BSD
-    val sjsonTest   = "net.debasishg"          %% "sjson"               % "0.11"       % "test" // ApacheV2
+    val scalatest   = "org.scalatest"           %% "scalatest"          % V.Scalatest  % "test" // ApacheV2
+    val scalacheck  = "org.scala-tools.testing" %% "scalacheck"         % "1.9"        % "test" // New BSD
   }
 }
diff --git a/project/Publish.scala b/project/Publish.scala
index 8f5997edb2..38dbdabc8e 100644
--- a/project/Publish.scala
+++ b/project/Publish.scala
@@ -1,3 +1,5 @@
+package akka
+
 import sbt._
 import Keys._
 import java.io.File
diff --git a/project/Unidoc.scala b/project/Unidoc.scala
index 2673e602fe..c8f13b02ac 100644
--- a/project/Unidoc.scala
+++ b/project/Unidoc.scala
@@ -1,3 +1,5 @@
+package akka
+
 import sbt._
 import Keys._
 import Project.Initialize
diff --git a/project/build.properties b/project/build.properties
index f47a3009ec..f2ccdfa377 100644
--- a/project/build.properties
+++ b/project/build.properties
@@ -1 +1 @@
-sbt.version=0.10.1
+sbt.version=0.11.0
diff --git a/project/plugins.sbt b/project/plugins.sbt
new file mode 100644
index 0000000000..8b6d17a0c3
--- /dev/null
+++ b/project/plugins.sbt
@@ -0,0 +1,6 @@
+
+resolvers += Classpaths.typesafeResolver
+
+addSbtPlugin("com.typesafe.sbtmultijvm" % "sbt-multi-jvm" % "0.1.7")
+
+addSbtPlugin("com.typesafe.sbtscalariform" % "sbt-scalariform" % "0.1.4")
diff --git a/project/plugins/build.sbt b/project/plugins/build.sbt
deleted file mode 100644
index 8db73933f3..0000000000
--- a/project/plugins/build.sbt
+++ /dev/null
@@ -1,6 +0,0 @@
-
-resolvers += "Typesafe Repo" at "http://repo.typesafe.com/typesafe/releases/"
-
-libraryDependencies += "com.typesafe.sbt-multi-jvm" %% "sbt-multi-jvm" % "0.1.4"
-
-libraryDependencies += "com.typesafe.sbt-scalariform" %% "sbt-scalariform" % "0.1.2"