diff --git a/akka-remote/src/main/java/se/scalablesolutions/akka/remote/protocol/RemoteProtocol.java b/akka-remote/src/main/java/se/scalablesolutions/akka/remote/protocol/RemoteProtocol.java
index ab05937f61..31ae9650d4 100644
--- a/akka-remote/src/main/java/se/scalablesolutions/akka/remote/protocol/RemoteProtocol.java
+++ b/akka-remote/src/main/java/se/scalablesolutions/akka/remote/protocol/RemoteProtocol.java
@@ -653,6 +653,360 @@ public final class RemoteProtocol {
     // @@protoc_insertion_point(class_scope:RemoteActorRefProtocol)
   }
   
+  public static final class RemoteTypedActorRefProtocol extends
+      com.google.protobuf.GeneratedMessage {
+    // Use RemoteTypedActorRefProtocol.newBuilder() to construct.
+    private RemoteTypedActorRefProtocol() {
+      initFields();
+    }
+    private RemoteTypedActorRefProtocol(boolean noInit) {}
+    
+    private static final RemoteTypedActorRefProtocol defaultInstance;
+    public static RemoteTypedActorRefProtocol getDefaultInstance() {
+      return defaultInstance;
+    }
+    
+    public RemoteTypedActorRefProtocol getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+    
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return se.scalablesolutions.akka.remote.protocol.RemoteProtocol.internal_static_RemoteTypedActorRefProtocol_descriptor;
+    }
+    
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return se.scalablesolutions.akka.remote.protocol.RemoteProtocol.internal_static_RemoteTypedActorRefProtocol_fieldAccessorTable;
+    }
+    
+    // required .RemoteActorRefProtocol actorRef = 1;
+    public static final int ACTORREF_FIELD_NUMBER = 1;
+    private boolean hasActorRef;
+    private se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol actorRef_;
+    public boolean hasActorRef() { return hasActorRef; }
+    public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol getActorRef() { return actorRef_; }
+    
+    // required string interfaceName = 2;
+    public static final int INTERFACENAME_FIELD_NUMBER = 2;
+    private boolean hasInterfaceName;
+    private java.lang.String interfaceName_ = "";
+    public boolean hasInterfaceName() { return hasInterfaceName; }
+    public java.lang.String getInterfaceName() { return interfaceName_; }
+    
+    private void initFields() {
+      actorRef_ = se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
+    }
+    public final boolean isInitialized() {
+      if (!hasActorRef) return false;
+      if (!hasInterfaceName) return false;
+      if (!getActorRef().isInitialized()) return false;
+      return true;
+    }
+    
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (hasActorRef()) {
+        output.writeMessage(1, getActorRef());
+      }
+      if (hasInterfaceName()) {
+        output.writeString(2, getInterfaceName());
+      }
+      getUnknownFields().writeTo(output);
+    }
+    
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+    
+      size = 0;
+      if (hasActorRef()) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(1, getActorRef());
+      }
+      if (hasInterfaceName()) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeStringSize(2, getInterfaceName());
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+    
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return newBuilder().mergeFrom(data).buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return newBuilder().mergeFrom(data, extensionRegistry)
+               .buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return newBuilder().mergeFrom(data).buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return newBuilder().mergeFrom(data, extensionRegistry)
+               .buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return newBuilder().mergeFrom(input).buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return newBuilder().mergeFrom(input, extensionRegistry)
+               .buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      Builder builder = newBuilder();
+      if (builder.mergeDelimitedFrom(input)) {
+        return builder.buildParsed();
+      } else {
+        return null;
+      }
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      Builder builder = newBuilder();
+      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+        return builder.buildParsed();
+      } else {
+        return null;
+      }
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return newBuilder().mergeFrom(input).buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return newBuilder().mergeFrom(input, extensionRegistry)
+               .buildParsed();
+    }
+    
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+    
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder> {
+      private se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol result;
+      
+      // Construct using se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol.newBuilder()
+      private Builder() {}
+      
+      private static Builder create() {
+        Builder builder = new Builder();
+        builder.result = new se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol();
+        return builder;
+      }
+      
+      protected se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol internalGetResult() {
+        return result;
+      }
+      
+      public Builder clear() {
+        if (result == null) {
+          throw new IllegalStateException(
+            "Cannot call clear() after build().");
+        }
+        result = new se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol();
+        return this;
+      }
+      
+      public Builder clone() {
+        return create().mergeFrom(result);
+      }
+      
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol.getDescriptor();
+      }
+      
+      public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol getDefaultInstanceForType() {
+        return se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol.getDefaultInstance();
+      }
+      
+      public boolean isInitialized() {
+        return result.isInitialized();
+      }
+      public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol build() {
+        if (result != null && !isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return buildPartial();
+      }
+      
+      private se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol buildParsed()
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        if (!isInitialized()) {
+          throw newUninitializedMessageException(
+            result).asInvalidProtocolBufferException();
+        }
+        return buildPartial();
+      }
+      
+      public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol buildPartial() {
+        if (result == null) {
+          throw new IllegalStateException(
+            "build() has already been called on this Builder.");
+        }
+        se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol returnMe = result;
+        result = null;
+        return returnMe;
+      }
+      
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol) {
+          return mergeFrom((se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+      
+      public Builder mergeFrom(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol other) {
+        if (other == se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol.getDefaultInstance()) return this;
+        if (other.hasActorRef()) {
+          mergeActorRef(other.getActorRef());
+        }
+        if (other.hasInterfaceName()) {
+          setInterfaceName(other.getInterfaceName());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+      
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder(
+            this.getUnknownFields());
+        while (true) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              this.setUnknownFields(unknownFields.build());
+              return this;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                this.setUnknownFields(unknownFields.build());
+                return this;
+              }
+              break;
+            }
+            case 10: {
+              se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder subBuilder = se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.newBuilder();
+              if (hasActorRef()) {
+                subBuilder.mergeFrom(getActorRef());
+              }
+              input.readMessage(subBuilder, extensionRegistry);
+              setActorRef(subBuilder.buildPartial());
+              break;
+            }
+            case 18: {
+              setInterfaceName(input.readString());
+              break;
+            }
+          }
+        }
+      }
+      
+      
+      // required .RemoteActorRefProtocol actorRef = 1;
+      public boolean hasActorRef() {
+        return result.hasActorRef();
+      }
+      public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol getActorRef() {
+        return result.getActorRef();
+      }
+      public Builder setActorRef(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        result.hasActorRef = true;
+        result.actorRef_ = value;
+        return this;
+      }
+      public Builder setActorRef(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder builderForValue) {
+        result.hasActorRef = true;
+        result.actorRef_ = builderForValue.build();
+        return this;
+      }
+      public Builder mergeActorRef(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol value) {
+        if (result.hasActorRef() &&
+            result.actorRef_ != se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) {
+          result.actorRef_ =
+            se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.newBuilder(result.actorRef_).mergeFrom(value).buildPartial();
+        } else {
+          result.actorRef_ = value;
+        }
+        result.hasActorRef = true;
+        return this;
+      }
+      public Builder clearActorRef() {
+        result.hasActorRef = false;
+        result.actorRef_ = se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
+        return this;
+      }
+      
+      // required string interfaceName = 2;
+      public boolean hasInterfaceName() {
+        return result.hasInterfaceName();
+      }
+      public java.lang.String getInterfaceName() {
+        return result.getInterfaceName();
+      }
+      public Builder setInterfaceName(java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  result.hasInterfaceName = true;
+        result.interfaceName_ = value;
+        return this;
+      }
+      public Builder clearInterfaceName() {
+        result.hasInterfaceName = false;
+        result.interfaceName_ = getDefaultInstance().getInterfaceName();
+        return this;
+      }
+      
+      // @@protoc_insertion_point(builder_scope:RemoteTypedActorRefProtocol)
+    }
+    
+    static {
+      defaultInstance = new RemoteTypedActorRefProtocol(true);
+      se.scalablesolutions.akka.remote.protocol.RemoteProtocol.internalForceInit();
+      defaultInstance.initFields();
+    }
+    
+    // @@protoc_insertion_point(class_scope:RemoteTypedActorRefProtocol)
+  }
+  
   public static final class SerializedActorRefProtocol extends
       com.google.protobuf.GeneratedMessage {
     // Use SerializedActorRefProtocol.newBuilder() to construct.
@@ -1559,6 +1913,360 @@ public final class RemoteProtocol {
     // @@protoc_insertion_point(class_scope:SerializedActorRefProtocol)
   }
   
+  public static final class SerializedTypedActorRefProtocol extends
+      com.google.protobuf.GeneratedMessage {
+    // Use SerializedTypedActorRefProtocol.newBuilder() to construct.
+    private SerializedTypedActorRefProtocol() {
+      initFields();
+    }
+    private SerializedTypedActorRefProtocol(boolean noInit) {}
+    
+    private static final SerializedTypedActorRefProtocol defaultInstance;
+    public static SerializedTypedActorRefProtocol getDefaultInstance() {
+      return defaultInstance;
+    }
+    
+    public SerializedTypedActorRefProtocol getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+    
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return se.scalablesolutions.akka.remote.protocol.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_descriptor;
+    }
+    
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return se.scalablesolutions.akka.remote.protocol.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable;
+    }
+    
+    // required .SerializedActorRefProtocol actorRef = 1;
+    public static final int ACTORREF_FIELD_NUMBER = 1;
+    private boolean hasActorRef;
+    private se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol actorRef_;
+    public boolean hasActorRef() { return hasActorRef; }
+    public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol getActorRef() { return actorRef_; }
+    
+    // required string interfaceName = 2;
+    public static final int INTERFACENAME_FIELD_NUMBER = 2;
+    private boolean hasInterfaceName;
+    private java.lang.String interfaceName_ = "";
+    public boolean hasInterfaceName() { return hasInterfaceName; }
+    public java.lang.String getInterfaceName() { return interfaceName_; }
+    
+    private void initFields() {
+      actorRef_ = se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
+    }
+    public final boolean isInitialized() {
+      if (!hasActorRef) return false;
+      if (!hasInterfaceName) return false;
+      if (!getActorRef().isInitialized()) return false;
+      return true;
+    }
+    
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (hasActorRef()) {
+        output.writeMessage(1, getActorRef());
+      }
+      if (hasInterfaceName()) {
+        output.writeString(2, getInterfaceName());
+      }
+      getUnknownFields().writeTo(output);
+    }
+    
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+    
+      size = 0;
+      if (hasActorRef()) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(1, getActorRef());
+      }
+      if (hasInterfaceName()) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeStringSize(2, getInterfaceName());
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+    
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return newBuilder().mergeFrom(data).buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.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 se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return newBuilder().mergeFrom(data).buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return newBuilder().mergeFrom(data, extensionRegistry)
+               .buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return newBuilder().mergeFrom(input).buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return newBuilder().mergeFrom(input, extensionRegistry)
+               .buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      Builder builder = newBuilder();
+      if (builder.mergeDelimitedFrom(input)) {
+        return builder.buildParsed();
+      } else {
+        return null;
+      }
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      Builder builder = newBuilder();
+      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+        return builder.buildParsed();
+      } else {
+        return null;
+      }
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return newBuilder().mergeFrom(input).buildParsed();
+    }
+    public static se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return newBuilder().mergeFrom(input, extensionRegistry)
+               .buildParsed();
+    }
+    
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+    
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder> {
+      private se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol result;
+      
+      // Construct using se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.newBuilder()
+      private Builder() {}
+      
+      private static Builder create() {
+        Builder builder = new Builder();
+        builder.result = new se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol();
+        return builder;
+      }
+      
+      protected se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol internalGetResult() {
+        return result;
+      }
+      
+      public Builder clear() {
+        if (result == null) {
+          throw new IllegalStateException(
+            "Cannot call clear() after build().");
+        }
+        result = new se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol();
+        return this;
+      }
+      
+      public Builder clone() {
+        return create().mergeFrom(result);
+      }
+      
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.getDescriptor();
+      }
+      
+      public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol getDefaultInstanceForType() {
+        return se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.getDefaultInstance();
+      }
+      
+      public boolean isInitialized() {
+        return result.isInitialized();
+      }
+      public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol build() {
+        if (result != null && !isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return buildPartial();
+      }
+      
+      private se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol buildParsed()
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        if (!isInitialized()) {
+          throw newUninitializedMessageException(
+            result).asInvalidProtocolBufferException();
+        }
+        return buildPartial();
+      }
+      
+      public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol buildPartial() {
+        if (result == null) {
+          throw new IllegalStateException(
+            "build() has already been called on this Builder.");
+        }
+        se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol returnMe = result;
+        result = null;
+        return returnMe;
+      }
+      
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol) {
+          return mergeFrom((se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+      
+      public Builder mergeFrom(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol other) {
+        if (other == se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.getDefaultInstance()) return this;
+        if (other.hasActorRef()) {
+          mergeActorRef(other.getActorRef());
+        }
+        if (other.hasInterfaceName()) {
+          setInterfaceName(other.getInterfaceName());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+      
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder(
+            this.getUnknownFields());
+        while (true) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              this.setUnknownFields(unknownFields.build());
+              return this;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                this.setUnknownFields(unknownFields.build());
+                return this;
+              }
+              break;
+            }
+            case 10: {
+              se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.Builder subBuilder = se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.newBuilder();
+              if (hasActorRef()) {
+                subBuilder.mergeFrom(getActorRef());
+              }
+              input.readMessage(subBuilder, extensionRegistry);
+              setActorRef(subBuilder.buildPartial());
+              break;
+            }
+            case 18: {
+              setInterfaceName(input.readString());
+              break;
+            }
+          }
+        }
+      }
+      
+      
+      // required .SerializedActorRefProtocol actorRef = 1;
+      public boolean hasActorRef() {
+        return result.hasActorRef();
+      }
+      public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol getActorRef() {
+        return result.getActorRef();
+      }
+      public Builder setActorRef(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        result.hasActorRef = true;
+        result.actorRef_ = value;
+        return this;
+      }
+      public Builder setActorRef(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.Builder builderForValue) {
+        result.hasActorRef = true;
+        result.actorRef_ = builderForValue.build();
+        return this;
+      }
+      public Builder mergeActorRef(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol value) {
+        if (result.hasActorRef() &&
+            result.actorRef_ != se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance()) {
+          result.actorRef_ =
+            se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.newBuilder(result.actorRef_).mergeFrom(value).buildPartial();
+        } else {
+          result.actorRef_ = value;
+        }
+        result.hasActorRef = true;
+        return this;
+      }
+      public Builder clearActorRef() {
+        result.hasActorRef = false;
+        result.actorRef_ = se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
+        return this;
+      }
+      
+      // required string interfaceName = 2;
+      public boolean hasInterfaceName() {
+        return result.hasInterfaceName();
+      }
+      public java.lang.String getInterfaceName() {
+        return result.getInterfaceName();
+      }
+      public Builder setInterfaceName(java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  result.hasInterfaceName = true;
+        result.interfaceName_ = value;
+        return this;
+      }
+      public Builder clearInterfaceName() {
+        result.hasInterfaceName = false;
+        result.interfaceName_ = getDefaultInstance().getInterfaceName();
+        return this;
+      }
+      
+      // @@protoc_insertion_point(builder_scope:SerializedTypedActorRefProtocol)
+    }
+    
+    static {
+      defaultInstance = new SerializedTypedActorRefProtocol(true);
+      se.scalablesolutions.akka.remote.protocol.RemoteProtocol.internalForceInit();
+      defaultInstance.initFields();
+    }
+    
+    // @@protoc_insertion_point(class_scope:SerializedTypedActorRefProtocol)
+  }
+  
   public static final class MessageProtocol extends
       com.google.protobuf.GeneratedMessage {
     // Use MessageProtocol.newBuilder() to construct.
@@ -5700,11 +6408,21 @@ public final class RemoteProtocol {
   private static
     com.google.protobuf.GeneratedMessage.FieldAccessorTable
       internal_static_RemoteActorRefProtocol_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_RemoteTypedActorRefProtocol_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_RemoteTypedActorRefProtocol_fieldAccessorTable;
   private static com.google.protobuf.Descriptors.Descriptor
     internal_static_SerializedActorRefProtocol_descriptor;
   private static
     com.google.protobuf.GeneratedMessage.FieldAccessorTable
       internal_static_SerializedActorRefProtocol_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_SerializedTypedActorRefProtocol_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable;
   private static com.google.protobuf.Descriptors.Descriptor
     internal_static_MessageProtocol_descriptor;
   private static
@@ -5767,49 +6485,54 @@ public final class RemoteProtocol {
       "\n\024RemoteProtocol.proto\"v\n\026RemoteActorRef" +
       "Protocol\022\014\n\004uuid\030\001 \002(\t\022\026\n\016actorClassname" +
       "\030\002 \002(\t\022%\n\013homeAddress\030\003 \002(\0132\020.AddressPro" +
-      "tocol\022\017\n\007timeout\030\004 \001(\004\"\200\003\n\032SerializedAct" +
-      "orRefProtocol\022\014\n\004uuid\030\001 \002(\t\022\n\n\002id\030\002 \002(\t\022" +
-      "\026\n\016actorClassname\030\003 \002(\t\022)\n\017originalAddre" +
-      "ss\030\004 \002(\0132\020.AddressProtocol\022\025\n\ractorInsta" +
-      "nce\030\005 \001(\014\022\033\n\023serializerClassname\030\006 \001(\t\022\024" +
-      "\n\014isTransactor\030\007 \001(\010\022\017\n\007timeout\030\010 \001(\004\022\026\n" +
-      "\016receiveTimeout\030\t \001(\004\022%\n\tlifeCycle\030\n \001(\013",
-      "2\022.LifeCycleProtocol\022+\n\nsupervisor\030\013 \001(\013" +
-      "2\027.RemoteActorRefProtocol\022\024\n\014hotswapStac" +
-      "k\030\014 \001(\014\022(\n\010messages\030\r \003(\0132\026.RemoteReques" +
-      "tProtocol\"r\n\017MessageProtocol\0225\n\023serializ" +
-      "ationScheme\030\001 \002(\0162\030.SerializationSchemeT" +
-      "ype\022\017\n\007message\030\002 \002(\014\022\027\n\017messageManifest\030" +
-      "\003 \001(\014\"\236\001\n\021ActorInfoProtocol\022\014\n\004uuid\030\001 \002(" +
-      "\t\022\016\n\006target\030\002 \002(\t\022\017\n\007timeout\030\003 \002(\004\022\035\n\tac" +
-      "torType\030\004 \002(\0162\n.ActorType\022/\n\016typedActorI" +
-      "nfo\030\005 \001(\0132\027.TypedActorInfoProtocol\022\n\n\002id",
-      "\030\006 \001(\t\";\n\026TypedActorInfoProtocol\022\021\n\tinte" +
-      "rface\030\001 \002(\t\022\016\n\006method\030\002 \002(\t\"\352\001\n\025RemoteRe" +
-      "questProtocol\022\n\n\002id\030\001 \002(\004\022!\n\007message\030\002 \002" +
-      "(\0132\020.MessageProtocol\022%\n\tactorInfo\030\003 \002(\0132" +
-      "\022.ActorInfoProtocol\022\020\n\010isOneWay\030\004 \002(\010\022\026\n" +
-      "\016supervisorUuid\030\005 \001(\t\022\'\n\006sender\030\006 \001(\0132\027." +
-      "RemoteActorRefProtocol\022(\n\010metadata\030\007 \003(\013" +
-      "2\026.MetadataEntryProtocol\"\324\001\n\023RemoteReply" +
-      "Protocol\022\n\n\002id\030\001 \002(\004\022!\n\007message\030\002 \001(\0132\020." +
-      "MessageProtocol\022%\n\texception\030\003 \001(\0132\022.Exc",
-      "eptionProtocol\022\026\n\016supervisorUuid\030\004 \001(\t\022\017" +
-      "\n\007isActor\030\005 \002(\010\022\024\n\014isSuccessful\030\006 \002(\010\022(\n" +
-      "\010metadata\030\007 \003(\0132\026.MetadataEntryProtocol\"" +
-      ")\n\014UuidProtocol\022\014\n\004high\030\001 \002(\004\022\013\n\003low\030\002 \002" +
-      "(\004\"3\n\025MetadataEntryProtocol\022\013\n\003key\030\001 \002(\t" +
-      "\022\r\n\005value\030\002 \002(\014\"6\n\021LifeCycleProtocol\022!\n\t" +
-      "lifeCycle\030\001 \002(\0162\016.LifeCycleType\"1\n\017Addre" +
-      "ssProtocol\022\020\n\010hostname\030\001 \002(\t\022\014\n\004port\030\002 \002" +
-      "(\r\"7\n\021ExceptionProtocol\022\021\n\tclassname\030\001 \002" +
-      "(\t\022\017\n\007message\030\002 \002(\t*=\n\tActorType\022\017\n\013SCAL",
-      "A_ACTOR\020\001\022\016\n\nJAVA_ACTOR\020\002\022\017\n\013TYPED_ACTOR" +
-      "\020\003*]\n\027SerializationSchemeType\022\010\n\004JAVA\020\001\022" +
-      "\013\n\007SBINARY\020\002\022\016\n\nSCALA_JSON\020\003\022\r\n\tJAVA_JSO" +
-      "N\020\004\022\014\n\010PROTOBUF\020\005*-\n\rLifeCycleType\022\r\n\tPE" +
-      "RMANENT\020\001\022\r\n\tTEMPORARY\020\002B-\n)se.scalables" +
-      "olutions.akka.remote.protocolH\001"
+      "tocol\022\017\n\007timeout\030\004 \001(\004\"_\n\033RemoteTypedAct" +
+      "orRefProtocol\022)\n\010actorRef\030\001 \002(\0132\027.Remote" +
+      "ActorRefProtocol\022\025\n\rinterfaceName\030\002 \002(\t\"" +
+      "\200\003\n\032SerializedActorRefProtocol\022\014\n\004uuid\030\001" +
+      " \002(\t\022\n\n\002id\030\002 \002(\t\022\026\n\016actorClassname\030\003 \002(\t" +
+      "\022)\n\017originalAddress\030\004 \002(\0132\020.AddressProto" +
+      "col\022\025\n\ractorInstance\030\005 \001(\014\022\033\n\023serializer",
+      "Classname\030\006 \001(\t\022\024\n\014isTransactor\030\007 \001(\010\022\017\n" +
+      "\007timeout\030\010 \001(\004\022\026\n\016receiveTimeout\030\t \001(\004\022%" +
+      "\n\tlifeCycle\030\n \001(\0132\022.LifeCycleProtocol\022+\n" +
+      "\nsupervisor\030\013 \001(\0132\027.RemoteActorRefProtoc" +
+      "ol\022\024\n\014hotswapStack\030\014 \001(\014\022(\n\010messages\030\r \003" +
+      "(\0132\026.RemoteRequestProtocol\"g\n\037Serialized" +
+      "TypedActorRefProtocol\022-\n\010actorRef\030\001 \002(\0132" +
+      "\033.SerializedActorRefProtocol\022\025\n\rinterfac" +
+      "eName\030\002 \002(\t\"r\n\017MessageProtocol\0225\n\023serial" +
+      "izationScheme\030\001 \002(\0162\030.SerializationSchem",
+      "eType\022\017\n\007message\030\002 \002(\014\022\027\n\017messageManifes" +
+      "t\030\003 \001(\014\"\236\001\n\021ActorInfoProtocol\022\014\n\004uuid\030\001 " +
+      "\002(\t\022\016\n\006target\030\002 \002(\t\022\017\n\007timeout\030\003 \002(\004\022\035\n\t" +
+      "actorType\030\004 \002(\0162\n.ActorType\022/\n\016typedActo" +
+      "rInfo\030\005 \001(\0132\027.TypedActorInfoProtocol\022\n\n\002" +
+      "id\030\006 \001(\t\";\n\026TypedActorInfoProtocol\022\021\n\tin" +
+      "terface\030\001 \002(\t\022\016\n\006method\030\002 \002(\t\"\352\001\n\025Remote" +
+      "RequestProtocol\022\n\n\002id\030\001 \002(\004\022!\n\007message\030\002" +
+      " \002(\0132\020.MessageProtocol\022%\n\tactorInfo\030\003 \002(" +
+      "\0132\022.ActorInfoProtocol\022\020\n\010isOneWay\030\004 \002(\010\022",
+      "\026\n\016supervisorUuid\030\005 \001(\t\022\'\n\006sender\030\006 \001(\0132" +
+      "\027.RemoteActorRefProtocol\022(\n\010metadata\030\007 \003" +
+      "(\0132\026.MetadataEntryProtocol\"\324\001\n\023RemoteRep" +
+      "lyProtocol\022\n\n\002id\030\001 \002(\004\022!\n\007message\030\002 \001(\0132" +
+      "\020.MessageProtocol\022%\n\texception\030\003 \001(\0132\022.E" +
+      "xceptionProtocol\022\026\n\016supervisorUuid\030\004 \001(\t" +
+      "\022\017\n\007isActor\030\005 \002(\010\022\024\n\014isSuccessful\030\006 \002(\010\022" +
+      "(\n\010metadata\030\007 \003(\0132\026.MetadataEntryProtoco" +
+      "l\")\n\014UuidProtocol\022\014\n\004high\030\001 \002(\004\022\013\n\003low\030\002" +
+      " \002(\004\"3\n\025MetadataEntryProtocol\022\013\n\003key\030\001 \002",
+      "(\t\022\r\n\005value\030\002 \002(\014\"6\n\021LifeCycleProtocol\022!" +
+      "\n\tlifeCycle\030\001 \002(\0162\016.LifeCycleType\"1\n\017Add" +
+      "ressProtocol\022\020\n\010hostname\030\001 \002(\t\022\014\n\004port\030\002" +
+      " \002(\r\"7\n\021ExceptionProtocol\022\021\n\tclassname\030\001" +
+      " \002(\t\022\017\n\007message\030\002 \002(\t*=\n\tActorType\022\017\n\013SC" +
+      "ALA_ACTOR\020\001\022\016\n\nJAVA_ACTOR\020\002\022\017\n\013TYPED_ACT" +
+      "OR\020\003*]\n\027SerializationSchemeType\022\010\n\004JAVA\020" +
+      "\001\022\013\n\007SBINARY\020\002\022\016\n\nSCALA_JSON\020\003\022\r\n\tJAVA_J" +
+      "SON\020\004\022\014\n\010PROTOBUF\020\005*-\n\rLifeCycleType\022\r\n\t" +
+      "PERMANENT\020\001\022\r\n\tTEMPORARY\020\002B-\n)se.scalabl",
+      "esolutions.akka.remote.protocolH\001"
     };
     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
@@ -5824,16 +6547,32 @@ public final class RemoteProtocol {
               new java.lang.String[] { "Uuid", "ActorClassname", "HomeAddress", "Timeout", },
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.class,
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder.class);
-          internal_static_SerializedActorRefProtocol_descriptor =
+          internal_static_RemoteTypedActorRefProtocol_descriptor =
             getDescriptor().getMessageTypes().get(1);
+          internal_static_RemoteTypedActorRefProtocol_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_RemoteTypedActorRefProtocol_descriptor,
+              new java.lang.String[] { "ActorRef", "InterfaceName", },
+              se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol.class,
+              se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol.Builder.class);
+          internal_static_SerializedActorRefProtocol_descriptor =
+            getDescriptor().getMessageTypes().get(2);
           internal_static_SerializedActorRefProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_SerializedActorRefProtocol_descriptor,
               new java.lang.String[] { "Uuid", "Id", "ActorClassname", "OriginalAddress", "ActorInstance", "SerializerClassname", "IsTransactor", "Timeout", "ReceiveTimeout", "LifeCycle", "Supervisor", "HotswapStack", "Messages", },
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.class,
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.Builder.class);
+          internal_static_SerializedTypedActorRefProtocol_descriptor =
+            getDescriptor().getMessageTypes().get(3);
+          internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_SerializedTypedActorRefProtocol_descriptor,
+              new java.lang.String[] { "ActorRef", "InterfaceName", },
+              se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.class,
+              se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.Builder.class);
           internal_static_MessageProtocol_descriptor =
