diff --git a/akka-channels-tests/src/test/scala/akka/channels/ChannelSpec.scala b/akka-channels-tests/src/test/scala/akka/channels/ChannelSpec.scala
index c7828e50a6..088dceeeca 100644
--- a/akka-channels-tests/src/test/scala/akka/channels/ChannelSpec.scala
+++ b/akka-channels-tests/src/test/scala/akka/channels/ChannelSpec.scala
@@ -43,19 +43,19 @@ object ChannelSpec {
   object D extends D
 
   // used for sender verification in the first two test cases
-  class Tester extends Channels[TNil, (A, C) :+: (B, D) :+: TNil] {
+  class Tester extends Actor with Channels[TNil, (A, C) :+: (B, D) :+: TNil] {
     channel[A.type] { (msg, snd) ⇒ snd <-!- C }
     channel[A] { (msg, snd) ⇒ snd <-!- C1 }
     channel[B] {
       case (B, s) ⇒ s <-!- D
     }
   }
-  class RecvC(ref: ActorRef) extends Channels[TNil, (C, Nothing) :+: TNil] {
+  class RecvC(ref: ActorRef) extends Actor with Channels[TNil, (C, Nothing) :+: TNil] {
     channel[C] { case (x, _) ⇒ ref ! x }
   }
 
   // pos compile test for multiple reply channels
-  class SubChannels extends Channels[TNil, (A, B) :+: (A, C) :+: TNil] {
+  class SubChannels extends Actor with Channels[TNil, (A, B) :+: (A, C) :+: TNil] {
     channel[A] {
       case (A1, x) ⇒ B -!-> x
       case (_, x)  ⇒ x <-!- C
@@ -63,8 +63,8 @@ object ChannelSpec {
   }
 
   // pos compile test for children
-  class Children extends Channels[TNil, (A, B) :+: (C, Nothing) :+: TNil] {
-    val c = createChild(new Channels[(A, Nothing) :+: TNil, (B, C) :+: TNil] {
+  class Children extends Actor with Channels[TNil, (A, B) :+: (C, Nothing) :+: TNil] {
+    val c = createChild(new Actor with Channels[(A, Nothing) :+: TNil, (B, C) :+: TNil] {
       channel[B] { case (B, s) ⇒ s <-!- C }
     })
 
@@ -76,12 +76,12 @@ object ChannelSpec {
       case (C, _) ⇒ client ! C
     }
 
-    createChild(new Channels[(C, Nothing) :+: TNil, TNil] {})
-    createChild(new Channels[(A, Nothing) :+:(C, Nothing) :+: TNil, TNil] {})
+    createChild(new Actor with Channels[(C, Nothing) :+: TNil, TNil] {})
+    createChild(new Actor with Channels[(A, Nothing) :+:(C, Nothing) :+: TNil, TNil] {})
   }
 
   // compile test for polymorphic actors
-  class WriteOnly[T1: ru.TypeTag, T2: ru.TypeTag](target: ChannelRef[(T1, T2) :+: TNil]) extends Channels[TNil, (D, D) :+: (T1, T2) :+: TNil] {
+  class WriteOnly[T1: ru.TypeTag, T2: ru.TypeTag](target: ChannelRef[(T1, T2) :+: TNil]) extends Actor with Channels[TNil, (D, D) :+: (T1, T2) :+: TNil] {
     implicit val t = Timeout(1.second)
     import akka.pattern.ask
 
@@ -91,7 +91,7 @@ object ChannelSpec {
   }
 
   // compile test for whole-channel polymorphism
-  class Poly[T <: ChannelList: ru.TypeTag](target: ChannelRef[T]) extends Channels[TNil, (A, A) :+: (B, B) :+: T] {
+  class Poly[T <: ChannelList: ru.TypeTag](target: ChannelRef[T]) extends Actor with Channels[TNil, (A, A) :+: (B, B) :+: T] {
     implicit val timeout = Timeout(1.second)
     channel[T] { (x, snd) ⇒
       val xx: WrappedMessage[T, Any] = x
@@ -107,11 +107,11 @@ object ChannelSpec {
   }
 
   // companion to WriteOnly for testing pass-through
-  class EchoTee(target: ActorRef) extends Channels[TNil, (C, C) :+: TNil] {
+  class EchoTee(target: ActorRef) extends Actor with Channels[TNil, (C, C) :+: TNil] {
     channel[C] { (c, snd) ⇒ target ! C1; snd <-!- C1 }
   }
 
-  class MissingChannel extends Channels[TNil, (A, A) :+: (B, B) :+: TNil] {
+  class MissingChannel extends Actor with Channels[TNil, (A, A) :+: (B, B) :+: TNil] {
     channel[A.type] { (_, _) ⇒ }
   }
 
@@ -123,7 +123,7 @@ class ChannelSpec extends AkkaSpec(ActorSystem("ChannelSpec", AkkaSpec.testConf,
 
   implicit val selfChannel = new ChannelRef[(Any, Nothing) :+: TNil](testActor)
 
-  "Channels" must {
+  "Actor with Channels" must {
 
     "construct refs" in {
       val ref = ChannelExt(system).actorOf(new Tester)
@@ -231,7 +231,7 @@ class ChannelSpec extends AkkaSpec(ActorSystem("ChannelSpec", AkkaSpec.testConf,
         eval("""
             |import akka.channels._
             |import ChannelSpec._
-            |new Channels[TNil, (A, B) :+: TNil] {
+            |new Actor with Channels[TNil, (A, B) :+: TNil] {
             |  channel[B] {
             |    case (B, _) =>
             |  }
@@ -245,7 +245,7 @@ class ChannelSpec extends AkkaSpec(ActorSystem("ChannelSpec", AkkaSpec.testConf,
         eval("""
             |import akka.channels._
             |import ChannelSpec._
-            |new Channels[TNil, (A, B) :+: (A1.type, C) :+: TNil] {
+            |new Actor with Channels[TNil, (A, B) :+: (A1.type, C) :+: TNil] {
             |  channel[A] {
             |    case (A1, x) => x <-!- C
             |  }
@@ -258,9 +258,10 @@ class ChannelSpec extends AkkaSpec(ActorSystem("ChannelSpec", AkkaSpec.testConf,
       intercept[ToolBoxError] {
         eval("""
             |import akka.channels._
+            |import akka.actor.Actor
             |import ChannelSpec._
-            |new Channels[TNil, (A, B) :+: (C, D) :+: TNil] {
-            |  createChild(new Channels[Nothing, Nothing] {})
+            |new Actor with Channels[TNil, (A, B) :+: (C, D) :+: TNil] {
+            |  createChild(new Actor with Channels[Nothing, Nothing] {})
             |}
             """.stripMargin)
       }.message must include("Parent argument must not be Nothing")
@@ -270,9 +271,10 @@ class ChannelSpec extends AkkaSpec(ActorSystem("ChannelSpec", AkkaSpec.testConf,
       intercept[ToolBoxError] {
         eval("""
             |import akka.channels._
+            |import akka.actor.Actor
             |import ChannelSpec._
-            |new Channels[TNil, (A, B) :+: (C, D) :+: TNil] {
-            |  createChild(new Channels[(B, Nothing) :+: TNil, TNil] {})
+            |new Actor with Channels[TNil, (A, B) :+: (C, D) :+: TNil] {
+            |  createChild(new Actor with Channels[(B, Nothing) :+: TNil, TNil] {})
             |}
             """.stripMargin)
       }.message must include("This actor cannot support a child requiring channels akka.channels.ChannelSpec.B")
@@ -285,8 +287,8 @@ class ChannelSpec extends AkkaSpec(ActorSystem("ChannelSpec", AkkaSpec.testConf,
     }
 
     "have a working parentChannel" in {
-      val parent = ChannelExt(system).actorOf(new Channels[TNil, (A, Nothing) :+: TNil] {
-        createChild(new Channels[(A, Nothing) :+: TNil, TNil] {
+      val parent = ChannelExt(system).actorOf(new Actor with Channels[TNil, (A, Nothing) :+: TNil] {
+        createChild(new Actor with Channels[(A, Nothing) :+: TNil, TNil] {
           parentChannel <-!- A
         })
         channel[A] { (msg, snd) ⇒ testActor ! msg }
@@ -294,12 +296,12 @@ class ChannelSpec extends AkkaSpec(ActorSystem("ChannelSpec", AkkaSpec.testConf,
       expectMsg(A)
     }
 
-    "not permit top-level Channels which send to parent" in {
+    "not permit top-level Actor with Channels which send to parent" in {
       intercept[ToolBoxError] {
         eval("""
             |import akka.channels._
             |import ChannelSpec._
-            |null.asInstanceOf[ChannelExtension].actorOf(new Channels[(A, A) :+: TNil, (A, Nothing) :+: TNil] {})
+            |null.asInstanceOf[ChannelExtension].actorOf(new Actor with Channels[(A, A) :+: TNil, (A, Nothing) :+: TNil] {})
             """.stripMargin)
       }.message must include("type mismatch")
     }
@@ -309,8 +311,8 @@ class ChannelSpec extends AkkaSpec(ActorSystem("ChannelSpec", AkkaSpec.testConf,
         eval("""
             |import akka.channels._
             |import ChannelSpec._
-            |new Channels[TNil, (A, Nothing) :+: TNil] {
-            |  createChild(new Channels[(A, Nothing) :+: TNil, TNil] {
+            |new Actor with Channels[TNil, (A, Nothing) :+: TNil] {
+            |  createChild(new Actor with Channels[(A, Nothing) :+: TNil, TNil] {
             |    parentChannel <-!- B
             |  })
             |}
@@ -400,7 +402,7 @@ class ChannelSpec extends AkkaSpec(ActorSystem("ChannelSpec", AkkaSpec.testConf,
       lastSender must be(wrap.actorRef)
     }
 
-    "allow wrapping of ChannelsRefs with replies" in {
+    "allow wrapping of Actor with ChannelsRefs with replies" in {
       val probe = TestProbe()
       val target = ChannelExt(system).actorOf(new EchoTee(probe.ref))
       val wrap = ChannelExt(system).actorOf(new WriteOnly[C, C](target))
@@ -429,7 +431,7 @@ class ChannelSpec extends AkkaSpec(ActorSystem("ChannelSpec", AkkaSpec.testConf,
         eval("""
             |import akka.channels._
             |import ChannelSpec._
-            |new Channels[TNil, (List[A], A) :+: (List[B], B) :+: TNil] {
+            |new Actor with Channels[TNil, (List[A], A) :+: (List[B], B) :+: TNil] {
             |  channel[List[A]] { (x, s) ⇒ }
             |  channel[List[B]] { (x, s) ⇒ }
             |}
@@ -458,7 +460,7 @@ class ChannelSpec extends AkkaSpec(ActorSystem("ChannelSpec", AkkaSpec.testConf,
     }
 
     "be able to forward fully generic channels" in {
-      val cd = ChannelExt(system).actorOf(new Channels[TNil, (C, D) :+: TNil] {
+      val cd = ChannelExt(system).actorOf(new Actor with Channels[TNil, (C, D) :+: TNil] {
         channel[C] { (x, snd) ⇒ snd <-!- D }
       })
       val t = ChannelExt(system).actorOf(new Poly(cd))
@@ -474,7 +476,7 @@ class ChannelSpec extends AkkaSpec(ActorSystem("ChannelSpec", AkkaSpec.testConf,
   "A WrappedMessage" must {
 
     "be sendable to a ChannelRef" in {
-      implicit val selfChannel = ChannelExt(system).actorOf(new Channels[TNil, (C, Nothing) :+:(D, Nothing) :+: TNil] {
+      implicit val selfChannel = ChannelExt(system).actorOf(new Actor with Channels[TNil, (C, Nothing) :+:(D, Nothing) :+: TNil] {
         channel[C] { (c, snd) ⇒ testActor ! c }
         channel[D] { (d, snd) ⇒ testActor ! d }
       })
diff --git a/akka-channels/src/main/scala/akka/channels/ChannelExtension.scala b/akka-channels/src/main/scala/akka/channels/ChannelExtension.scala
index 3a610c8933..fa48af3779 100644
--- a/akka-channels/src/main/scala/akka/channels/ChannelExtension.scala
+++ b/akka-channels/src/main/scala/akka/channels/ChannelExtension.scala
@@ -11,6 +11,7 @@ import scala.reflect.runtime.universe._
 import akka.actor.Props
 import scala.reflect.ClassTag
 import scala.reflect.runtime.universe
+import akka.actor.Actor
 
 object ChannelExt extends ExtensionKey[ChannelExtension]
 
@@ -19,6 +20,6 @@ class ChannelExtension(system: ExtendedActorSystem) extends Extension {
   // kick-start the universe (needed due to thread safety issues in runtime mirror)
   private val t = typeTag[(Int, Int) :+: TNil]
 
-  def actorOf[Ch <: ChannelList](factory: ⇒ Channels[TNil, Ch]): ChannelRef[Ch] =
+  def actorOf[Ch <: ChannelList](factory: ⇒ Actor with Channels[TNil, Ch]): ChannelRef[Ch] =
     new ChannelRef[Ch](system.actorOf(Props(factory)))
 }
diff --git a/akka-channels/src/main/scala/akka/channels/Channels.scala b/akka-channels/src/main/scala/akka/channels/Channels.scala
index e3bc14ccbd..3eb0943ab5 100644
--- a/akka-channels/src/main/scala/akka/channels/Channels.scala
+++ b/akka-channels/src/main/scala/akka/channels/Channels.scala
@@ -40,7 +40,7 @@ import akka.actor.ActorInitializationException
  *    erased type, which may be less precise than the actual channel type; this
  *    can lead to ClassCastExceptions if sending through the untyped ActorRef
  */
-trait Channels[P <: ChannelList, C <: ChannelList] extends Actor {
+trait Channels[P <: ChannelList, C <: ChannelList] { this: Actor ⇒
 
   import macros.Helpers._
 
@@ -49,7 +49,7 @@ trait Channels[P <: ChannelList, C <: ChannelList] extends Actor {
    * actor can handle everything which the child tries to send via its
    * `parent` ChannelRef.
    */
-  def createChild[Pa <: ChannelList, Ch <: ChannelList](factory: Channels[Pa, Ch]): ChannelRef[Ch] = macro macros.CreateChild.impl[C, Pa, Ch]
+  def createChild[Pa <: ChannelList, Ch <: ChannelList](factory: Actor with Channels[Pa, Ch]): ChannelRef[Ch] = macro macros.CreateChild.impl[C, Pa, Ch]
 
   /**
    * Properly typed ChannelRef for the context.parent.
diff --git a/akka-channels/src/main/scala/akka/channels/macros/CreateChild.scala b/akka-channels/src/main/scala/akka/channels/macros/CreateChild.scala
index 1d38f4c52c..0f1d4ba7b0 100644
--- a/akka-channels/src/main/scala/akka/channels/macros/CreateChild.scala
+++ b/akka-channels/src/main/scala/akka/channels/macros/CreateChild.scala
@@ -6,14 +6,15 @@ import ru.TypeTag
 import scala.reflect.macros.Context
 import scala.reflect.api.Universe
 import akka.actor.Props
+import akka.actor.Actor
 
 object CreateChild {
   import Helpers._
 
   def impl[MyChannels <: ChannelList: c.WeakTypeTag, ParentChannels <: ChannelList: c.WeakTypeTag, ChildChannels <: ChannelList: c.WeakTypeTag](
     c: Context {
-      type PrefixType = Channels[_, MyChannels]
-    })(factory: c.Expr[Channels[ParentChannels, ChildChannels]]): c.Expr[ChannelRef[ChildChannels]] = {
+      type PrefixType = Actor with Channels[_, MyChannels]
+    })(factory: c.Expr[Actor with Channels[ParentChannels, ChildChannels]]): c.Expr[ChannelRef[ChildChannels]] = {
 
     import c.universe._