diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -7,4 +7,10 @@
 ## 0.2.0.0 (2020-07-29)
 
 * Lifted the restriction that one handler can exactly handle one effect. Handlers can now handle multiple effects.
-* Effects whose definitions refer to other effects (see the RWS effect, for example) are now possible to implement, but only manually for now (i.e., no code generation).
+* Effects whose definitions refer to other effects (see the RWS effect, for example) are now possible to implement, but only manually for now (i.e., no code generation).
+
+## 0.3.0.0 (2020-10-13)
+
+* Adapted the embed effect which now supports tagging/retagging/untagging.
+* Introduced the managed effect.
+* Relaxed bounds a bit for better compilation.
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -108,7 +108,7 @@
 newtype LocalFS m a =
   LocalFS { runLocalFS :: m a }
     deriving (Applicative, Functor, Monad, MonadIO)
-    deriving (MonadTrans, MonadTransControl) via Default
+    deriving (MonadTrans, MonadTransControl) via IdentityT
     deriving (MonadBase b, MonadBaseControl b)
 ```
 
@@ -142,7 +142,7 @@
 newtype VirtualFS m a =
   VirtualFS { runVirtualFS :: m a }
     deriving (Applicative, Functor, Monad, MonadIO)
-    deriving (MonadTrans, MonadTransControl) via Default
+    deriving (MonadTrans, MonadTransControl) via IdentityT
     deriving (MonadBase b, MonadBaseControl b)
 
 instance Map' tag FilePath String m => FileSystem' tag (VirtualFS m) where
diff --git a/effet.cabal b/effet.cabal
--- a/effet.cabal
+++ b/effet.cabal
@@ -4,10 +4,10 @@
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: 397bba600623b58701020a4ec01a2dff5e707d155f8f98e84f63423537604919
+-- hash: df92fee8597297b24a1a0e0ac46f0b028382ad585bd69cc307e0701203bd4502
 
 name:           effet
-version:        0.2.0.0
+version:        0.3.0.0
 synopsis:       An Effect System based on Type Classes
 description:    Please see the README on GitHub at <https://github.com/typedbyte/effet#readme>
 category:       Control
@@ -33,10 +33,10 @@
       Control.Effect.Embed
       Control.Effect.Error
       Control.Effect.Machinery
-      Control.Effect.Machinery.Default
       Control.Effect.Machinery.Tagger
       Control.Effect.Machinery.TH
       Control.Effect.Machinery.Via
+      Control.Effect.Managed
       Control.Effect.Map
       Control.Effect.Map.Lazy
       Control.Effect.Map.Strict
@@ -61,7 +61,7 @@
       base >=4.7 && <5
     , containers >=0.6.2.1 && <0.7
     , monad-control >=1.0.2.3 && <1.1
-    , template-haskell >=2.15.0.0 && <2.16
+    , template-haskell >=2.14.0.0 && <3
     , transformers >=0.5.6.2 && <0.6
     , transformers-base >=0.4.5.2 && <0.5
   default-language: Haskell2010
diff --git a/src/Control/Effect/Embed.hs b/src/Control/Effect/Embed.hs
--- a/src/Control/Effect/Embed.hs
+++ b/src/Control/Effect/Embed.hs
@@ -11,32 +11,77 @@
 -- The embed effect for integrating arbitrary monads into the effect system.
 -----------------------------------------------------------------------------
 module Control.Effect.Embed
-  ( -- * Embed Effect
-    Embed(..)
+  ( -- * Tagged Embed Effect
+    Embed'(..)
+    -- * Untagged Embed Effect
+    -- | If you don't require disambiguation of multiple embed effects
+    -- (i.e., you only have one embed effect in your monadic context),
+    -- it is recommended to always use the untagged embed effect.
+  , Embed
+  , embed
     -- * Interpretations
+    -- ** Via Transformation
   , Transformation
+  , runEmbed'
   , runEmbed
+    -- ** Via Finalization
+  , Finalization
+  , runFinal'
+  , runFinal
+    -- * Tagging and Untagging
+    -- | Conversion functions between the tagged and untagged embed effect,
+    -- usually used in combination with type applications, like:
+    --
+    -- @
+    --     'tagEmbed'' \@\"newTag\" program
+    --     'retagEmbed'' \@\"oldTag\" \@\"newTag\" program
+    --     'untagEmbed'' \@\"erasedTag\" program
+    -- @
+    -- 
+  , tagEmbed'
+  , retagEmbed'
+  , untagEmbed'
   ) where
 
+-- base
+import Data.Coerce           (coerce)
+import Data.Functor.Identity (Identity)
+
 -- transformers
 import Control.Monad.Trans.Reader (ReaderT(ReaderT), runReaderT)
 
 import Control.Effect.Machinery hiding (embed)
 
 -- | An effect that integrates a monad @n@ into the computation @m@.
-class Monad m => Embed n m where
+--
+-- @since 0.3.0.0
+class Monad m => Embed' tag n m | tag m -> n where
   -- | Monadic actions in @n@ can be lifted into @m@ via 'embed'.
   --
   -- 'embed' is like 'liftIO', but not limited to 'IO'. In fact, 'liftIO' can
   -- be realized using 'embed' by specializing @n@ to @IO@.
-  embed :: n a -> m a
+  --
+  -- @since 0.3.0.0
+  embed' :: n a -> m a
 
-makeEffect ''Embed
+makeTaggedEffect ''Embed'
 
-instance Monad m => Embed m m where
-  embed = id
-  {-# INLINE embed #-}
+instance Embed' tag IO IO where
+  embed' = id
+  {-# INLINE embed' #-}
 
+instance Embed' tag Maybe Maybe where
+  embed' = id
+  {-# INLINE embed' #-}
+
+instance Embed' tag [] [] where
+  embed' = id
+  {-# INLINE embed' #-}
+
+instance Embed' tag Identity Identity where
+  embed' = id
+  {-# INLINE embed' #-}
+
 newtype F n t = F (forall b. n b -> t b)
 
 -- | The transformation interpreter of the embed effect. This type implements the
@@ -51,15 +96,60 @@
     deriving (MonadTrans, MonadTransControl)
     deriving (MonadBase b, MonadBaseControl b)
 
-instance Embed t m => Embed n (Transformation n t m) where
-  embed na = Transformation . ReaderT $
-    \(F f) -> embed (f na)
-  {-# INLINE embed #-}
+instance Embed' tag t m => Embed' tag n (Transformation n t m) where
+  embed' na = Transformation . ReaderT $
+    \(F f) -> embed' @tag (f na)
+  {-# INLINE embed' #-}
 
 -- | Runs the embed effect by transforming the integrated monad @n@ into another
 -- integrated monad @t@.
-runEmbed :: (forall b. n b -> t b)                 -- ^ The natural transformation from monad @n@ to monad @t@.
-         -> (Embed n `Via` Transformation n t) m a -- ^ The program whose embed effect should be handled.
-         -> m a                                    -- ^ The program with its embed effect handled.
-runEmbed f = flip runReaderT (F f) . runTransformation . runVia
+--
+-- @since 0.3.0.0
+runEmbed' :: forall tag n t m a
+           . (forall b. n b -> t b)                      -- ^ The natural transformation from monad @n@ to monad @t@.
+          -> (Embed' tag n `Via` Transformation n t) m a -- ^ The program whose embed effect should be handled.
+          -> m a                                         -- ^ The program with its embed effect handled.
+runEmbed' f = flip runReaderT (F f) . runTransformation . runVia
+{-# INLINE runEmbed' #-}
+
+-- | The untagged version of 'runEmbed''.
+runEmbed :: (forall b. n b -> t b) -> (Embed n `Via` Transformation n t) m a -> m a
+runEmbed = runEmbed' @G
 {-# INLINE runEmbed #-}
+
+-- | The finalization interpreter of the embed effect. This type implements the
+-- 'Embed' type class by declaring the integrated monad the final monad @m@
+-- (also called the \"base monad\").
+--
+-- Chances are very high that you only need this interpreter if you have a
+-- custom final monad because the 'Embed'' effect is already implemented for
+-- final monads like 'IO', 'Maybe', @[]@ and 'Identity'.
+--
+-- When interpreting the effect, you usually don\'t interact with this type directly,
+-- but instead use one of its corresponding interpretation functions.
+--
+-- @since 0.3.0.0
+newtype Finalization m a =
+  Finalization { _runFinalization :: m a }
+    deriving (Applicative, Functor, Monad, MonadIO)
+    deriving (MonadTrans, MonadTransControl) via IdentityT
+    deriving (MonadBase b, MonadBaseControl b)
+
+instance Monad n => Embed' tag n (Finalization n) where
+  embed' = Finalization
+  {-# INLINE embed' #-}
+
+-- | Runs the embed effect by declaring the integrated monad the final monad.
+--
+-- @since 0.3.0.0
+runFinal' :: (Embed' tag m `Via` Finalization) m a -- ^ The program whose embed effect should be handled.
+          -> m a                                   -- ^ The program with its embed effect handled.
+runFinal' = coerce
+{-# INLINE runFinal' #-}
+
+-- | The untagged version of 'runFinal''.
+--
+-- @since 0.3.0.0
+runFinal :: (Embed m `Via` Finalization) m a -> m a
+runFinal = runFinal' @G
+{-# INLINE runFinal #-}
diff --git a/src/Control/Effect/Machinery.hs b/src/Control/Effect/Machinery.hs
--- a/src/Control/Effect/Machinery.hs
+++ b/src/Control/Effect/Machinery.hs
@@ -13,8 +13,7 @@
 -----------------------------------------------------------------------------
 module Control.Effect.Machinery
   ( -- * Re-exports from @effet@
-    module Control.Effect.Machinery.Default
-  , module Control.Effect.Machinery.Tagger
+    module Control.Effect.Machinery.Tagger
   , module Control.Effect.Machinery.TH
   , module Control.Effect.Machinery.Via
     -- * Re-exports from @base@
@@ -23,6 +22,7 @@
   , module Control.Monad.Trans.Control
     -- * Re-exports from @transformers@
   , module Control.Monad.Trans.Class
+  , module Control.Monad.Trans.Identity
     -- * Re-exports from @transformers-base@
   , module Control.Monad.Base
   ) where
@@ -31,15 +31,15 @@
 import Control.Monad.IO.Class
 
 -- monad-control
-import Control.Monad.Trans.Control -- hiding (embed)
+import Control.Monad.Trans.Control
 
 -- transformers
 import Control.Monad.Trans.Class
+import Control.Monad.Trans.Identity
 
 -- transformers-base
 import Control.Monad.Base
 
-import Control.Effect.Machinery.Default
 import Control.Effect.Machinery.Tagger
 import Control.Effect.Machinery.TH
 import Control.Effect.Machinery.Via
diff --git a/src/Control/Effect/Machinery/Default.hs b/src/Control/Effect/Machinery/Default.hs
deleted file mode 100644
--- a/src/Control/Effect/Machinery/Default.hs
+++ /dev/null
@@ -1,54 +0,0 @@
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Effect.Machinery.Default
--- Copyright   :  (c) Michael Szvetits, 2020
--- License     :  BSD3 (see the file LICENSE)
--- Maintainer  :  typedbyte@qualified.name
--- Stability   :  stable
--- Portability :  portable
---
--- This module provides default implementations for the 'MonadTrans' and
--- 'MonadTransControl' type classes.
------------------------------------------------------------------------------
-module Control.Effect.Machinery.Default (Default(..)) where
-
--- base
-import Control.Monad.IO.Class (MonadIO)
-
--- monad-control
-import Control.Monad.Trans.Control (MonadBaseControl, MonadTransControl, StT,
-                                    liftWith, restoreT)
-
--- transformers
-import Control.Monad.Trans.Class (MonadTrans, lift)
-
--- transformers-base
-import Control.Monad.Base (MonadBase)
-
--- | This type provides default implementations for the 'MonadTrans' and
--- 'MonadTransControl' type classes. The type is intended to be targeted by the
--- @DerivingVia@ language extension when writing an effect handler newtype that
--- wraps a monad @m a@ :
---
--- @
---     newtype MyHandler m a =
---       MyHandler { runMyHandler :: m a }
---         deriving (Applicative, Functor, Monad, MonadIO)
---         deriving (MonadTrans, MonadTransControl) via 'Default'
---         deriving (MonadBase b, MonadBaseControl b)
--- @
-newtype Default m a =
-  Default { runDefault :: m a }
-    deriving (Applicative, Functor, Monad, MonadIO)
-    deriving (MonadBase b, MonadBaseControl b)
-
-instance MonadTrans Default where
-  lift = Default
-  {-# INLINE lift #-}
-
-instance MonadTransControl Default where
-  type StT Default a = a
-  liftWith f = Default (f runDefault)
-  {-# INLINE liftWith #-}
-  restoreT = Default
-  {-# INLINE restoreT #-}
diff --git a/src/Control/Effect/Machinery/Tagger.hs b/src/Control/Effect/Machinery/Tagger.hs
--- a/src/Control/Effect/Machinery/Tagger.hs
+++ b/src/Control/Effect/Machinery/Tagger.hs
@@ -19,13 +19,12 @@
 import Control.Monad.Trans.Control (MonadBaseControl, MonadTransControl)
 
 -- transformers
-import Control.Monad.Trans.Class (MonadTrans)
+import Control.Monad.Trans.Class    (MonadTrans)
+import Control.Monad.Trans.Identity (IdentityT(IdentityT))
 
 -- transformers-base
 import Control.Monad.Base (MonadBase)
 
-import Control.Effect.Machinery.Default (Default(Default))
-
 -- | This type provides instances for effect type classes in order to enable
 -- tagging, retagging and untagging of effects. Whenever this type is used as
 -- handler of an effect, the effect previously tagged with @tag@ will be
@@ -37,5 +36,5 @@
 newtype Tagger tag new m a =
   Tagger { runTagger :: m a }
     deriving (Applicative, Functor, Monad, MonadIO)
-    deriving (MonadTrans, MonadTransControl) via Default
+    deriving (MonadTrans, MonadTransControl) via IdentityT
     deriving (MonadBase b, MonadBaseControl b)
diff --git a/src/Control/Effect/Machinery/Via.hs b/src/Control/Effect/Machinery/Via.hs
--- a/src/Control/Effect/Machinery/Via.hs
+++ b/src/Control/Effect/Machinery/Via.hs
@@ -1,141 +1,141 @@
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Effect.Machinery.Via
--- Copyright   :  (c) Michael Szvetits, 2020
--- License     :  BSD3 (see the file LICENSE)
--- Maintainer  :  typedbyte@qualified.name
--- Stability   :  stable
--- Portability :  portable
---
--- This module defines the types 'EachVia' and its corresponding type synonym
--- 'Via' which indicate that specific effects are handled by a specific monad
--- transformer (also known as effect handler or effect interpreter).
---
--- It also defines the 'G' type, which is the global tag that is used for
--- untagged effects.
--- 
--- Last but not least, it defines some constraint synonyms and kinds that are
--- used throughout this library, hopefully to increase the readability of the
--- code at some points.
------------------------------------------------------------------------------
-module Control.Effect.Machinery.Via
-  ( -- * Core Types
-    EachVia(..)
-  , Via
-  , G
-    -- * Constraint Synonyms and Kinds
-  , SomeMonad
-  , Effect
-  , Transformer
-  , Handle
-  , Find
-  , Lift
-  , Control
-  ) where
-
--- base
-import Control.Monad.IO.Class (MonadIO)
-import Data.Kind              (Constraint, Type)
-
--- monad-control
-import Control.Monad.Trans.Control (ComposeSt, MonadBaseControl,
-                                    MonadTransControl, StM, defaultLiftBaseWith,
-                                    defaultRestoreM,liftBaseWith, restoreM)
-
--- transformers
-import Control.Monad.Trans.Class (MonadTrans)
-
--- transformers-base
-import Control.Monad.Base (MonadBase, liftBase, liftBaseDefault)
-
--- | This type indicates that the effects (i.e., type classes) @effs@ are handled by
--- a specific monad transformer @t@. The type is a simple wrapper around the
--- monad transformer itself. The whole purpose of this type is to guide the type
--- system to pick the instances of type classes @effs@ given by the type @t@, and
--- to delegate all other effects that are not in @effs@ to their handlers which are
--- located somewhere further down the monad transformer stack.
---
--- @since 0.2.0.0
-newtype EachVia (effs :: [Effect]) (t :: Transformer) m a =
-  EachVia { runVia :: t m a }
-    deriving (Applicative, Functor, Monad, MonadIO)
-    deriving (MonadTrans, MonadTransControl)
-
-instance (Monad (t m), MonadBase b m, MonadTrans t) => MonadBase b (EachVia effs t m) where
-  liftBase = liftBaseDefault
-  {-# INLINE liftBase #-}
-
-instance (Monad (t m), MonadBaseControl b m, MonadTransControl t) => MonadBaseControl b (EachVia effs t m) where
-  type StM (EachVia effs t m) a = ComposeSt t m a
-  liftBaseWith = defaultLiftBaseWith
-  {-# INLINE liftBaseWith #-}
-  restoreM = defaultRestoreM
-  {-# INLINE restoreM #-}
-
--- | This type synonym can be used to indicate that a single effect @eff@ is
--- handled by a specific monad transformer @t@.
---
--- @since 0.2.0.0
-type Via eff t m a = EachVia '[eff] t m a
-
--- | This type is used as tag for all untagged effects. In order words, every
--- effect is tagged, even untagged ones, but all the untagged ones simply have
--- the same tag @G@ (short for \"Global\", because you can view tags as some
--- kind of namespace mechanism, and all untagged effects live in the same
--- global namespace).
---
--- If you don\'t want to use tagged effects (i.e., you write effect type classes
--- without a tag type parameter), you can ignore this type completely.
-data G
-
--- | The kind of monads.
-type SomeMonad = Type -> Type
-
--- | The kind of effects, which are type classes with a monad type parameter at
--- the end.
-type Effect = SomeMonad -> Constraint
-
--- | The kind of monad transformers, also known as effect handlers or effect
--- interpreters.
-type Transformer = SomeMonad -> Type -> Type
-
--- | This type synonym indicates that an effect is handled by a specific monad
--- transformer.
-type Handle (eff :: Effect) (t :: Transformer) m =
-  eff (t m)
-
--- | This type synonym indicates that an effect @eff@ is not at the head of the
--- type level list of effects to be handled, so the effect must be found further
--- down in the tail @effs@.
---
--- @since 0.2.0.0
-type Find eff effs t m = (Monad (t m), eff (EachVia effs t m))
-
--- | This constraint synonym indicates that a first-order effect is not handled
--- by a specific monad transformer and must thus be delegated (\"lifted\")
--- further down the monad transformer stack in order to find its associated
--- handler.
---
--- Roughly speaking, a first-order effect is a type class whose monad type
--- parameter @m@ appears only in positive position when looking at the types of
--- its corresponding class methods (e.g., @m@ appears only in the result type).
---
--- An example of a first-order effect is the 'Control.Effect.State.State'' effect.
-type Lift (eff :: Effect) (t :: Transformer) m =
-  (eff m, Monad (t m), MonadTrans t)
-
--- | This constraint synonym indicates that a higher-order effect is not handled
--- by a specific monad transformer and must thus be delegated (\"lifted\")
--- further down the monad transformer stack in order to find its associated
--- handler.
---
--- Roughly speaking, a higher-order effect is a type class whose monad type
--- parameter @m@ appears in negative position when looking at the types of its
--- corresponding class methods (e.g., @m@ appears in the type of a method
--- parameter).
---
--- An example of a higher-order effect is the 'Control.Effect.Reader.Reader'' effect,
--- since its class method 'Control.Effect.Reader.local'' has a parameter of
--- type @m a@.
-type Control (eff :: Effect) (t :: Transformer) m =
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Effect.Machinery.Via
+-- Copyright   :  (c) Michael Szvetits, 2020
+-- License     :  BSD3 (see the file LICENSE)
+-- Maintainer  :  typedbyte@qualified.name
+-- Stability   :  stable
+-- Portability :  portable
+--
+-- This module defines the types 'EachVia' and its corresponding type synonym
+-- 'Via' which indicate that specific effects are handled by a specific monad
+-- transformer (also known as effect handler or effect interpreter).
+--
+-- It also defines the 'G' type, which is the global tag that is used for
+-- untagged effects.
+-- 
+-- Last but not least, it defines some constraint synonyms and kinds that are
+-- used throughout this library, hopefully to increase the readability of the
+-- code at some points.
+-----------------------------------------------------------------------------
+module Control.Effect.Machinery.Via
+  ( -- * Core Types
+    EachVia(..)
+  , Via
+  , G
+    -- * Constraint Synonyms and Kinds
+  , SomeMonad
+  , Effect
+  , Transformer
+  , Handle
+  , Find
+  , Lift
+  , Control
+  ) where
+
+-- base
+import Control.Monad.IO.Class (MonadIO)
+import Data.Kind              (Constraint, Type)
+
+-- monad-control
+import Control.Monad.Trans.Control (ComposeSt, MonadBaseControl,
+                                    MonadTransControl, StM, defaultLiftBaseWith,
+                                    defaultRestoreM,liftBaseWith, restoreM)
+
+-- transformers
+import Control.Monad.Trans.Class (MonadTrans)
+
+-- transformers-base
+import Control.Monad.Base (MonadBase, liftBase, liftBaseDefault)
+
+-- | This type indicates that the effects (i.e., type classes) @effs@ are handled by
+-- a specific monad transformer @t@. The type is a simple wrapper around the
+-- monad transformer itself. The whole purpose of this type is to guide the type
+-- system to pick the instances of type classes @effs@ given by the type @t@, and
+-- to delegate all other effects that are not in @effs@ to their handlers which are
+-- located somewhere further down the monad transformer stack.
+--
+-- @since 0.2.0.0
+newtype EachVia (effs :: [Effect]) (t :: Transformer) m a =
+  EachVia { runVia :: t m a }
+    deriving (Applicative, Functor, Monad, MonadIO)
+    deriving (MonadTrans, MonadTransControl)
+
+instance (Monad (t m), MonadBase b m, MonadTrans t) => MonadBase b (EachVia effs t m) where
+  liftBase = liftBaseDefault
+  {-# INLINE liftBase #-}
+
+instance (Monad (t m), MonadBaseControl b m, MonadTransControl t) => MonadBaseControl b (EachVia effs t m) where
+  type StM (EachVia effs t m) a = ComposeSt t m a
+  liftBaseWith = defaultLiftBaseWith
+  {-# INLINE liftBaseWith #-}
+  restoreM = defaultRestoreM
+  {-# INLINE restoreM #-}
+
+-- | This type synonym can be used to indicate that a single effect @eff@ is
+-- handled by a specific monad transformer @t@.
+--
+-- @since 0.2.0.0
+type Via eff t m a = EachVia '[eff] t m a
+
+-- | This type is used as tag for all untagged effects. In order words, every
+-- effect is tagged, even untagged ones, but all the untagged ones simply have
+-- the same tag @G@ (short for \"Global\", because you can view tags as some
+-- kind of namespace mechanism, and all untagged effects live in the same
+-- global namespace).
+--
+-- If you don\'t want to use tagged effects (i.e., you write effect type classes
+-- without a tag type parameter), you can ignore this type completely.
+data G
+
+-- | The kind of monads.
+type SomeMonad = Type -> Type
+
+-- | The kind of effects, which are type classes with a monad type parameter at
+-- the end.
+type Effect = SomeMonad -> Constraint
+
+-- | The kind of monad transformers, also known as effect handlers or effect
+-- interpreters.
+type Transformer = SomeMonad -> Type -> Type
+
+-- | This constraint synonym indicates that an effect is handled by a specific monad
+-- transformer.
+type Handle (eff :: Effect) (t :: Transformer) m =
+  eff (t m)
+
+-- | This constraint synonym indicates that an effect @eff@ is not at the head of the
+-- type level list of effects to be handled, so the effect must be found further
+-- down in the tail @effs@.
+--
+-- @since 0.2.0.0
+type Find eff effs t m = (Monad (t m), eff (EachVia effs t m))
+
+-- | This constraint synonym indicates that a first-order effect is not handled
+-- by a specific monad transformer and must thus be delegated (\"lifted\")
+-- further down the monad transformer stack in order to find its associated
+-- handler.
+--
+-- Roughly speaking, a first-order effect is a type class whose monad type
+-- parameter @m@ appears only in positive position when looking at the types of
+-- its corresponding class methods (e.g., @m@ appears only in the result type).
+--
+-- An example of a first-order effect is the 'Control.Effect.State.State'' effect.
+type Lift (eff :: Effect) (t :: Transformer) m =
+  (eff m, Monad (t m), MonadTrans t)
+
+-- | This constraint synonym indicates that a higher-order effect is not handled
+-- by a specific monad transformer and must thus be delegated (\"lifted\")
+-- further down the monad transformer stack in order to find its associated
+-- handler.
+--
+-- Roughly speaking, a higher-order effect is a type class whose monad type
+-- parameter @m@ appears in negative position when looking at the types of its
+-- corresponding class methods (e.g., @m@ appears in the type of a method
+-- parameter).
+--
+-- An example of a higher-order effect is the 'Control.Effect.Reader.Reader'' effect,
+-- since its class method 'Control.Effect.Reader.local'' has a parameter of
+-- type @m a@.
+type Control (eff :: Effect) (t :: Transformer) m =
   (eff m, Monad (t m), MonadTransControl t)
diff --git a/src/Control/Effect/Managed.hs b/src/Control/Effect/Managed.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Effect/Managed.hs
@@ -0,0 +1,122 @@
+{-# LANGUAGE TemplateHaskell #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Effect.Managed
+-- Copyright   :  (c) Michael Szvetits, 2020
+-- License     :  BSD3 (see the file LICENSE)
+-- Maintainer  :  typedbyte@qualified.name
+-- Stability   :  stable
+-- Portability :  portable
+--
+-- The managed effect allows a computation to allocate resources which are
+-- guaranteed to be released after the end of the computation. This effect
+-- provides a monadic interface for managing one or more long-living
+-- resources in a more readable way than nesting 'IO.bracket'-style
+-- operations of the "Control.Effect.Resource" effect.
+-----------------------------------------------------------------------------
+module Control.Effect.Managed
+  ( -- * Tagged Managed Effect
+    Managed'(..)
+    -- * Untagged Managed Effect
+    -- | If you don't require disambiguation of multiple managed effects
+    -- (i.e., you only have one managed effect in your monadic context),
+    -- it is recommended to always use the untagged managed effect.
+  , Managed
+  , manage
+    -- * Interpretations
+  , Bracket
+  , runManaged'
+  , runManaged
+    -- * Tagging and Untagging
+    -- | Conversion functions between the tagged and untagged managed effect,
+    -- usually used in combination with type applications, like:
+    --
+    -- @
+    --     'tagManaged'' \@\"newTag\" program
+    --     'retagManaged'' \@\"oldTag\" \@\"newTag\" program
+    --     'untagManaged'' \@\"erasedTag\" program
+    -- @
+    -- 
+  , tagManaged'
+  , retagManaged'
+  , untagManaged'
+  ) where
+
+-- base
+import qualified Control.Exception as IO
+import Data.IORef (IORef, atomicModifyIORef', newIORef, readIORef)
+
+-- transformers
+import Control.Monad.Trans.Reader (ReaderT(ReaderT), runReaderT)
+
+import Control.Effect.Machinery
+
+-- | An effect that allows a computation to allocate resources which are
+-- guaranteed to be released after the computation.
+--
+-- @since 0.3.0.0
+class Monad m => Managed' tag m where
+  -- | Acquire a resource by specifying an acquisition action and a release
+  -- action to be used for cleanup after the computation.
+  --
+  -- @since 0.3.0.0
+  manage' :: m a        -- ^ The computation which acquires the resource.
+          -> (a -> m b) -- ^ The computation which releases the resource.
+          -> m a        -- ^ The acquired resource.
+
+makeTaggedEffect ''Managed'
+
+-- | The bracket-based interpreter of the managed effect. This type implements
+-- the 'Managed'' type class by using 'IO.bracket', thus requiring 'IO' at the
+-- bottom of the monad transformer stack.
+--
+-- When interpreting the effect, you usually don\'t interact with this type directly,
+-- but instead use one of its corresponding interpretation functions.
+--
+-- @since 0.3.0.0
+newtype Bracket n m a = Bracket { runBracket :: ReaderT (IORef [n ()]) m a }
+  deriving (Applicative, Functor, Monad, MonadIO)
+  deriving (MonadTrans, MonadTransControl)
+  deriving (MonadBase b, MonadBaseControl b)
+
+instance MonadBase IO m => Managed' tag (Bracket m m) where
+  manage' alloc free = Bracket . ReaderT $
+    \ref -> do
+      a <- runReaderT (runBracket alloc) ref
+      liftBase $
+        atomicModifyIORef' ref $
+          \frees -> (runReaderT (runBracket (free a >> pure ())) ref : frees, ())
+      pure a
+  {-# INLINE manage' #-}
+
+-- | Runs the managed effect using 'IO.bracket'.
+--
+-- @since 0.3.0.0
+runManaged' :: forall tag m a. MonadBaseControl IO m => (Managed' tag `Via` Bracket m) m a -> m a
+runManaged' program =
+  liftedBracket
+    ( allocRef )
+    ( freeRef  )
+    ( runReaderT (runBracket (runVia program)) )
+  where
+    allocRef :: forall n. MonadBase IO n => n (IORef [n ()])
+    allocRef = liftBase $ newIORef []
+    
+    freeRef :: forall n. MonadBase IO n => IORef [n ()] -> n ()
+    freeRef = (sequence_ =<<) . liftBase . readIORef
+    
+    liftedBracket :: forall n b c d. MonadBaseControl IO n => n b -> (b -> n c) -> (b -> n d) -> n d
+    liftedBracket alloc free use =
+      control $ \run ->
+        IO.bracket
+          ( run alloc )
+          ( \a -> run (restoreM a >>= free) )
+          ( \a -> run (restoreM a >>= use) )
+{-# INLINE runManaged' #-}
+
+-- | The untagged version of 'runManaged''.
+--
+-- @since 0.3.0.0
+runManaged :: MonadBaseControl IO m => (Managed `Via` Bracket m) m a -> m a
+runManaged = runManaged' @G
+{-# INLINE runManaged #-}
diff --git a/src/Control/Effect/RWS.hs b/src/Control/Effect/RWS.hs
--- a/src/Control/Effect/RWS.hs
+++ b/src/Control/Effect/RWS.hs
@@ -89,7 +89,7 @@
 newtype Separation m a =
   Separation { _runSeparation :: m a }
     deriving (Applicative, Functor, Monad, MonadIO)
-    deriving (MonadTrans, MonadTransControl) via Default
+    deriving (MonadTrans, MonadTransControl) via IdentityT
     deriving (MonadBase b, MonadBaseControl b)
     deriving (R.Reader' tag r, W.Writer' tag w, S.State' tag s)
 
@@ -120,7 +120,7 @@
 newtype Tagger tag new m a =
   Tagger { runRWSTagger :: m a }
     deriving (Applicative, Functor, Monad, MonadIO)
-    deriving (MonadTrans, MonadTransControl) via Default
+    deriving (MonadTrans, MonadTransControl) via IdentityT
     deriving (MonadBase b, MonadBaseControl b)
 
 instance RWS' new r w s m => RWS' tag r w s (Tagger tag new m)
diff --git a/src/Control/Effect/Resource.hs b/src/Control/Effect/Resource.hs
--- a/src/Control/Effect/Resource.hs
+++ b/src/Control/Effect/Resource.hs
@@ -113,7 +113,7 @@
 newtype LowerIO m a =
   LowerIO { _runLowerIO :: m a }
     deriving (Applicative, Functor, Monad, MonadIO)
-    deriving (MonadTrans, MonadTransControl) via Default
+    deriving (MonadTrans, MonadTransControl) via IdentityT
     deriving (MonadBase b, MonadBaseControl b)
 
 instance MonadBaseControl IO m => Resource' tag (LowerIO m) where