-            getDescriptor().getMessageTypes().get(2);
+            getDescriptor().getMessageTypes().get(4);
           internal_static_MessageProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_MessageProtocol_descriptor,
@@ -5841,7 +6580,7 @@ public final class RemoteProtocol {
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.MessageProtocol.class,
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.MessageProtocol.Builder.class);
           internal_static_ActorInfoProtocol_descriptor =
-            getDescriptor().getMessageTypes().get(3);
+            getDescriptor().getMessageTypes().get(5);
           internal_static_ActorInfoProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_ActorInfoProtocol_descriptor,
@@ -5849,7 +6588,7 @@ public final class RemoteProtocol {
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.class,
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.Builder.class);
           internal_static_TypedActorInfoProtocol_descriptor =
-            getDescriptor().getMessageTypes().get(4);
+            getDescriptor().getMessageTypes().get(6);
           internal_static_TypedActorInfoProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_TypedActorInfoProtocol_descriptor,
@@ -5857,7 +6596,7 @@ public final class RemoteProtocol {
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.TypedActorInfoProtocol.class,
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.TypedActorInfoProtocol.Builder.class);
           internal_static_RemoteRequestProtocol_descriptor =
-            getDescriptor().getMessageTypes().get(5);
+            getDescriptor().getMessageTypes().get(7);
           internal_static_RemoteRequestProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_RemoteRequestProtocol_descriptor,
