diff --git a/library/Potoki/Core/Consume.hs b/library/Potoki/Core/Consume.hs
--- a/library/Potoki/Core/Consume.hs
+++ b/library/Potoki/Core/Consume.hs
@@ -11,6 +11,7 @@
 import Potoki.Core.Prelude hiding (sum)
 import Potoki.Core.Types
 import qualified Potoki.Core.Fetch as A
+import qualified Acquire.IO as B
 
 
 instance Profunctor Consume where
@@ -86,5 +87,5 @@
 
 {-# INLINABLE transform #-}
 transform :: Transform input output -> Consume output sinkOutput -> Consume input sinkOutput
-transform (Transform transformManaged) (Consume sink) =
-  Consume (\ fetch -> with (fmap ($ fetch) transformManaged) sink)
+transform (Transform transformAcquire) (Consume sink) =
+  Consume (\ fetch -> B.acquire (fmap ($ fetch) transformAcquire) sink)
diff --git a/library/Potoki/Core/Fetch.hs b/library/Potoki/Core/Fetch.hs
--- a/library/Potoki/Core/Fetch.hs
+++ b/library/Potoki/Core/Fetch.hs
@@ -11,6 +11,7 @@
   eitherFetchingRight,
   signaling,
   ioMaybe,
+  ioFetch,
 )
 where
 
@@ -174,3 +175,10 @@
 ioMaybe :: IO (Maybe a) -> Fetch a
 ioMaybe io =
   Fetch $ \nil just -> maybe nil just <$> io
