diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,10 @@
 # Changelog for free-category
 
+## Version 0.0.2.0
+
+- EffCategory class and FreeEffCat category transformer
+- Example usage of FreeEffCat
+
 ## Version 0.0.1.0
 - free category (concrete and condensity transformed)
 - free arrows (concrete and condensity transformed)
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,13 +1,24 @@
 # Free Category
 [![Maintainer: coot](https://img.shields.io/badge/maintainer-coot-lightgrey.svg)](http://github.com/coot)
-[![Travis Build Status](https://travis-ci.org/coot/free-category.svg?branch=master)](https://travis-ci.org/coot/free-category)
+[![CircleCI](https://circleci.com/gh/coot/free-category/tree/master.svg?style=svg)](https://circleci.com/gh/coot/free-category/tree/master)
 
-This package introduces variouos encodings of free categories in Haskell.
+This package introduces variouos presentations of free categories in Haskell.
 
 Free categories are useful to model state machines in a simple yet type safe
 way and for that purpose `Kleisli` categroies are a very useful target which
-allows to include monadic computations.  Read more
-[here](https://coot.me/posts/finite-state-machines.html) on a simple example of
-a finite state machine encoded using a free category using a simple GADT.
-Another simple
-[example](https://github.com/coot/free-algebras/blob/master/examples/src/Control/Category/Free.hs).
+allows to include monadic computations.  This packge contains a useful
+generalisation of `Kliesli` categories captured by `EffCategory` class
+(effectful categories), and a (free) transformer which lifts a category to
+an effectful one.
+
+## Some examples
+* [LoginStateMachine](https://github.com/coot/free-category/blob/master/examples/src/LoginStateMachine.hs):
+  based on [State Machines All The Way
+  Down](https://www.youtube.com/watch?v=xq7ZuSRgCR4) by Edwin Bradly, 2017 You
+  can run it with `cabal new-run examples:login-state-machine`.
+* Read more [here](https://coot.me/posts/finite-state-machines.html) on
+  a simple example of a finite state machine encoded using a free category
+  using a simple GADT.
+* Another
+  [example](https://github.com/coot/free-algebras/blob/master/examples/src/Control/Category/Free.hs).
+* [Blog post](https://coot.me/posts/kleisli-categories-and-free-monads.html) on Keleisli categories.
diff --git a/Setup.hs b/Setup.hs
deleted file mode 100644
--- a/Setup.hs
+++ /dev/null
@@ -1,2 +0,0 @@
-import Distribution.Simple
-main = defaultMain
diff --git a/free-category.cabal b/free-category.cabal
--- a/free-category.cabal
+++ b/free-category.cabal
@@ -1,5 +1,5 @@
 name:           free-category
-version:        0.0.1.0
+version:        0.0.2.0
 synopsis:       Free category
 description:    Free categories
 category:       Algebra, Control, Monads, Category
@@ -24,31 +24,32 @@
   exposed-modules:
       Control.Arrow.Free
       Control.Category.Free
+      Control.Category.FreeEff
   other-modules:
       Paths_free_category
   hs-source-dirs:
       src
   default-extensions:
-    ConstraintKinds
-    DataKinds
-    DeriveFunctor
-    EmptyDataDecls
-    FlexibleInstances
-    FlexibleContexts
-    GADTs
-    KindSignatures
-    InstanceSigs
-    MultiParamTypeClasses
-    OverloadedStrings
-    PolyKinds
-    RankNTypes
-    ScopedTypeVariables
-    TupleSections
-    TypeApplications
-    TypeFamilies
+      ConstraintKinds
+      DataKinds
+      DeriveFunctor
+      EmptyDataDecls
+      FlexibleInstances
+      FlexibleContexts
+      GADTs
+      KindSignatures
+      InstanceSigs
+      MultiParamTypeClasses
+      OverloadedStrings
+      PolyKinds
+      RankNTypes
+      ScopedTypeVariables
+      TupleSections
+      TypeApplications
+      TypeFamilies
   build-depends:
       base          >= 4.9 && <5
-    , free-algebras >= 0.0.6.0
+    , free-algebras >= 0.0.7.0
   ghc-options:
     -Wall
     -fwarn-incomplete-record-updates
diff --git a/src/Control/Category/Free.hs b/src/Control/Category/Free.hs
--- a/src/Control/Category/Free.hs
+++ b/src/Control/Category/Free.hs
@@ -37,8 +37,6 @@
 import           Data.Monoid (Monoid (..))
 import           Data.Semigroup (Semigroup (..))
 #endif
-import           Data.Monoid.MSet (MSet (..))
-import           Data.Semigroup.SSet (SSet (..))
 
 -- |
 -- Free category encoded as a recursive data type, in a simlar way as
@@ -49,7 +47,7 @@
 --
 -- The same performance concerns that apply to @'Control.Monad.Free.Free'@
 -- apply to this encoding of a free category.
-data Cat :: (* -> * -> *) -> * -> * -> * where
+data Cat :: (k -> k -> *) -> k -> k -> * where
   Id    :: Cat f a a
   (:.:) :: f b c -> Cat f a b -> Cat f a c
 
@@ -86,14 +84,6 @@
   mappend = (<>)
 #endif
 
-instance SSet (Cat f o o) (Cat f a o) where
-  act = (.)
-
-instance MSet (Cat f o o) (Cat f a o) where
-#if __GLASGOW_HASKELL__ < 804
-  mact = (.)
-#endif
-
 type instance AlgebraType0 Cat f = ()
 type instance AlgebraType  Cat c = Category c
 
@@ -167,12 +157,4 @@
   mempty = id
 #if __GLASGOW_HASKELL__ < 804
   mappend = (<>)
-#endif
-
-instance SSet (C f o o) (C f a o) where
-  act = (.)
-
-instance MSet (C f o o) (C f a o) where
-#if __GLASGOW_HASKELL__ < 804
-  mact = (.)
 #endif
diff --git a/src/Control/Category/FreeEff.hs b/src/Control/Category/FreeEff.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Category/FreeEff.hs
@@ -0,0 +1,81 @@
+{-# LANGUAGE FunctionalDependencies #-}
+module Control.Category.FreeEff
+  ( EffCategory (..)
+  , FreeEffCat (..)
+  , liftCat
+  , foldNatLift
+  , liftKleisli
+  ) where
+
+import Prelude hiding (id, (.))
+
+import Control.Arrow (Kleisli (..))
+import Control.Category (Category (..))
+import Data.Functor.Identity (Identity (..))
+
+import Control.Category.Free (Cat (..))
+import Control.Algebra.Free2 (FreeAlgebra2 (..))
+import Data.Algebra.Free (AlgebraType, AlgebraType0, proof)
+
+
+-- | Categories which can lift monadic actions, i.e. effectful categories.
+--
+class Category c => EffCategory c m | c -> m where
+  lift :: m (c a b) -> c a b
+
+instance Monad m => EffCategory (Kleisli m) m where
+  lift m = Kleisli (\a -> m >>= \(Kleisli f) -> f a)
+
+instance EffCategory (->) Identity where
+  lift = runIdentity
+
+-- | Category transformer, which adds @'EffCategory'@ instance to the
+-- underlying base category.
+--
+data FreeEffCat :: (* -> *) -> (k -> k -> *) -> k -> k -> * where
+  Base :: c a b -> FreeEffCat m c a b
+  Lift :: m (FreeEffCat m c a b) -> FreeEffCat m c a b
+
+instance (Functor m, Category c) => Category (FreeEffCat m c) where
+  id = Base id
+  Base f  . Base g  = Base $ f . g
+  f       . Lift mg = Lift $ (f .) <$> mg
+  Lift mf . g       = Lift $ (. g) <$> mf
+
+instance (Functor m, Category c) => EffCategory (FreeEffCat m c) m where
+  lift = Lift
+
+type instance AlgebraType0 (FreeEffCat m) c = (Monad m, Category c)
+type instance AlgebraType  (FreeEffCat m) c  = EffCategory c m
+instance Monad m => FreeAlgebra2 (FreeEffCat m) where
+  liftFree2    = Base
+  foldNatFree2 nat (Base cab)  = nat cab
+  foldNatFree2 nat (Lift mcab) = lift $ foldNatFree2 nat <$> mcab
+
+  codom2  = proof
+  forget2 = proof
+
+-- | Wrap a transition into a free category @'Cat'@ and then in
+-- @'FreeEffCat'@
+--
+-- prop> liftCat tr = Base (tr :.: Id)
+--
+liftCat :: Monad m => tr a b -> FreeEffCat m (Cat tr) a b
+liftCat = liftFree2 . liftFree2
+
+-- | Fold @'FreeLifing'@ category based on a free category @'Cat' tr@ using
+-- a functor @tr x y -> c x y@.
+--
+foldNatLift
+  :: (Monad m, EffCategory c m)
+  => (forall x y. tr x y -> c x y)
+  -> FreeEffCat m (Cat tr) a b
+  -> c a b
+foldNatLift nat = foldNatFree2 (foldNatFree2 nat)
+
+-- |  Functor from @'->'@ category to @'Kleisli' m@.  If @m@ is @Identity@ then
+-- it will respect @'lift'@ i.e. @liftKleisli (lift ar) = lift (liftKleisli <$>
+-- ar).
+--
+liftKleisli :: Applicative m => (a -> b) -> Kleisli m a b
+liftKleisli f = Kleisli (pure . f)