@@ -5865,7 +6604,7 @@ public final class RemoteProtocol {
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteRequestProtocol.class,
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteRequestProtocol.Builder.class);
           internal_static_RemoteReplyProtocol_descriptor =
-            getDescriptor().getMessageTypes().get(6);
+            getDescriptor().getMessageTypes().get(8);
           internal_static_RemoteReplyProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_RemoteReplyProtocol_descriptor,
@@ -5873,7 +6612,7 @@ public final class RemoteProtocol {
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteReplyProtocol.class,
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteReplyProtocol.Builder.class);
           internal_static_UuidProtocol_descriptor =
-            getDescriptor().getMessageTypes().get(7);
+            getDescriptor().getMessageTypes().get(9);
           internal_static_UuidProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_UuidProtocol_descriptor,
@@ -5881,7 +6620,7 @@ public final class RemoteProtocol {
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.UuidProtocol.class,
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder.class);
           internal_static_MetadataEntryProtocol_descriptor =
-            getDescriptor().getMessageTypes().get(8);
+            getDescriptor().getMessageTypes().get(10);
           internal_static_MetadataEntryProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_MetadataEntryProtocol_descriptor,
@@ -5889,7 +6628,7 @@ public final class RemoteProtocol {
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.class,
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.Builder.class);
           internal_static_LifeCycleProtocol_descriptor =