+
+{-# INLINABLE ioFetch #-}
+ioFetch :: IO (Fetch a) -> Fetch a
+ioFetch io =
+  Fetch $ \ nil just -> do
+    Fetch fetchIO <- io
+    fetchIO nil just
diff --git a/library/Potoki/Core/IO.hs b/library/Potoki/Core/IO.hs
--- a/library/Potoki/Core/IO.hs
+++ b/library/Potoki/Core/IO.hs
@@ -4,19 +4,20 @@
 import Potoki.Core.Types
 import qualified Potoki.Core.Produce as A
 import qualified Potoki.Core.Consume as B
+import qualified Acquire.IO as C
 
 
 produceAndConsume :: Produce input -> Consume input output -> IO output
 produceAndConsume (Produce produceManaged) (Consume consume) =
-  with produceManaged consume
+  C.acquire produceManaged consume
 
 produceAndTransformAndConsume :: Produce input -> Transform input anotherInput -> Consume anotherInput output -> IO output
 produceAndTransformAndConsume (Produce produceManaged) (Transform transformManaged) (Consume consume) =
-  with (($) <$> transformManaged <*> produceManaged) consume
+  C.acquire (($) <$> transformManaged <*> produceManaged) consume
 
 produce :: Produce input -> forall x. IO x -> (input -> IO x) -> IO x
 produce (Produce produceManaged) stop emit =
-  with produceManaged $ \ (Fetch fetchIO) -> 
+  C.acquire produceManaged $ \ (Fetch fetchIO) -> 
   fix (\ loop -> join (fetchIO stop (\ element -> emit element >> loop)))
 
 consume :: (forall x. x -> (input -> x) -> IO x) -> Consume input output -> IO output
diff --git a/library/Potoki/Core/Prelude.hs b/library/Potoki/Core/Prelude.hs
--- a/library/Potoki/Core/Prelude.hs
+++ b/library/Potoki/Core/Prelude.hs
@@ -78,6 +78,6 @@
 -------------------------
 import Control.Concurrent.STM as Exports
 
--- managed
+-- acquire
 -------------------------
-import Control.Monad.Managed as Exports
+import Acquire.Acquire as Exports
diff --git a/library/Potoki/Core/Produce.hs b/library/Potoki/Core/Produce.hs
--- a/library/Potoki/Core/Produce.hs
+++ b/library/Potoki/Core/Produce.hs
@@ -9,6 +9,7 @@
 import Potoki.Core.Prelude
 import Potoki.Core.Types
 import qualified Potoki.Core.Fetch as A
+import qualified Acquire.IO as B
 
 
 deriving instance Functor Produce
@@ -17,15 +18,34 @@
   pure x = Produce $ do
     refX <- liftIO (newIORef (Just x))
     return (A.maybeRef refX)
-  (<*>) (Produce leftManaged) (Produce rightManaged) =
-    Produce ((<*>) <$> leftManaged <*> rightManaged)
+  (<*>) (Produce leftAcquire) (Produce rightAcquire) =
+    Produce ((<*>) <$> leftAcquire <*> rightAcquire)
 
 instance Alternative Produce where
   empty =
     Produce (pure empty)
-  (<|>) (Produce leftManaged) (Produce rightManaged) =
-    Produce ((<|>) <$> leftManaged <*> rightManaged)
+  (<|>) (Produce leftAcquire) (Produce rightAcquire) =
+    Produce ((<|>) <$> leftAcquire <*> rightAcquire)
 
+instance Monad Produce where
+  return = pure
+  (>>=) (Produce (Acquire io1)) k2 =
+    Produce $ Acquire $ do
+      (fetch1, release1) <- io1
+      release2Ref <- newIORef (return ())
+      let
+        fetch2 input1 =
+          case k2 input1 of
+            Produce (Acquire io2) ->
+              A.ioFetch $ do
+                join (readIORef release2Ref)
+                (fetch2, release2) <- io2
+                writeIORef release2Ref release2
+                return fetch2
+        release3 =
+          join (readIORef release2Ref) >> release1
+        in return (fetch1 >>= fetch2, release3)
+
 {-# INLINABLE list #-}
 list :: [input] -> Produce input
 list list =
@@ -33,8 +53,8 @@
 
 {-# INLINE transform #-}
 transform :: Transform input output -> Produce input -> Produce output
-transform (Transform transformManaged) (Produce produceManaged) =
+transform (Transform transformAcquire) (Produce produceAcquire) =
   Produce $ do
-    fetch <- produceManaged
-    newFetch <- transformManaged
+    fetch <- produceAcquire
+    newFetch <- transformAcquire
     return (newFetch fetch)
diff --git a/library/Potoki/Core/Transform.hs b/library/Potoki/Core/Transform.hs
--- a/library/Potoki/Core/Transform.hs
+++ b/library/Potoki/Core/Transform.hs
@@ -2,6 +2,7 @@
 (
   Transform(..),
   consume,
+  produce,
   mapFetch,
   executeIO,
   take,
@@ -97,6 +98,26 @@
                   writeIORef stoppedRef False
                   return stop
             else return (yield output)
+
+{-# INLINABLE produce #-}
+produce :: (input -> Produce output) -> Transform input output
+produce inputToProduce =
+  Transform $ do
+    stateRef <- liftIO (newIORef Nothing)
+    return $ \ (Fetch inputFetchIO) -> Fetch $ \ nil just -> fix $ \ loop -> do
+      state <- readIORef stateRef
+      case state of
+        Just (Fetch outputFetchIO, kill) ->
+          join $ outputFetchIO
+            (kill >> writeIORef stateRef Nothing >> loop)
+            (return . just)
+        Nothing ->
+          join $ inputFetchIO (return nil) $ \ !input -> do
+            case inputToProduce input of
+              Produce (Acquire produceIO) -> do
+                fetchAndKill <- produceIO
+                writeIORef stateRef (Just fetchAndKill)
+                loop
 
 {-# INLINE mapFetch #-}
 mapFetch :: (Fetch a -> Fetch b) -> Transform a b
diff --git a/library/Potoki/Core/Types.hs b/library/Potoki/Core/Types.hs
--- a/library/Potoki/Core/Types.hs
+++ b/library/Potoki/Core/Types.hs
@@ -18,7 +18,7 @@
 and resource management.
 -}
 newtype Produce element =
-  Produce (Managed (Fetch element))
+  Produce (Acquire (Fetch element))
 
 {-|
 Active consumer of input into output.
@@ -34,4 +34,4 @@
   Consume (Fetch input -> IO output)
 
 newtype Transform input output =
-  Transform (Managed (Fetch input -> Fetch output))
+  Transform (Acquire (Fetch input -> Fetch output))
diff --git a/potoki-core.cabal b/potoki-core.cabal
--- a/potoki-core.cabal
+++ b/potoki-core.cabal
@@ -1,7 +1,7 @@
 name:
   potoki-core
 version:
-  0.9.2
+  0.10
 synopsis:
   Low-level components of "potoki"
 description:
@@ -52,8 +52,8 @@
     Potoki.Core.Types
     Potoki.Core.Prelude
   build-depends:
+    acquire >=0.2 && <0.3,
     base >=4.7 && <5,
-    managed >=1.0.5 && <2,
     profunctors >=5.2 && <6,
     stm >=2.4 && <3
 
diff --git a/tests/Main.hs b/tests/Main.hs
--- a/tests/Main.hs
+++ b/tests/Main.hs
@@ -30,10 +30,21 @@
 transform =
   testGroup "Transform" $
   [
+    transformProduce
+    ,
     transformChoice
     ,
     transformArrowLaws
   ]
+
+transformProduce =
+  testCase "Produce" $ do
+    let list = [1, 2, 3] :: [Int]
+    result <- C.produceAndTransformAndConsume
+      (E.list list)
+      (A.produce (E.list . \ n -> flip replicate n n))
+      (D.list)
+    assertEqual "" [1, 2, 2, 3, 3, 3] result
 
 transformChoice =
   testGroup "Choice" $