Haskell limit number of recursions
Sheriff voice: Halt! You are breaking the laws!

Your monad breaks the right- and left-identity law of &gt;&gt;=:

k        &gt;&gt;= return = k   -- right identity
return a &gt;&gt;= f      = f a -- left  identity


Suddenly, it makes a big difference whether I call return at the end of my function:

do
   replicateM 9 actions        -- fine

do
   k &lt;- replicateM 9 actions
   return k                     -- fails


That simply breaks to much. Your Monad is also missing its Functor and Applicative instances, which would make it easy to "cheat". And if you implemented a fmap that limits the number of fmaps, you start to break Functor laws. Note that due to the Monad/Functor laws, we should be able to rewrite

limitedFactorial :: Int -&gt; Limiter Int
limitedFactorial 1 = return 1
limitedFactorial n = do
    recursive &lt;- limitedFactorial (n - 1)
    return $ n * recursive


to

limitedFactorial :: Int -&gt; Limiter Int
limitedFactorial 1 = return 1
limitedFactorial n = fmap (n *) $ limitedFactorial (n - 1)


If you were to limit that, you would break fmap id = id immediately.

But even without all of these quirks, at long last, there's nothing preventing the user to use recursion:

example :: Limit Int
example = return 1      -- fine

evil :: Int -&gt; a -&gt; Int
evil x _ = if x &gt; 0 then 1 + evil (x - 1) undefined else 0

do
    liftM (evil 100000000) example -- recursion!


So conceptionally, your Monad is broken, unfortunately.

Further review


Your code uses names from your imports. state is a function defined in Control.Monad.State, so it makes your instance slightly hard to read.
You use increment only once, so it makes sense to inline it.