-            getDescriptor().getMessageTypes().get(9);
+            getDescriptor().getMessageTypes().get(11);
           internal_static_LifeCycleProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_LifeCycleProtocol_descriptor,
@@ -5897,7 +6636,7 @@ public final class RemoteProtocol {
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.class,
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.Builder.class);
           internal_static_AddressProtocol_descriptor =
-            getDescriptor().getMessageTypes().get(10);
+            getDescriptor().getMessageTypes().get(12);
           internal_static_AddressProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_AddressProtocol_descriptor,
@@ -5905,7 +6644,7 @@ public final class RemoteProtocol {
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.AddressProtocol.class,
               se.scalablesolutions.akka.remote.protocol.RemoteProtocol.AddressProtocol.Builder.class);
           internal_static_ExceptionProtocol_descriptor =
-            getDescriptor().getMessageTypes().get(11);
+            getDescriptor().getMessageTypes().get(13);
           internal_static_ExceptionProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_ExceptionProtocol_descriptor,
diff --git a/akka-remote/src/main/protocol/RemoteProtocol.proto b/akka-remote/src/main/protocol/RemoteProtocol.proto
index 4343fecf7f..e84ae9f18e 100644
--- a/akka-remote/src/main/protocol/RemoteProtocol.proto
+++ b/akka-remote/src/main/protocol/RemoteProtocol.proto
@@ -22,6 +22,15 @@ message RemoteActorRefProtocol {
   optional uint64 timeout = 4;
 }
 
