diff --git a/acid-state.cabal b/acid-state.cabal
--- a/acid-state.cabal
+++ b/acid-state.cabal
@@ -1,5 +1,5 @@
 Name:                acid-state
-Version:             0.12.4
+Version:             0.13.0
 Synopsis:            Add ACID guarantees to any serializable Haskell data structure.
 Description:         Use regular Haskell data structures as your database and get stronger ACID guarantees than most RDBMS offer.
 Homepage:            http://acid-state.seize.it/
@@ -24,12 +24,13 @@
   Exposed-Modules:     Data.Acid,
                        Data.Acid.Local, Data.Acid.Memory,
                        Data.Acid.Memory.Pure, Data.Acid.Remote,
-                       Data.Acid.Advanced
-
-  Other-modules:       Data.Acid.Log, Data.Acid.Archive,
-                       Data.Acid.CRC, Paths_acid_state,
-                       Data.Acid.TemplateHaskell, Data.Acid.Common, FileIO,
+                       Data.Acid.Advanced,
+                       Data.Acid.Log, Data.Acid.CRC,
                        Data.Acid.Abstract, Data.Acid.Core
+
+  Other-modules:       Data.Acid.Archive,
+                       Paths_acid_state,
+                       Data.Acid.TemplateHaskell, Data.Acid.Common, FileIO
 
   Build-depends:       array,
                        base >= 4 && < 5,
diff --git a/src/Data/Acid/Abstract.hs b/src/Data/Acid/Abstract.hs
--- a/src/Data/Acid/Abstract.hs
+++ b/src/Data/Acid/Abstract.hs
@@ -35,15 +35,14 @@
 {-| State container offering full ACID (Atomicity, Consistency, Isolation and Durability)
     guarantees.
 
-    [@Atomicity@]  State changes are all-or-nothing. This is what you'd expect of any state
-                   variable in Haskell and AcidState doesn't change that.
-
+    [@Atomicity@]   State changes are all-or-nothing. This is what you'd expect
+                    of any state variable in Haskell and AcidState doesn't
+                    change that.
     [@Consistency@] No event or set of events will break your data invariants.
-
-    [@Isolation@] Transactions cannot interfere with each other even when issued in parallel.
-
-    [@Durability@] Successful transaction are guaranteed to survive unexpected system shutdowns
-                   (both those caused by hardware and software).
+    [@Isolation@]   Transactions cannot interfere with each other even when
+                    issued in parallel.
+    [@Durability@]  Successful transaction are guaranteed to survive unexpected
+                    system shutdowns (both those caused by hardware and software).
 -}
 data AcidState st
   = AcidState {
diff --git a/src/Data/Acid/Local.hs b/src/Data/Acid/Local.hs
--- a/src/Data/Acid/Local.hs
+++ b/src/Data/Acid/Local.hs
@@ -17,7 +17,11 @@
     , openLocalStateFrom
     , prepareLocalState
     , prepareLocalStateFrom
+    , scheduleLocalUpdate'
+    , scheduleLocalColdUpdate'
     , createCheckpointAndClose
+    , LocalState(..)
+    , Checkpoint(..)
     ) where
 
 import Data.Acid.Log as Log
@@ -95,6 +99,32 @@
          return mvar
     where hotMethod = lookupHotMethod (coreMethods (localCore acidState)) event
 
+-- | Same as scheduleLocalUpdate but does not immediately change the localCopy
+-- and return the result mvar - returns an IO action to do this instead. Take
+-- care to run actions of multiple Updates in the correct order as otherwise
+-- Queries will operate on outdated state.
+scheduleLocalUpdate' :: UpdateEvent event => LocalState (EventState event) -> event -> MVar (EventResult event) -> IO (IO ())
+scheduleLocalUpdate' acidState event mvar
+    = do
+         let encoded = runPutLazy (safePut event)
+
+         -- It is important that we encode the event now so that we can catch
+         -- any exceptions (see nestedStateError in examples/errors/Exceptions.hs)
+         evaluate (Lazy.length encoded)
+
+         act <- modifyCoreState (localCore acidState) $ \st ->
+           do let !(result, !st') = runState hotMethod st
+              -- Schedule the log entry. Very important that it happens when 'localCore' is locked
+              -- to ensure that events are logged in the same order that they are executed.
+              pushEntry (localEvents acidState) (methodTag event, encoded) $ return ()
+              let action = do writeIORef (localCopy acidState) st'
+                              putMVar mvar result
+              return (st', action)
+         -- this is the action to update state for queries and release the
+         -- result into the supplied mvar
+         return act
+    where hotMethod = lookupHotMethod (coreMethods (localCore acidState)) event
+
 scheduleLocalColdUpdate :: LocalState st -> Tagged ByteString -> IO (MVar ByteString)
 scheduleLocalColdUpdate acidState event
     = do mvar <- newEmptyMVar
@@ -106,6 +136,23 @@
                                                            putMVar mvar result
               return st'
          return mvar
+    where coldMethod = lookupColdMethod (localCore acidState) event
+
+-- | Same as scheduleLocalColdUpdate but does not immediately change the
+-- localCopy and return the result mvar - returns an IO action to do this
+-- instead. Take care to run actions of multiple Updates in the correct order as
+-- otherwise Queries will operate on outdated state.
+scheduleLocalColdUpdate' :: LocalState st -> Tagged ByteString -> MVar ByteString -> IO (IO ())
+scheduleLocalColdUpdate' acidState event mvar
+    = do act <- modifyCoreState (localCore acidState) $ \st ->
+           do let !(result, !st') = runState coldMethod st
+              -- Schedule the log entry. Very important that it happens when 'localCore' is locked
+              -- to ensure that events are logged in the same order that they are executed.
+              pushEntry (localEvents acidState) event $ return ()
+              let action = do writeIORef (localCopy acidState) st'
+                              putMVar mvar result
+              return (st', action)
+         return act
     where coldMethod = lookupColdMethod (localCore acidState) event
 
 -- | Issue a Query event and wait for its result. Events may be issued in parallel.
diff --git a/src/Data/Acid/Log.hs b/src/Data/Acid/Log.hs
--- a/src/Data/Acid/Log.hs
+++ b/src/Data/Acid/Log.hs
@@ -3,7 +3,7 @@
 -- extendible array of entries.
 --
 module Data.Acid.Log
-    ( FileLog
+    ( FileLog(..)
     , LogKey(..)
     , EntryId
     , openFileLog