+/**
+ * Defines a remote ActorRef that "remembers" and uses its original typed Actor instance
+ * on the original node.
+ */
+message RemoteTypedActorRefProtocol {
+  required RemoteActorRefProtocol actorRef = 1;
+  required string interfaceName = 2;
+}
+
 /**
  * Defines a fully serialized remote ActorRef (with serialized Actor instance)
  * that is about to be instantiated on the remote node. It is fully disconnected 
@@ -43,6 +52,16 @@ message SerializedActorRefProtocol {
   repeated RemoteRequestProtocol messages = 13;
 }
 
+/**
+ * Defines a fully serialized remote ActorRef (with serialized typed actor instance)
+ * that is about to be instantiated on the remote node. It is fully disconnected
+ * from its original host.
+ */
+message SerializedTypedActorRefProtocol {
+  required SerializedActorRefProtocol actorRef = 1;
+  required string interfaceName = 2;
+}
+
 /**
  * Defines a message.
  */
diff --git a/akka-remote/src/main/scala/serialization/SerializationProtocol.scala b/akka-remote/src/main/scala/serialization/SerializationProtocol.scala
index 0ed0f557eb..5fbf9583b4 100644
--- a/akka-remote/src/main/scala/serialization/SerializationProtocol.scala
+++ b/akka-remote/src/main/scala/serialization/SerializationProtocol.scala
@@ -4,7 +4,6 @@
 
 package se.scalablesolutions.akka.serialization
 
-import se.scalablesolutions.akka.actor.{Actor, ActorRef, LocalActorRef, RemoteActorRef, IllegalActorStateException, ActorType}
 import se.scalablesolutions.akka.stm.global._
 import se.scalablesolutions.akka.stm.TransactionManagement._
 import se.scalablesolutions.akka.stm.TransactionManagement
@@ -15,6 +14,7 @@ import se.scalablesolutions.akka.config.{AllForOneStrategy, OneForOneStrategy, F
 import se.scalablesolutions.akka.config.ScalaConfig._
 
 import com.google.protobuf.ByteString
+import se.scalablesolutions.akka.actor._
 
 /**
  * Type class definition for Actor Serialization
@@ -36,13 +36,14 @@ trait Format[T <: Actor] extends FromBinary[T] with ToBinary[T]
  * Create a Format object with the client actor as the implementation of the type class
  *
  * <pre>
- * object BinaryFormatMyStatelessActor {
+ * object BinaryFormatMyStatelessActor  {
  *   implicit object MyStatelessActorFormat extends StatelessActorFormat[MyStatelessActor]
  * }
  * </pre>
  */
 trait StatelessActorFormat[T <: Actor] extends Format[T] {
   def fromBinary(bytes: Array[Byte], act: T) = act
+
   def toBinary(ac: T) = Array.empty[Byte]
 }
 
@@ -53,16 +54,18 @@ trait StatelessActorFormat[T <: Actor] extends Format[T] {
  * a serializer object
  *
  * <pre>
- * object BinaryFormatMyJavaSerializableActor {
- *   implicit object MyJavaSerializableActorFormat extends SerializerBasedActorFormat[MyJavaSerializableActor] {
+ * object BinaryFormatMyJavaSerializableActor  {
+ *   implicit object MyJavaSerializableActorFormat extends SerializerBasedActorFormat[MyJavaSerializableActor]  {
  *     val serializer = Serializer.Java
- *   }
+ * }
  * }
  * </pre>
  */
 trait SerializerBasedActorFormat[T <: Actor] extends Format[T] {
   val serializer: Serializer
+
   def fromBinary(bytes: Array[Byte], act: T) = serializer.fromBinary(bytes, Some(act.self.actorClass)).asInstanceOf[T]
+
   def toBinary(ac: T) = serializer.toBinary(ac)
 }
 
@@ -70,7 +73,6 @@ trait SerializerBasedActorFormat[T <: Actor] extends Format[T] {
  * Module for local actor serialization.
  */
 object ActorSerialization {
-
   def fromBinary[T <: Actor](bytes: Array[Byte])(implicit format: Format[T]): ActorRef =
     fromBinaryToLocalActorRef(bytes, format)
 
@@ -85,8 +87,8 @@ object ActorSerialization {
   def toBinaryJ[T <: Actor](a: ActorRef, format: Format[T]): Array[Byte] =
     toBinary(a)(format)
 
-  private def toSerializedActorRefProtocol[T <: Actor](
-    actorRef: ActorRef, format: Format[T]): SerializedActorRefProtocol = {
+  private[akka] def toSerializedActorRefProtocol[T <: Actor](
+      actorRef: ActorRef, format: Format[T]): SerializedActorRefProtocol = {
     val lifeCycleProtocol: Option[LifeCycleProtocol] = {
       def setScope(builder: LifeCycleProtocol.Builder, scope: Scope) = scope match {
         case Permanent => builder.setLifeCycle(LifeCycleType.PERMANENT)
@@ -102,17 +104,17 @@ object ActorSerialization {
     }
 
     val originalAddress = AddressProtocol.newBuilder
-      .setHostname(actorRef.homeAddress.getHostName)
-      .setPort(actorRef.homeAddress.getPort)
-      .build
+        .setHostname(actorRef.homeAddress.getHostName)
+        .setPort(actorRef.homeAddress.getPort)
+        .build
 
     val builder = SerializedActorRefProtocol.newBuilder
-      .setUuid(actorRef.uuid)
-      .setId(actorRef.id)
-      .setActorClassname(actorRef.actorClass.getName)
-      .setOriginalAddress(originalAddress)
-      .setIsTransactor(actorRef.isTransactor)
-      .setTimeout(actorRef.timeout)
+        .setUuid(actorRef.uuid)
+        .setId(actorRef.id)
+        .setActorClassname(actorRef.actorClass.getName)
+        .setOriginalAddress(originalAddress)
+        .setIsTransactor(actorRef.isTransactor)
+        .setTimeout(actorRef.timeout)
 
     actorRef.receiveTimeout.foreach(builder.setReceiveTimeout(_))
     builder.setActorInstance(ByteString.copyFrom(format.toBinary(actorRef.actor.asInstanceOf[T])))
@@ -126,33 +128,33 @@ object ActorSerialization {
   private def fromBinaryToLocalActorRef[T <: Actor](bytes: Array[Byte], format: Format[T]): ActorRef =
     fromProtobufToLocalActorRef(SerializedActorRefProtocol.newBuilder.mergeFrom(bytes).build, format, None)
 
-  private def fromProtobufToLocalActorRef[T <: Actor](
-    protocol: SerializedActorRefProtocol, format: Format[T], loader: Option[ClassLoader]): ActorRef = {
+  private[akka] def fromProtobufToLocalActorRef[T <: Actor](
+      protocol: SerializedActorRefProtocol, format: Format[T], loader: Option[ClassLoader]): ActorRef = {
     Actor.log.debug("Deserializing SerializedActorRefProtocol to LocalActorRef:\n" + protocol)
 
     val serializer =
-      if (format.isInstanceOf[SerializerBasedActorFormat[_]])
-        Some(format.asInstanceOf[SerializerBasedActorFormat[_]].serializer)
-      else None
+    if (format.isInstanceOf[SerializerBasedActorFormat[_]])
+      Some(format.asInstanceOf[SerializerBasedActorFormat[_]].serializer)
+    else None
 
     val lifeCycle =
-      if (protocol.hasLifeCycle) {
-        val lifeCycleProtocol = protocol.getLifeCycle
-        Some(if (lifeCycleProtocol.getLifeCycle == LifeCycleType.PERMANENT) LifeCycle(Permanent)
-             else if (lifeCycleProtocol.getLifeCycle == LifeCycleType.TEMPORARY) LifeCycle(Temporary)
-             else throw new IllegalActorStateException("LifeCycle type is not valid: " + lifeCycleProtocol.getLifeCycle))
-      } else None
+    if (protocol.hasLifeCycle) {
+      val lifeCycleProtocol = protocol.getLifeCycle
+      Some(if (lifeCycleProtocol.getLifeCycle == LifeCycleType.PERMANENT) LifeCycle(Permanent)
+      else if (lifeCycleProtocol.getLifeCycle == LifeCycleType.TEMPORARY) LifeCycle(Temporary)
+      else throw new IllegalActorStateException("LifeCycle type is not valid: " + lifeCycleProtocol.getLifeCycle))
+    } else None
 
     val supervisor =
-      if (protocol.hasSupervisor)
-        Some(RemoteActorSerialization.fromProtobufToRemoteActorRef(protocol.getSupervisor, loader))
-      else None
+    if (protocol.hasSupervisor)
+      Some(RemoteActorSerialization.fromProtobufToRemoteActorRef(protocol.getSupervisor, loader))
+    else None
 
     val hotswap =
-      if (serializer.isDefined && protocol.hasHotswapStack) Some(serializer.get
+    if (serializer.isDefined && protocol.hasHotswapStack) Some(serializer.get
         .fromBinary(protocol.getHotswapStack.toByteArray, Some(classOf[PartialFunction[Any, Unit]]))
         .asInstanceOf[PartialFunction[Any, Unit]])
-      else None
+    else None
 
     val classLoader = loader.getOrElse(getClass.getClassLoader)
 
@@ -194,9 +196,9 @@ object RemoteActorSerialization {
   def fromBinaryToRemoteActorRef(bytes: Array[Byte]): ActorRef =
     fromProtobufToRemoteActorRef(RemoteActorRefProtocol.newBuilder.mergeFrom(bytes).build, None)
 
-    /**
-     * Deserializes a byte array (Array[Byte]) into an RemoteActorRef instance.
-     */
+  /**
+   * Deserializes a byte array (Array[Byte]) into an RemoteActorRef instance.
+   */
   def fromBinaryToRemoteActorRef(bytes: Array[Byte], loader: ClassLoader): ActorRef =
     fromProtobufToRemoteActorRef(RemoteActorRefProtocol.newBuilder.mergeFrom(bytes).build, Some(loader))
 
@@ -230,21 +232,21 @@ object RemoteActorSerialization {
     }
 
     RemoteActorRefProtocol.newBuilder
-      .setUuid(uuid)
-      .setActorClassname(actorClass.getName)
-      .setHomeAddress(AddressProtocol.newBuilder.setHostname(host).setPort(port).build)
-      .setTimeout(timeout)
-      .build
+        .setUuid(uuid)
+        .setActorClassname(actorClass.getName)
+        .setHomeAddress(AddressProtocol.newBuilder.setHostname(host).setPort(port).build)
+        .setTimeout(timeout)
+        .build
   }
 
   def createRemoteRequestProtocolBuilder(
-    actorRef: ActorRef,
-    message: Any,
-    isOneWay: Boolean,
-    senderOption: Option[ActorRef],
-    typedActorInfo: Option[Tuple2[String, String]],
-    actorType: ActorType):
-    RemoteRequestProtocol.Builder = {
+      actorRef: ActorRef,
+      message: Any,
+      isOneWay: Boolean,
+      senderOption: Option[ActorRef],
+      typedActorInfo: Option[Tuple2[String, String]],
+      actorType: ActorType):
+  RemoteRequestProtocol.Builder = {
     import actorRef._
 
     val actorInfoBuilder = ActorInfoProtocol.newBuilder
@@ -253,12 +255,13 @@ object RemoteActorSerialization {
         .setTarget(actorClassName)
         .setTimeout(timeout)
 
-    typedActorInfo.foreach { typedActor =>
-      actorInfoBuilder.setTypedActorInfo(
-        TypedActorInfoProtocol.newBuilder
-          .setInterface(typedActor._1)
-          .setMethod(typedActor._2)
-          .build)
+    typedActorInfo.foreach {
+      typedActor =>
+        actorInfoBuilder.setTypedActorInfo(
+          TypedActorInfoProtocol.newBuilder
+              .setInterface(typedActor._1)
+              .setMethod(typedActor._2)
+              .build)
     }
 
     actorType match {
@@ -276,10 +279,110 @@ object RemoteActorSerialization {
     val id = registerSupervisorAsRemoteActor
     if (id.isDefined) requestBuilder.setSupervisorUuid(id.get)
 
-    senderOption.foreach { sender =>
-      RemoteServer.getOrCreateServer(sender.homeAddress).register(sender.uuid, sender)
-      requestBuilder.setSender(toRemoteActorRefProtocol(sender))
+    senderOption.foreach {
+      sender =>
+        RemoteServer.getOrCreateServer(sender.homeAddress).register(sender.uuid, sender)
+        requestBuilder.setSender(toRemoteActorRefProtocol(sender))
     }
     requestBuilder
   }
+
+
+}
+
+
+/**
+ * Module for local typed actor serialization.
+ */
+object TypedActorSerialization {
+
+  def fromBinary[T <: Actor, U <: AnyRef](bytes: Array[Byte])(implicit format: Format[T]): U =
+    fromBinaryToLocalTypedActorRef(bytes, format)
+
+  def toBinary[T <: Actor](proxy: AnyRef)(implicit format: Format[T]): Array[Byte] = {
+    toSerializedTypedActorRefProtocol(proxy, format).toByteArray
+  }
+
+  // wrapper for implicits to be used by Java
+  def fromBinaryJ[T <: Actor, U <: AnyRef](bytes: Array[Byte], format: Format[T]): U =
+    fromBinary(bytes)(format)
+
+  // wrapper for implicits to be used by Java
+  def toBinaryJ[T <: Actor](a: AnyRef, format: Format[T]): Array[Byte] =
+    toBinary(a)(format)
+
+  private def toSerializedTypedActorRefProtocol[T <: Actor](
+      proxy: AnyRef, format: Format[T]): SerializedTypedActorRefProtocol = {
+
+    val init = AspectInitRegistry.initFor(proxy)
+    if (init == null) throw new IllegalArgumentException("Proxy for typed actor could not be found in AspectInitRegistry.")
+
+    SerializedTypedActorRefProtocol.newBuilder
+        .setActorRef(ActorSerialization.toSerializedActorRefProtocol(init.actorRef, format))
+        .setInterfaceName(init.interfaceClass.getName)
+        .build
+  }
+
+  private def fromBinaryToLocalTypedActorRef[T <: Actor, U <: AnyRef](bytes: Array[Byte], format: Format[T]): U =
+    fromProtobufToLocalTypedActorRef(SerializedTypedActorRefProtocol.newBuilder.mergeFrom(bytes).build, format, None)
+
+  private def fromProtobufToLocalTypedActorRef[T <: Actor, U <: AnyRef](
+      protocol: SerializedTypedActorRefProtocol, format: Format[T], loader: Option[ClassLoader]): U = {
+    Actor.log.debug("Deserializing SerializedTypedActorRefProtocol to LocalActorRef:\n" + protocol)
+    val actorRef = ActorSerialization.fromProtobufToLocalActorRef(protocol.getActorRef, format, loader)
+    val intfClass = toClass(loader, protocol.getInterfaceName)
+    TypedActor.newInstance(intfClass, actorRef).asInstanceOf[U]
+  }
+
+  private[akka] def toClass[U <: AnyRef](loader: Option[ClassLoader], name: String): Class[U] = {
+    val classLoader = loader.getOrElse(getClass.getClassLoader)
+    val clazz = classLoader.loadClass(name)
+    clazz.asInstanceOf[Class[U]]
+  }
+}
+
+/**
+ * Module for remote typed actor serialization.
+ */
+object RemoteTypedActorSerialization {
+  /**
+   * Deserializes a byte array (Array[Byte]) into an RemoteActorRef instance.
+   */
+  def fromBinaryToRemoteTypedActorRef[T <: AnyRef](bytes: Array[Byte]): T =
+    fromProtobufToRemoteTypedActorRef(RemoteTypedActorRefProtocol.newBuilder.mergeFrom(bytes).build, None)
+
+  /**
+   * Deserializes a byte array (Array[Byte]) into a AW RemoteActorRef proxy.
+   */
+  def fromBinaryToRemoteTypedActorRef[T <: AnyRef](bytes: Array[Byte], loader: ClassLoader): T =
+    fromProtobufToRemoteTypedActorRef(RemoteTypedActorRefProtocol.newBuilder.mergeFrom(bytes).build, Some(loader))
+
+  /**
+   * Serialize as AW RemoteActorRef proxy.
+   */
+  def toBinary[T <: Actor](proxy: AnyRef): Array[Byte] = {
+    toRemoteTypedActorRefProtocol(proxy).toByteArray
+  }
+
+  /**
+   * Deserializes a RemoteTypedActorRefProtocol Protocol Buffers (protobuf) Message into AW RemoteActorRef proxy.
+   */
+  private[akka] def fromProtobufToRemoteTypedActorRef[T](protocol: RemoteTypedActorRefProtocol, loader: Option[ClassLoader]): T = {
+    Actor.log.debug("Deserializing RemoteTypedActorRefProtocol to AW RemoteActorRef proxy:\n" + protocol)
+    val actorRef = RemoteActorSerialization.fromProtobufToRemoteActorRef(protocol.getActorRef, loader)
+    val intfClass = TypedActorSerialization.toClass(loader, protocol.getInterfaceName)
+    TypedActor.createProxyForRemoteActorRef(intfClass, actorRef).asInstanceOf[T]
+  }
+
+  /**
+   * Serializes the AW TypedActor proxy into a Protocol Buffers (protobuf) Message.
+   */
+  def toRemoteTypedActorRefProtocol(proxy: AnyRef): RemoteTypedActorRefProtocol = {
+    val init = AspectInitRegistry.initFor(proxy)
+    RemoteTypedActorRefProtocol.newBuilder
+        .setActorRef(RemoteActorSerialization.toRemoteActorRefProtocol(init.actorRef))
+        .setInterfaceName(init.interfaceClass.getName)
+        .build
+  }
+
 }
diff --git a/akka-remote/src/test/scala/serialization/TypedActorSerializationSpec.scala b/akka-remote/src/test/scala/serialization/TypedActorSerializationSpec.scala
new file mode 100644
index 0000000000..ccf4d05f7f
--- /dev/null
+++ b/akka-remote/src/test/scala/serialization/TypedActorSerializationSpec.scala
@@ -0,0 +1,166 @@
+/**
+ * Copyright (C) 2009-2010 Scalable Solutions AB <http://scalablesolutions.se>
+ */
+package se.scalablesolutions.akka.actor.serialization
+
+import org.scalatest.Spec
+import org.scalatest.matchers.ShouldMatchers
+import org.scalatest.BeforeAndAfterAll
+import org.scalatest.junit.JUnitRunner
+import org.junit.runner.RunWith
+
+import se.scalablesolutions.akka.serialization._
+import se.scalablesolutions.akka.actor._
+
+import TypedActorSerialization._
+import Actor._
+import se.scalablesolutions.akka.remote.{RemoteClient, RemoteServer}
+import se.scalablesolutions.akka.actor.remote.ServerInitiatedRemoteActorSpec.RemoteActorSpecActorUnidirectional
+
+@RunWith(classOf[JUnitRunner])
+class TypedActorSerializationSpec extends
+  Spec with
+  ShouldMatchers with
+  BeforeAndAfterAll {
+
+  var server1: RemoteServer = null
+  var typedActor: MyTypedActor = null
+
+  override def beforeAll = {
+    server1 = new RemoteServer().start("localhost", 9991)
+    typedActor = TypedActor.newInstance(classOf[MyTypedActor], classOf[MyTypedActorImpl], 1000)
+    server1.registerTypedActor("typed-actor-service", typedActor)
+    Thread.sleep(1000)
+  }
+
+  // make sure the servers shutdown cleanly after the test has finished
+  override def afterAll = {
+    try {
+      TypedActor.stop(typedActor)
+      server1.shutdown
+      RemoteClient.shutdownAll
+      Thread.sleep(1000)
+    } catch {
+      case e => ()
+    }
+  }
+
+  object MyTypedStatelessActorFormat extends StatelessActorFormat[MyStatelessTypedActorImpl]
+
+  class MyTypedActorFormat extends Format[MyTypedActorImpl] {
+    def fromBinary(bytes: Array[Byte], act: MyTypedActorImpl) = {
+      val p = Serializer.Protobuf.fromBinary(bytes, Some(classOf[ProtobufProtocol.Counter])).asInstanceOf[ProtobufProtocol.Counter]
+      act.count = p.getCount
+      act
+    }
+    def toBinary(ac: MyTypedActorImpl) =
+      ProtobufProtocol.Counter.newBuilder.setCount(ac.count).build.toByteArray
+  }
+
+  class MyTypedActorWithDualCounterFormat extends Format[MyTypedActorWithDualCounter] {
+    def fromBinary(bytes: Array[Byte], act: MyTypedActorWithDualCounter) = {
+      val p = Serializer.Protobuf.fromBinary(bytes, Some(classOf[ProtobufProtocol.DualCounter])).asInstanceOf[ProtobufProtocol.DualCounter]
+      act.count1 = p.getCount1
+      act.count2 = p.getCount2
+      act
+    }
+    def toBinary(ac: MyTypedActorWithDualCounter) =
+      ProtobufProtocol.DualCounter.newBuilder.setCount1(ac.count1).setCount2(ac.count2).build.toByteArray
+  }
+
+
+  describe("Serializable typed actor") {
+
+    it("should be able to serialize and de-serialize a stateless typed actor") {
+      val typedActor1 = TypedActor.newInstance(classOf[MyTypedActor], classOf[MyStatelessTypedActorImpl], 1000)
+      typedActor1.requestReply("hello") should equal("world")
+      typedActor1.requestReply("hello") should equal("world")
+
+      val bytes = toBinaryJ(typedActor1, MyTypedStatelessActorFormat)
+      val typedActor2: MyTypedActor = fromBinaryJ(bytes, MyTypedStatelessActorFormat)
+      typedActor2.requestReply("hello") should equal("world")
+    }
+
+    it("should be able to serialize and de-serialize a stateful typed actor") {
+      val typedActor1 = TypedActor.newInstance(classOf[MyTypedActor], classOf[MyTypedActorImpl], 1000)
+      typedActor1.requestReply("hello") should equal("world 1")
+      typedActor1.requestReply("scala") should equal("hello scala 2")
+
+      val f = new MyTypedActorFormat
+      val bytes = toBinaryJ(typedActor1, f)
+      val typedActor2: MyTypedActor = fromBinaryJ(bytes, f)
+      typedActor2.requestReply("hello") should equal("world 3")
+    }
+
+    it("should be able to serialize and de-serialize a stateful typed actor with compound state") {
+      val typedActor1 = TypedActor.newInstance(classOf[MyTypedActor], classOf[MyTypedActorWithDualCounter], 1000)
+      typedActor1.requestReply("hello") should equal("world 1 1")
+      typedActor1.requestReply("hello") should equal("world 2 2")
+
+      val f = new MyTypedActorWithDualCounterFormat
+      val bytes = toBinaryJ(typedActor1, f)
+      val typedActor2: MyTypedActor = fromBinaryJ(bytes, f)
+      typedActor2.requestReply("hello") should equal("world 3 3")
+    }
+
+    it("should be able to serialize a local yped actor ref to a remote typed actor ref proxy") {
+      val typedActor1 = TypedActor.newInstance(classOf[MyTypedActor], classOf[MyStatelessTypedActorImpl], 1000)
+      typedActor1.requestReply("hello") should equal("world")
+      typedActor1.requestReply("hello") should equal("world")
+
+      val bytes = RemoteTypedActorSerialization.toBinary(typedActor1)
+      val typedActor2: MyTypedActor = RemoteTypedActorSerialization.fromBinaryToRemoteTypedActorRef(bytes)
+      typedActor1.requestReply("hello") should equal("world")
+    }
+  }
+}
+
+
+trait MyTypedActor {
+  def requestReply(s: String) : String
+  def oneWay() : Unit
+}
+
+class MyTypedActorImpl extends TypedActor with MyTypedActor {
+  var count = 0
+
+  override def oneWay() {
+    println("got oneWay message")
+  }
+
+  override def requestReply(message: String) : String = {
+    count = count + 1
+    if (message == "hello") {
+      "world " + count
+    } else ("hello " + message + " " + count)
+  }
+}
+
+class MyTypedActorWithDualCounter extends TypedActor with MyTypedActor {
+  var count1 = 0
+  var count2 = 0
+
+  override def oneWay() {
+    println("got oneWay message")
+  }
+
+  override def requestReply(message: String) : String = {
+    count1 = count1 + 1
+    count2 = count2 + 1
+
+    if (message == "hello") {
+      "world " + count1 + " " + count2
+    } else ("hello " + message + " " + count1 + " " + count2)
+  }
+}
+
+class MyStatelessTypedActorImpl extends TypedActor with MyTypedActor {
+
+  override def oneWay() {
+    println("got oneWay message")
+  }
+
+  override def requestReply(message: String) : String = {
+    if (message == "hello") "world" else ("hello " + message)
+  }
+}
diff --git a/akka-typed-actor/src/main/scala/actor/TypedActor.scala b/akka-typed-actor/src/main/scala/actor/TypedActor.scala
index c3457cb43b..f6cf2e2337 100644
--- a/akka-typed-actor/src/main/scala/actor/TypedActor.scala
+++ b/akka-typed-actor/src/main/scala/actor/TypedActor.scala
@@ -390,11 +390,22 @@ object TypedActor extends Logging {
     if (config._messageDispatcher.isDefined) actorRef.dispatcher = config._messageDispatcher.get
     if (config._threadBasedDispatcher.isDefined) actorRef.dispatcher = Dispatchers.newThreadBasedDispatcher(actorRef)
     if (config._host.isDefined) actorRef.makeRemote(config._host.get)
+    actorRef.timeout = config.timeout
     AspectInitRegistry.register(proxy, AspectInit(intfClass, typedActor, actorRef, config._host, config.timeout))
     actorRef.start
     proxy.asInstanceOf[T]
   }
 
+  private[akka] def newInstance[T](intfClass: Class[T], actorRef: ActorRef): T = {
+    if (!actorRef.actorInstance.get.isInstanceOf[TypedActor]) throw new IllegalArgumentException("ActorRef is not a ref to a typed actor")
+    val typedActor = actorRef.actorInstance.get.asInstanceOf[TypedActor]
+    val proxy = Proxy.newInstance(Array(intfClass), Array(typedActor), true, false)
+    typedActor.initialize(proxy)
+    AspectInitRegistry.register(proxy, AspectInit(intfClass, typedActor, actorRef, actorRef.remoteAddress, actorRef.timeout))
+    actorRef.start
+    proxy.asInstanceOf[T]
+  }
+
   private[akka] def newInstance[T](intfClass: Class[T], targetClass: Class[_],
                                    remoteAddress: Option[InetSocketAddress], timeout: Long): T = {
     val actorRef = actorOf(newTypedActor(targetClass))