diff --git a/src/Automatonymous.Tests/Condition_Specs.cs b/src/Automatonymous.Tests/Condition_Specs.cs
index 6316925..e44f339 100644
--- a/src/Automatonymous.Tests/Condition_Specs.cs
+++ b/src/Automatonymous.Tests/Condition_Specs.cs
@@ -44,6 +44,15 @@ public async Task Should_allow_if_condition_to_be_evaluated()
             Assert.That(_instance.CurrentState, Is.Not.EqualTo(_machine.ShouldNotBeHere));
         }
 
+        [Test]
+        public async Task Should_evaluate_else_statement_when_if_condition__is_false()
+        {
+            await _machine.RaiseEvent(_instance, _machine.ExplicitFilterStarted, new StartedExplicitFilter());
+
+            Assert.That(_instance.ShouldBeCalled, Is.True);
+        }
+        
+
         [SetUp]
         public void Specifying_an_event_activity()
         {
@@ -59,6 +68,8 @@ class Instance
         {
             public bool InitializeOnly { get; set; }
             public State CurrentState { get; set; }
+            
+            public bool ShouldBeCalled { get; set; }
         }
 
 
@@ -75,10 +86,13 @@ public InstanceStateMachine()
 
                 During(Initial,
                     When(ExplicitFilterStarted, context => true)
-                        .If(context => false, binder => binder
-                            .Then(context => Console.WriteLine("Should not be here!"))
-                            .TransitionTo(ShouldNotBeHere))
-                        .If(context => true, binder => binder.Then(context => Console.WriteLine("Initializing Only!"))));
+                        .IfElse(context => false, 
+                            binder => binder
+                                .Then(context => Console.WriteLine("Should not be here!"))
+                                .TransitionTo(ShouldNotBeHere),
+                            binder => binder
+                                .Then(context => context.Instance.ShouldBeCalled = true)
+                                .Then(context => Console.WriteLine("Initializing Only!"))));
 
                 During(Running,
                     When(Finish)
@@ -136,6 +150,14 @@ public async Task Should_allow_if_condition_to_be_evaluated()
             Assert.That(_instance.CurrentState, Is.Not.EqualTo(_machine.ShouldNotBeHere));
         }
 
+        [Test]
+        public async Task Should_evaluate_else_statement_when_if_condition__is_false()
+        {
+            await _machine.RaiseEvent(_instance, _machine.ExplicitFilterStarted, new StartedExplicitFilter());
+
+            Assert.That(_instance.ShouldBeCalled, Is.True);
+        }
+
         [SetUp]
         public void Specifying_an_event_activity()
         {
@@ -151,6 +173,7 @@ class Instance
         {
             public bool InitializeOnly { get; set; }
             public State CurrentState { get; set; }
+            public bool ShouldBeCalled { get; set; }
         }
 
 
@@ -167,10 +190,13 @@ public InstanceStateMachine()
 
                 During(Initial,
                     When(ExplicitFilterStarted, context => true)
-                        .IfAsync(context => Task.FromResult(false), binder => binder
-                            .Then(context => Console.WriteLine("Should not be here!"))
-                            .TransitionTo(ShouldNotBeHere))
-                        .IfAsync(context => Task.FromResult(true), binder => binder.Then(context => Console.WriteLine("Initializing Only!"))));
+                        .IfElseAsync(context => Task.FromResult(false), 
+                            binder => binder
+                                .Then(context => Console.WriteLine("Should not be here!"))
+                                .TransitionTo(ShouldNotBeHere),
+                            binder => binder
+                                .Then(context => context.Instance.ShouldBeCalled = true)
+                                .Then(context => Console.WriteLine("Initializing Only!"))));
 
                 During(Running,
                     When(Finish)
diff --git a/src/Automatonymous.Tests/Exception_Specs.cs b/src/Automatonymous.Tests/Exception_Specs.cs
index 00ffc45..e710de5 100644
--- a/src/Automatonymous.Tests/Exception_Specs.cs
+++ b/src/Automatonymous.Tests/Exception_Specs.cs
@@ -51,7 +51,12 @@ public Instance()
             public bool ShouldNotBeCalled { get; set; }
 
             public bool CalledThenClause { get; set; }
-            public bool CalledSecondThenClause { get; set; }
+            public bool CalledThenClauseAsync { get; set; }
+
+            public bool ThenShouldNotBeCalled { get; set; }
+            public bool ElseShouldBeCalled { get; set; }
+            public bool ThenAsyncShouldNotBeCalled { get; set; }
+            public bool ElseAsyncShouldBeCalled { get; set; }
         }
 
 
@@ -70,7 +75,15 @@ public InstanceStateMachine()
                                 .Then(context => context.Instance.CalledThenClause = true)
                             )
                             .IfAsync(context => Task.FromResult(true), b => b
-                                .Then(context => context.Instance.CalledSecondThenClause = true)
+                                .Then(context => context.Instance.CalledThenClauseAsync = true)
+                            )
+                            .IfElse(context => false, 
+                                b => b.Then(context => context.Instance.ThenShouldNotBeCalled = true),
+                                b => b.Then(context => context.Instance.ElseShouldBeCalled = true)
+                            )
+                            .IfElseAsync(context => Task.FromResult(false), 
+                                b => b.Then(context => context.Instance.ThenAsyncShouldNotBeCalled = true),
+                                b => b.Then(context => context.Instance.ElseAsyncShouldBeCalled = true)
                             )
                             .Then(context =>
                             {
@@ -142,7 +155,31 @@ public void Should_have_called_the_first_if_block()
         [Test]
         public void Should_have_called_the_async_if_block()
         {
-            Assert.IsTrue(_instance.CalledSecondThenClause);
+            Assert.IsTrue(_instance.CalledThenClauseAsync);
+        }
+
+        [Test]
+        public void Should_not_have_called_the_false_condition_then_block()
+        {
+            Assert.IsFalse(_instance.ThenShouldNotBeCalled);
+        }
+
+        [Test]
+        public void Should_not_have_called_the_false_async_condition_then_block()
+        {
+            Assert.IsFalse(_instance.ThenAsyncShouldNotBeCalled);
+        }
+
+        [Test]
+        public void Should_have_called_the_false_condition_else_block()
+        {
+            Assert.IsTrue(_instance.ElseShouldBeCalled);
+        }
+
+        [Test]
+        public void Should_have_called_the_false_async_condition_else_block()
+        {
+            Assert.IsTrue(_instance.ElseAsyncShouldBeCalled);
         }
     }
 
@@ -316,6 +353,11 @@ public Instance()
 
             public bool CalledThenClause { get; set; }
             public bool CalledSecondThenClause { get; set; }
+
+            public bool ThenShouldNotBeCalled { get; set; }
+            public bool ElseShouldBeCalled { get; set; }
+            public bool ThenAsyncShouldNotBeCalled { get; set; }
+            public bool ElseAsyncShouldBeCalled { get; set; }
         }
 
 
@@ -343,6 +385,14 @@ public InstanceStateMachine()
                             .IfAsync(context => Task.FromResult(true), b => b
                                 .Then(context => context.Instance.CalledSecondThenClause = true)
                             )
+                            .IfElse(context => false, 
+                                b => b.Then(context => context.Instance.ThenShouldNotBeCalled = true),
+                                b => b.Then(context => context.Instance.ElseShouldBeCalled = true)
+                            )
+                            .IfElseAsync(context => Task.FromResult(false), 
+                                b => b.Then(context => context.Instance.ThenAsyncShouldNotBeCalled = true),
+                                b => b.Then(context => context.Instance.ElseAsyncShouldBeCalled = true)
+                            )
                             .Then(context =>
                             {
                                 context.Instance.ExceptionMessage = context.Exception.Message;
@@ -398,5 +448,30 @@ public void Should_have_called_the_async_if_block()
         {
             Assert.IsTrue(_instance.CalledSecondThenClause);
         }
+
+        [Test]
+        public void Should_not_have_called_the_false_condition_then_block()
+        {
+            Assert.IsFalse(_instance.ThenShouldNotBeCalled);
+        }
+
+        [Test]
+        public void Should_not_have_called_the_false_async_condition_then_block()
+        {
+            Assert.IsFalse(_instance.ThenAsyncShouldNotBeCalled);
+        }
+
+        [Test]
+        public void Should_have_called_the_false_condition_else_block()
+        {
+            Assert.IsTrue(_instance.ElseShouldBeCalled);
+        }
+
+        [Test]
+        public void Should_have_called_the_false_async_condition_else_block()
+        {
+            Assert.IsTrue(_instance.ElseAsyncShouldBeCalled);
+        }
     }
+
 }
\ No newline at end of file
diff --git a/src/Automatonymous/Activities/ConditionActivity.cs b/src/Automatonymous/Activities/ConditionActivity.cs
index 4edf61c..138fefa 100644
--- a/src/Automatonymous/Activities/ConditionActivity.cs
+++ b/src/Automatonymous/Activities/ConditionActivity.cs
@@ -20,31 +20,37 @@ public class ConditionActivity<TInstance> :
         Activity<TInstance>
         where TInstance : class
     {
-        readonly Behavior<TInstance> _behavior;
+        readonly Behavior<TInstance> _thenBehavior;
+        readonly Behavior<TInstance> _elseBehavior;
         readonly StateMachineAsyncCondition<TInstance> _condition;
 
-        public ConditionActivity(StateMachineAsyncCondition<TInstance> condition, Behavior<TInstance> behavior)
+        public ConditionActivity(StateMachineAsyncCondition<TInstance> condition, Behavior<TInstance> thenBehavior, Behavior<TInstance> elseBehavior)
         {
             _condition = condition;
-            _behavior = behavior;
+            _thenBehavior = thenBehavior;
+            _elseBehavior = elseBehavior;
         }
 
         void IProbeSite.Probe(ProbeContext context)
         {
             var scope = context.CreateScope("condition");
 
-            _behavior.Probe(scope);
+            _thenBehavior.Probe(scope);
+            _elseBehavior.Probe(scope);
         }
 
         void Visitable.Accept(StateMachineVisitor visitor)
         {
-            visitor.Visit(this, x => _behavior.Accept(visitor));
+            visitor.Visit(this, x => _thenBehavior.Accept(visitor));
+            visitor.Visit(this, x => _elseBehavior.Accept(visitor));
         }
 
         async Task Activity<TInstance>.Execute(BehaviorContext<TInstance> context, Behavior<TInstance> next)
         {
             if (await _condition(context).ConfigureAwait(false))
-                await _behavior.Execute(context).ConfigureAwait(false);
+                await _thenBehavior.Execute(context).ConfigureAwait(false);
+            else
+                await _elseBehavior.Execute(context).ConfigureAwait(false);
 
             await next.Execute(context).ConfigureAwait(false);
         }
@@ -52,7 +58,9 @@ async Task Activity<TInstance>.Execute(BehaviorContext<TInstance> context, Behav
         async Task Activity<TInstance>.Execute<T>(BehaviorContext<TInstance, T> context, Behavior<TInstance, T> next)
         {
             if (await _condition(context).ConfigureAwait(false))
-                await _behavior.Execute(context).ConfigureAwait(false);
+                await _thenBehavior.Execute(context).ConfigureAwait(false);
+            else
+                await _elseBehavior.Execute(context).ConfigureAwait(false);
 
             await next.Execute(context).ConfigureAwait(false);
         }
@@ -74,25 +82,29 @@ public class ConditionActivity<TInstance, TData> :
         Activity<TInstance>
         where TInstance : class
     {
-        readonly Behavior<TInstance> _behavior;
+        readonly Behavior<TInstance> _thenBehavior;
+        readonly Behavior<TInstance> _elseBehavior;
         readonly StateMachineAsyncCondition<TInstance, TData> _condition;
 
-        public ConditionActivity(StateMachineAsyncCondition<TInstance, TData> condition, Behavior<TInstance> behavior)
+        public ConditionActivity(StateMachineAsyncCondition<TInstance, TData> condition, Behavior<TInstance> thenBehavior, Behavior<TInstance> elseBehavior)
         {
             _condition = condition;
-            _behavior = behavior;
+            _thenBehavior = thenBehavior;
+            _elseBehavior = elseBehavior;
         }
 
         void IProbeSite.Probe(ProbeContext context)
         {
             var scope = context.CreateScope("condition");
 
-            _behavior.Probe(scope);
+            _thenBehavior.Probe(scope);
+            _elseBehavior.Probe(scope);
         }
 
         void Visitable.Accept(StateMachineVisitor visitor)
         {
-            visitor.Visit(this, x => _behavior.Accept(visitor));
+            visitor.Visit(this, x => _thenBehavior.Accept(visitor));
+            visitor.Visit(this, x => _elseBehavior.Accept(visitor));
         }
 
         Task Activity<TInstance>.Execute(BehaviorContext<TInstance> context, Behavior<TInstance> next)
@@ -106,7 +118,9 @@ async Task Activity<TInstance>.Execute<T>(BehaviorContext<TInstance, T> context,
             if (behaviorContext != null)
             {
                 if (await _condition(behaviorContext).ConfigureAwait(false))
-                    await _behavior.Execute(behaviorContext).ConfigureAwait(false);
+                    await _thenBehavior.Execute(behaviorContext).ConfigureAwait(false);
+                else
+                    await _elseBehavior.Execute(behaviorContext).ConfigureAwait(false);
             }
 
             await next.Execute(context).ConfigureAwait(false);
diff --git a/src/Automatonymous/Activities/ConditionExceptionActivity.cs b/src/Automatonymous/Activities/ConditionExceptionActivity.cs
index 92446f1..7f07494 100644
--- a/src/Automatonymous/Activities/ConditionExceptionActivity.cs
+++ b/src/Automatonymous/Activities/ConditionExceptionActivity.cs
@@ -22,25 +22,30 @@ public class ConditionExceptionActivity<TInstance, TConditionException> :
         where TInstance : class
         where TConditionException : Exception
     {
-        readonly Behavior<TInstance> _behavior;
+        readonly Behavior<TInstance> _thenBehavior;
+        readonly Behavior<TInstance> _elseBehavior;
         readonly StateMachineAsyncExceptionCondition<TInstance, TConditionException> _condition;
 
-        public ConditionExceptionActivity(StateMachineAsyncExceptionCondition<TInstance, TConditionException> condition, Behavior<TInstance> behavior)
+        public ConditionExceptionActivity(StateMachineAsyncExceptionCondition<TInstance, TConditionException> condition,
+            Behavior<TInstance> thenBehavior, Behavior<TInstance> elseBehavior)
         {
             _condition = condition;
-            _behavior = behavior;
+            _thenBehavior = thenBehavior;
+            _elseBehavior = elseBehavior;
         }
 
         void IProbeSite.Probe(ProbeContext context)
         {
             var scope = context.CreateScope("condition");
 
-            _behavior.Probe(scope);
+            _thenBehavior.Probe(scope);
+            _elseBehavior.Probe(scope);
         }
 
         void Visitable.Accept(StateMachineVisitor visitor)
         {
-            visitor.Visit(this, x => _behavior.Accept(visitor));
+            visitor.Visit(this, x => _thenBehavior.Accept(visitor));
+            visitor.Visit(this, x => _elseBehavior.Accept(visitor));
         }
 
         Task Activity<TInstance>.Execute(BehaviorContext<TInstance> context, Behavior<TInstance> next)
@@ -60,7 +65,11 @@ async Task Activity<TInstance>.Faulted<TException>(BehaviorExceptionContext<TIns
             {
                 if (await _condition(behaviorContext).ConfigureAwait(false))
                 {
-                    await _behavior.Faulted(context).ConfigureAwait(false);
+                    await _thenBehavior.Faulted(context).ConfigureAwait(false);
+                }
+                else
+                {
+                    await _elseBehavior.Faulted(context).ConfigureAwait(false);
                 }
             }
 
@@ -75,7 +84,11 @@ async Task Activity<TInstance>.Faulted<T, TException>(BehaviorExceptionContext<T
             {
                 if (await _condition(behaviorContext).ConfigureAwait(false))
                 {
-                    await _behavior.Faulted(context).ConfigureAwait(false);
+                    await _thenBehavior.Faulted(context).ConfigureAwait(false);
+                }
+                else
+                {
+                    await _elseBehavior.Faulted(context).ConfigureAwait(false);
                 }
             }
 
@@ -89,25 +102,30 @@ public class ConditionExceptionActivity<TInstance, TData, TConditionException> :
         where TInstance : class
         where TConditionException : Exception
     {
-        readonly Behavior<TInstance> _behavior;
+        readonly Behavior<TInstance> _thenBehavior;
+        readonly Behavior<TInstance> _elseBehavior;
         readonly StateMachineAsyncExceptionCondition<TInstance, TData, TConditionException> _condition;
 
-        public ConditionExceptionActivity(StateMachineAsyncExceptionCondition<TInstance, TData, TConditionException> condition, Behavior<TInstance> behavior)
+        public ConditionExceptionActivity(StateMachineAsyncExceptionCondition<TInstance, TData, TConditionException> condition,
+            Behavior<TInstance> thenBehavior, Behavior<TInstance> elseBehavior)
         {
             _condition = condition;
-            _behavior = behavior;
+            _thenBehavior = thenBehavior;
+            _elseBehavior = elseBehavior;
         }
 
         void IProbeSite.Probe(ProbeContext context)
         {
             var scope = context.CreateScope("condition");
 
-            _behavior.Probe(scope);
+            _thenBehavior.Probe(scope);
+            _elseBehavior.Probe(scope);
         }
 
         void Visitable.Accept(StateMachineVisitor visitor)
         {
-            visitor.Visit(this, x => _behavior.Accept(visitor));
+            visitor.Visit(this, x => _thenBehavior.Accept(visitor));
+            visitor.Visit(this, x => _elseBehavior.Accept(visitor));
         }
 
         Task Activity<TInstance>.Execute(BehaviorContext<TInstance> context, Behavior<TInstance> next)
@@ -133,7 +151,11 @@ async Task Activity<TInstance>.Faulted<T, TException>(BehaviorExceptionContext<T
             {
                 if (await _condition(behaviorContext).ConfigureAwait(false))
                 {
-                    await _behavior.Faulted(context).ConfigureAwait(false);
+                    await _thenBehavior.Faulted(context).ConfigureAwait(false);
+                }
+                else
+                {
+                    await _elseBehavior.Faulted(context).ConfigureAwait(false);
                 }
             }
 
diff --git a/src/Automatonymous/Binders/CatchExceptionActivityBinder.cs b/src/Automatonymous/Binders/CatchExceptionActivityBinder.cs
index bacb7ad..a12de2a 100644
--- a/src/Automatonymous/Binders/CatchExceptionActivityBinder.cs
+++ b/src/Automatonymous/Binders/CatchExceptionActivityBinder.cs
@@ -78,27 +78,45 @@ public ExceptionActivityBinder<TInstance, TException> If(
             StateMachineExceptionCondition<TInstance, TException> condition,
             Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> activityCallback)
         {
-            ExceptionActivityBinder<TInstance, TException> binder = new CatchExceptionActivityBinder<TInstance, TException>(_machine, _event);
-
-            binder = activityCallback(binder);
-
-            var conditionBinder = new ConditionalExceptionActivityBinder<TInstance, TException>(_event, condition, binder);
-
-            return new CatchExceptionActivityBinder<TInstance, TException>(_machine, _event, _activities, conditionBinder);
+            return IfElse(condition, activityCallback, _ => _);
         }
 
         public ExceptionActivityBinder<TInstance, TException> IfAsync(
             StateMachineAsyncExceptionCondition<TInstance, TException> condition,
             Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> activityCallback)
         {
-            ExceptionActivityBinder<TInstance, TException> binder = new CatchExceptionActivityBinder<TInstance, TException>(_machine, _event);
+            return IfElseAsync(condition, activityCallback, _ => _);
+        }
 
-            binder = activityCallback(binder);
+        public ExceptionActivityBinder<TInstance, TException> IfElse(StateMachineExceptionCondition<TInstance, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> thenActivityCallback,
+            Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> elseActivityCallback)
+        {
+            var thenBinder = GetBinder(thenActivityCallback);
+            var elseBinder = GetBinder(elseActivityCallback);
+            
+            var conditionBinder = new ConditionalExceptionActivityBinder<TInstance, TException>(_event, condition, thenBinder, elseBinder);
 
-            var conditionBinder = new ConditionalExceptionActivityBinder<TInstance, TException>(_event, condition, binder);
+            return new CatchExceptionActivityBinder<TInstance, TException>(_machine, _event, _activities, conditionBinder);
+        }
+
+        public ExceptionActivityBinder<TInstance, TException> IfElseAsync(StateMachineAsyncExceptionCondition<TInstance, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> thenActivityCallback,
+            Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> elseActivityCallback)
+        {
+            var thenBinder = GetBinder(thenActivityCallback);
+            var elseBinder = GetBinder(elseActivityCallback);
+
+            var conditionBinder = new ConditionalExceptionActivityBinder<TInstance, TException>(_event, condition, thenBinder, elseBinder);
 
             return new CatchExceptionActivityBinder<TInstance, TException>(_machine, _event, _activities, conditionBinder);
         }
+
+        private ExceptionActivityBinder<TInstance, TException> GetBinder(Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> callback)
+        {
+            ExceptionActivityBinder<TInstance, TException> thenBinder = new CatchExceptionActivityBinder<TInstance, TException>(_machine, _event);
+            return callback(thenBinder);
+        }
     }
 
 
@@ -171,27 +189,43 @@ public ExceptionActivityBinder<TInstance, TData, TException> Catch<T>(
         public ExceptionActivityBinder<TInstance, TData, TException> If(StateMachineExceptionCondition<TInstance, TData, TException> condition,
             Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> activityCallback)
         {
-            ExceptionActivityBinder<TInstance, TData, TException> binder =
-                new CatchExceptionActivityBinder<TInstance, TData, TException>(_machine, _event);
+            return IfElse(condition, activityCallback, _ => _);
+        }
 
-            binder = activityCallback(binder);
+        public ExceptionActivityBinder<TInstance, TData, TException> IfAsync(StateMachineAsyncExceptionCondition<TInstance, TData, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> activityCallback)
+        {
+            return IfElseAsync(condition, activityCallback, _ => _);
+        }
+
+        public ExceptionActivityBinder<TInstance, TData, TException> IfElse(StateMachineExceptionCondition<TInstance, TData, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> thenActivityCallback,
+            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> elseActivityCallback)
+        {
+            var thenBinder = GetBinder(thenActivityCallback);
+            var elseBinder = GetBinder(elseActivityCallback);
 
-            var conditionBinder = new ConditionalExceptionActivityBinder<TInstance, TData, TException>(_event, condition, binder);
+            var conditionBinder = new ConditionalExceptionActivityBinder<TInstance, TData, TException>(_event, condition, thenBinder, elseBinder);
 
             return new CatchExceptionActivityBinder<TInstance, TData, TException>(_machine, _event, _activities, conditionBinder);
         }
 
-        public ExceptionActivityBinder<TInstance, TData, TException> IfAsync(StateMachineAsyncExceptionCondition<TInstance, TData, TException> condition,
-            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> activityCallback)
+        public ExceptionActivityBinder<TInstance, TData, TException> IfElseAsync(StateMachineAsyncExceptionCondition<TInstance, TData, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> thenActivityCallback,
+            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> elseActivityCallback)
         {
-            ExceptionActivityBinder<TInstance, TData, TException> binder =
-                new CatchExceptionActivityBinder<TInstance, TData, TException>(_machine, _event);
-
-            binder = activityCallback(binder);
+            var thenBinder = GetBinder(thenActivityCallback);
+            var elseBinder = GetBinder(elseActivityCallback);
 
-            var conditionBinder = new ConditionalExceptionActivityBinder<TInstance, TData, TException>(_event, condition, binder);
+            var conditionBinder = new ConditionalExceptionActivityBinder<TInstance, TData, TException>(_event, condition, thenBinder, elseBinder);
 
             return new CatchExceptionActivityBinder<TInstance, TData, TException>(_machine, _event, _activities, conditionBinder);
         }
+
+        private ExceptionActivityBinder<TInstance, TData, TException> GetBinder(Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> callback)
+        {
+            ExceptionActivityBinder<TInstance, TData, TException> binder = new CatchExceptionActivityBinder<TInstance, TData, TException>(_machine, _event);
+            return callback(binder);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Automatonymous/Binders/ConditionalActivityBinder.cs b/src/Automatonymous/Binders/ConditionalActivityBinder.cs
index 7608ce6..0962c66 100644
--- a/src/Automatonymous/Binders/ConditionalActivityBinder.cs
+++ b/src/Automatonymous/Binders/ConditionalActivityBinder.cs
@@ -21,18 +21,24 @@ public class ConditionalActivityBinder<TInstance> :
         ActivityBinder<TInstance>
         where TInstance : class
     {
-        readonly EventActivities<TInstance> _activities;
+        readonly EventActivities<TInstance> _thenActivities;
+        readonly EventActivities<TInstance> _elseActivities;
         readonly StateMachineAsyncCondition<TInstance> _condition;
         readonly Event _event;
 
-        public ConditionalActivityBinder(Event @event, StateMachineCondition<TInstance> condition, EventActivities<TInstance> activities)
-            : this(@event, context => Task.FromResult(condition(context)), activities)
+
+
+        public ConditionalActivityBinder(Event @event, StateMachineCondition<TInstance> condition,
+            EventActivities<TInstance> thenActivities, EventActivities<TInstance> elseActivities)
+            : this(@event, context => Task.FromResult(condition(context)), thenActivities, elseActivities)
         {
         }
 
-        public ConditionalActivityBinder(Event @event, StateMachineAsyncCondition<TInstance> condition, EventActivities<TInstance> activities)
+        public ConditionalActivityBinder(Event @event, StateMachineAsyncCondition<TInstance> condition,
+            EventActivities<TInstance> thenActivities, EventActivities<TInstance> elseActivities)
         {
-            _activities = activities;
+            _thenActivities = thenActivities;
+            _elseActivities = elseActivities;
             _condition = condition;
             _event = @event;
         }
@@ -45,30 +51,34 @@ public bool IsStateTransitionEvent(State state)
 
         public void Bind(State<TInstance> state)
         {
-            var builder = new ActivityBehaviorBuilder<TInstance>();
-
-            foreach (var activity in _activities.GetStateActivityBinders())
-            {
-                activity.Bind(builder);
-            }
+            var thenBehavior = GetBehavior(_thenActivities);
+            var elseBehavior = GetBehavior(_elseActivities);
 
-            var conditionActivity = new ConditionActivity<TInstance>(_condition, builder.Behavior);
+            var conditionActivity = new ConditionActivity<TInstance>(_condition, thenBehavior, elseBehavior);
 
             state.Bind(_event, conditionActivity);
         }
 
         public void Bind(BehaviorBuilder<TInstance> builder)
         {
-            var stateBuilder = new ActivityBehaviorBuilder<TInstance>();
+            var thenBehavior = GetBehavior(_thenActivities);
+            var elseBehavior = GetBehavior(_elseActivities);
+
+            var conditionActivity = new ConditionActivity<TInstance>(_condition, thenBehavior, elseBehavior);
+
+            builder.Add(conditionActivity);
+        }
+
+        private static Behavior<TInstance> GetBehavior(EventActivities<TInstance> activities)
+        {
+            var builder = new ActivityBehaviorBuilder<TInstance>();
 
-            foreach (var activity in _activities.GetStateActivityBinders())
+            foreach (var activity in activities.GetStateActivityBinders())
             {
-                activity.Bind(stateBuilder);
+                activity.Bind(builder);
             }
 
-            var conditionActivity = new ConditionActivity<TInstance>(_condition, stateBuilder.Behavior);
-
-            builder.Add(conditionActivity);
+            return builder.Behavior;
         }
     }
 
@@ -77,20 +87,22 @@ public class ConditionalActivityBinder<TInstance, TData> :
         ActivityBinder<TInstance>
         where TInstance : class
     {
-        readonly EventActivities<TInstance> _activities;
+        readonly EventActivities<TInstance> _thenActivities;
+        readonly EventActivities<TInstance> _elseActivities;
         readonly StateMachineAsyncCondition<TInstance, TData> _condition;
         readonly Event _event;
 
         public ConditionalActivityBinder(Event @event, StateMachineCondition<TInstance, TData> condition,
-            EventActivities<TInstance> activities)
-            : this(@event, context => Task.FromResult(condition(context)), activities)
+            EventActivities<TInstance> thenActivities, EventActivities<TInstance> elseActivities)
+            : this(@event, context => Task.FromResult(condition(context)), thenActivities, elseActivities)
         {
         }
 
         public ConditionalActivityBinder(Event @event, StateMachineAsyncCondition<TInstance, TData> condition,
-            EventActivities<TInstance> activities)
+            EventActivities<TInstance> thenActivities, EventActivities<TInstance> elseActivities)
         {
-            _activities = activities;
+            _thenActivities = thenActivities;
+            _elseActivities = elseActivities;
             _condition = condition;
             _event = @event;
         }
@@ -103,30 +115,34 @@ public bool IsStateTransitionEvent(State state)
 
         public void Bind(State<TInstance> state)
         {
-            var builder = new ActivityBehaviorBuilder<TInstance>();
-
-            foreach (var activity in _activities.GetStateActivityBinders())
-            {
-                activity.Bind(builder);
-            }
+            var thenBehavior = GetBehavior(_thenActivities);
+            var elseBehavior = GetBehavior(_elseActivities);
 
-            var conditionActivity = new ConditionActivity<TInstance, TData>(_condition, builder.Behavior);
+            var conditionActivity = new ConditionActivity<TInstance, TData>(_condition, thenBehavior, elseBehavior);
 
             state.Bind(_event, conditionActivity);
         }
 
         public void Bind(BehaviorBuilder<TInstance> builder)
         {
-            var stateBuilder = new ActivityBehaviorBuilder<TInstance>();
+            var thenBehavior = GetBehavior(_thenActivities);
+            var elseBehavior = GetBehavior(_elseActivities);
+
+            var conditionActivity = new ConditionActivity<TInstance, TData>(_condition, thenBehavior, elseBehavior);
+
+            builder.Add(conditionActivity);
+        }
+
+        private static Behavior<TInstance> GetBehavior(EventActivities<TInstance> activities)
+        {
+            var builder = new ActivityBehaviorBuilder<TInstance>();
 
-            foreach (var activity in _activities.GetStateActivityBinders())
+            foreach (var activity in activities.GetStateActivityBinders())
             {
-                activity.Bind(stateBuilder);
+                activity.Bind(builder);
             }
 
-            var conditionActivity = new ConditionActivity<TInstance, TData>(_condition, stateBuilder.Behavior);
-
-            builder.Add(conditionActivity);
+            return builder.Behavior;
         }
     }
 }
\ No newline at end of file
diff --git a/src/Automatonymous/Binders/ConditionalExceptionActivityBinder.cs b/src/Automatonymous/Binders/ConditionalExceptionActivityBinder.cs
index 9a82b35..fe329f6 100644
--- a/src/Automatonymous/Binders/ConditionalExceptionActivityBinder.cs
+++ b/src/Automatonymous/Binders/ConditionalExceptionActivityBinder.cs
@@ -23,18 +23,22 @@ public class ConditionalExceptionActivityBinder<TInstance, TException> :
         where TInstance : class
         where TException : Exception
     {
-        readonly EventActivities<TInstance> _activities;
+        readonly EventActivities<TInstance> _thenActivities;
+        readonly EventActivities<TInstance> _elseActivities;
         readonly StateMachineAsyncExceptionCondition<TInstance, TException> _condition;
         readonly Event _event;
 
-        public ConditionalExceptionActivityBinder(Event @event, StateMachineExceptionCondition<TInstance, TException> condition, EventActivities<TInstance> activities)
-            :this(@event, context => Task.FromResult(condition(context)), activities)
+        public ConditionalExceptionActivityBinder(Event @event, StateMachineExceptionCondition<TInstance, TException> condition,
+            EventActivities<TInstance> thenActivities, EventActivities<TInstance> elseActivities)
+            :this(@event, context => Task.FromResult(condition(context)), thenActivities, elseActivities)
         {
         }
 
-        public ConditionalExceptionActivityBinder(Event @event, StateMachineAsyncExceptionCondition<TInstance, TException> condition, EventActivities<TInstance> activities)
+        public ConditionalExceptionActivityBinder(Event @event, StateMachineAsyncExceptionCondition<TInstance, TException> condition,
+            EventActivities<TInstance> thenActivities, EventActivities<TInstance> elseActivities)
         {
-            _activities = activities;
+            _thenActivities = thenActivities;
+            _elseActivities = elseActivities;
             _condition = condition;
             _event = @event;
         }
@@ -47,30 +51,33 @@ public bool IsStateTransitionEvent(State state)
 
         public void Bind(State<TInstance> state)
         {
-            var catchBuilder = new CatchBehaviorBuilder<TInstance>();
+            var thenBehavior = GetBehavior(_thenActivities);
+            var elseBehavior = GetBehavior(_elseActivities);
 
-            foreach (var activity in _activities.GetStateActivityBinders())
-            {
-                activity.Bind(catchBuilder);
-            }
-
-            var conditionActivity = new ConditionExceptionActivity<TInstance, TException>(_condition, catchBuilder.Behavior);
+            var conditionActivity = new ConditionExceptionActivity<TInstance, TException>(_condition, thenBehavior, elseBehavior);
 
             state.Bind(_event, conditionActivity);
         }
 
         public void Bind(BehaviorBuilder<TInstance> builder)
+        {
+            var thenBehavior = GetBehavior(_thenActivities);
+            var elseBehavior = GetBehavior(_elseActivities);
+
+            var conditionActivity = new ConditionExceptionActivity<TInstance, TException>(_condition, thenBehavior, elseBehavior);
+
+            builder.Add(conditionActivity);
+        }
+
+        private Behavior<TInstance> GetBehavior(EventActivities<TInstance> activities)
         {
             var catchBuilder = new CatchBehaviorBuilder<TInstance>();
 
-            foreach (var activity in _activities.GetStateActivityBinders())
+            foreach (var activity in activities.GetStateActivityBinders())
             {
                 activity.Bind(catchBuilder);
             }
-
-            var conditionActivity = new ConditionExceptionActivity<TInstance, TException>(_condition, catchBuilder.Behavior);
-
-            builder.Add(conditionActivity);
+            return catchBuilder.Behavior;
         }
     }
 
@@ -80,19 +87,22 @@ public class ConditionalExceptionActivityBinder<TInstance, TData, TException> :
         where TInstance : class
         where TException : Exception
     {
-        readonly EventActivities<TInstance> _activities;
+        readonly EventActivities<TInstance> _thenActivities;
+        readonly EventActivities<TInstance> _elseActivities;
         readonly StateMachineAsyncExceptionCondition<TInstance, TData, TException> _condition;
         readonly Event _event;
 
-        public ConditionalExceptionActivityBinder(Event @event, StateMachineExceptionCondition<TInstance, TData, TException> condition, EventActivities<TInstance> activities)
-            : this(@event, context => Task.FromResult(condition(context)), activities)
+        public ConditionalExceptionActivityBinder(Event @event, StateMachineExceptionCondition<TInstance, TData, TException> condition,
+            EventActivities<TInstance> thenActivities, EventActivities<TInstance> elseActivities)
+            : this(@event, context => Task.FromResult(condition(context)), thenActivities, elseActivities)
         {
         }
 
         public ConditionalExceptionActivityBinder(Event @event, StateMachineAsyncExceptionCondition<TInstance, TData, TException> condition,
-            EventActivities<TInstance> activities)
+            EventActivities<TInstance> thenActivities, EventActivities<TInstance> elseActivities)
         {
-            _activities = activities;
+            _thenActivities = thenActivities;
+            _elseActivities = elseActivities;
             _condition = condition;
             _event = @event;
         }
@@ -105,30 +115,34 @@ public bool IsStateTransitionEvent(State state)
 
         public void Bind(State<TInstance> state)
         {
-            var catchBuilder = new CatchBehaviorBuilder<TInstance>();
+            var thenBehavior = GetBehavior(_thenActivities);
+            var elseBehavior = GetBehavior(_elseActivities);
 
-            foreach (var activity in _activities.GetStateActivityBinders())
-            {
-                activity.Bind(catchBuilder);
-            }
-
-            var conditionActivity = new ConditionExceptionActivity<TInstance, TData, TException>(_condition, catchBuilder.Behavior);
+            var conditionActivity = new ConditionExceptionActivity<TInstance, TData, TException>(_condition, thenBehavior, elseBehavior);
 
             state.Bind(_event, conditionActivity);
         }
 
         public void Bind(BehaviorBuilder<TInstance> builder)
+        {
+            var thenBehavior = GetBehavior(_thenActivities);
+            var elseBehavior = GetBehavior(_elseActivities);
+
+            var conditionActivity = new ConditionExceptionActivity<TInstance, TData, TException>(_condition, thenBehavior, elseBehavior);
+
+            builder.Add(conditionActivity);
+        }
+
+        private Behavior<TInstance> GetBehavior(EventActivities<TInstance> activities)
         {
             var catchBuilder = new CatchBehaviorBuilder<TInstance>();
 
-            foreach (var activity in _activities.GetStateActivityBinders())
+            foreach (var activity in activities.GetStateActivityBinders())
             {
                 activity.Bind(catchBuilder);
             }
 
-            var conditionActivity = new ConditionExceptionActivity<TInstance, TData, TException>(_condition, catchBuilder.Behavior);
-
-            builder.Add(conditionActivity);
+            return catchBuilder.Behavior;
         }
     }
 }
\ No newline at end of file
diff --git a/src/Automatonymous/Binders/DataEventActivityBinder.cs b/src/Automatonymous/Binders/DataEventActivityBinder.cs
index fa299b9..e947f5e 100644
--- a/src/Automatonymous/Binders/DataEventActivityBinder.cs
+++ b/src/Automatonymous/Binders/DataEventActivityBinder.cs
@@ -85,27 +85,46 @@ EventActivityBinder<TInstance, TData> EventActivityBinder<TInstance, TData>.Catc
         EventActivityBinder<TInstance, TData> EventActivityBinder<TInstance, TData>.If(StateMachineCondition<TInstance, TData> condition,
             Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> activityCallback)
         {
-            EventActivityBinder<TInstance, TData> binder = new DataEventActivityBinder<TInstance, TData>(_machine, _event);
+            return IfElse(condition, activityCallback, _ => _);
+        }
 
-            binder = activityCallback(binder);
+        EventActivityBinder<TInstance, TData> EventActivityBinder<TInstance, TData>.IfAsync(StateMachineAsyncCondition<TInstance, TData> condition,
+            Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> activityCallback)
+        {
+            return IfElseAsync(condition, activityCallback, _ => _);
+        }
 
-            var conditionBinder = new ConditionalActivityBinder<TInstance, TData>(_event, condition, binder);
+        public EventActivityBinder<TInstance, TData> IfElse(StateMachineCondition<TInstance, TData> condition,
+            Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> thenActivityCallback,
+            Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> elseActivityCallback)
+        {
+            var thenBinder = GetBinder(thenActivityCallback);
+            var elseBinder = GetBinder(elseActivityCallback);
+
+            var conditionBinder = new ConditionalActivityBinder<TInstance, TData>(_event, condition, thenBinder, elseBinder);
 
             return new DataEventActivityBinder<TInstance, TData>(_machine, _event, _filter, _activities, conditionBinder);
         }
 
-        EventActivityBinder<TInstance, TData> EventActivityBinder<TInstance, TData>.IfAsync(StateMachineAsyncCondition<TInstance, TData> condition,
-            Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> activityCallback)
+        public EventActivityBinder<TInstance, TData> IfElseAsync(StateMachineAsyncCondition<TInstance, TData> condition,
+            Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> thenActivityCallback,
+            Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> elseActivityCallback)
         {
-            EventActivityBinder<TInstance, TData> binder = new DataEventActivityBinder<TInstance, TData>(_machine, _event);
+            var thenBinder = GetBinder(thenActivityCallback);
+            var elseBinder = GetBinder(elseActivityCallback);
 
-            binder = activityCallback(binder);
-
-            var conditionBinder = new ConditionalActivityBinder<TInstance, TData>(_event, condition, binder);
+            var conditionBinder = new ConditionalActivityBinder<TInstance, TData>(_event, condition, thenBinder, elseBinder);
 
             return new DataEventActivityBinder<TInstance, TData>(_machine, _event, _filter, _activities, conditionBinder);
         }
 
+        private EventActivityBinder<TInstance, TData> GetBinder(Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> activityCallback)
+        {
+            EventActivityBinder<TInstance, TData> binder = new DataEventActivityBinder<TInstance, TData>(_machine, _event);
+
+            return activityCallback(binder);
+        }
+
         StateMachine<TInstance> EventActivityBinder<TInstance, TData>.StateMachine => _machine;
 
         public IEnumerable<ActivityBinder<TInstance>> GetStateActivityBinders()
@@ -125,9 +144,10 @@ ActivityBinder<TInstance> CreateStateActivityBinder(Activity<TInstance, TData> a
 
         ActivityBinder<TInstance> CreateConditionalActivityBinder()
         {
-            EventActivityBinder<TInstance, TData> binder = new DataEventActivityBinder<TInstance, TData>(_machine, _event, _activities);
+            EventActivityBinder<TInstance, TData> thenBinder = new DataEventActivityBinder<TInstance, TData>(_machine, _event, _activities);
+            EventActivityBinder<TInstance, TData> elseBinder = new DataEventActivityBinder<TInstance, TData>(_machine, _event);
 
-            var conditionBinder = new ConditionalActivityBinder<TInstance, TData>(_event, context => _filter(context), binder);
+            var conditionBinder = new ConditionalActivityBinder<TInstance, TData>(_event, context => _filter(context), thenBinder, elseBinder);
 
             return conditionBinder;
         }
diff --git a/src/Automatonymous/Binders/EventActivityBinder.cs b/src/Automatonymous/Binders/EventActivityBinder.cs
index 56c3f90..74928ac 100644
--- a/src/Automatonymous/Binders/EventActivityBinder.cs
+++ b/src/Automatonymous/Binders/EventActivityBinder.cs
@@ -52,6 +52,28 @@ EventActivityBinder<TInstance> If(StateMachineCondition<TInstance> condition,
         /// <returns></returns>
         EventActivityBinder<TInstance> IfAsync(StateMachineAsyncCondition<TInstance> condition,
             Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> activityCallback);
+
+        /// <summary>
+        /// Create a conditional branch of activities for processing
+        /// </summary>
+        /// <param name="condition"></param>
+        /// <param name="thenActivityCallback"></param>
+        /// <param name="elseActivityCallback"></param>
+        /// <returns></returns>
+        EventActivityBinder<TInstance> IfElse(StateMachineCondition<TInstance> condition,
+            Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> thenActivityCallback,
+            Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> elseActivityCallback);
+
+        /// <summary>
+        /// Create a conditional branch of activities for processing
+        /// </summary>
+        /// <param name="condition"></param>
+        /// <param name="thenActivityCallback"></param>
+        /// <param name="elseActivityCallback"></param>
+        /// <returns></returns>
+        EventActivityBinder<TInstance> IfElseAsync(StateMachineAsyncCondition<TInstance> condition,
+            Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> thenActivityCallback,
+            Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> elseActivityCallback);
     }
 
 
@@ -94,5 +116,27 @@ EventActivityBinder<TInstance, TData> If(StateMachineCondition<TInstance, TData>
         /// <returns></returns>
         EventActivityBinder<TInstance, TData> IfAsync(StateMachineAsyncCondition<TInstance, TData> condition,
             Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> activityCallback);
+
+        /// <summary>
+        /// Create a conditional branch of activities for processing
+        /// </summary>
+        /// <param name="condition"></param>
+        /// <param name="thenActivityCallback"></param>
+        /// <param name="elseActivityCallback"></param>
+        /// <returns></returns>
+        EventActivityBinder<TInstance, TData> IfElse(StateMachineCondition<TInstance, TData> condition,
+            Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> thenActivityCallback,
+            Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> elseActivityCallback);
+
+        /// <summary>
+        /// Create a conditional branch of activities for processing
+        /// </summary>
+        /// <param name="condition"></param>
+        /// <param name="thenActivityCallback"></param>
+        /// <param name="elseActivityCallback"></param>
+        /// <returns></returns>
+        EventActivityBinder<TInstance, TData> IfElseAsync(StateMachineAsyncCondition<TInstance, TData> condition,
+            Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> thenActivityCallback,
+            Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> elseActivityCallback);
     }
 }
\ No newline at end of file
diff --git a/src/Automatonymous/Binders/ExceptionActivityBinder.cs b/src/Automatonymous/Binders/ExceptionActivityBinder.cs
index aaafe35..7178ac0 100644
--- a/src/Automatonymous/Binders/ExceptionActivityBinder.cs
+++ b/src/Automatonymous/Binders/ExceptionActivityBinder.cs
@@ -53,6 +53,28 @@ ExceptionActivityBinder<TInstance, TException> If(StateMachineExceptionCondition
         /// <returns></returns>
         ExceptionActivityBinder<TInstance, TException> IfAsync(StateMachineAsyncExceptionCondition<TInstance, TException> condition,
             Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> activityCallback);
+
+        /// <summary>
+        /// Create a conditional branch of activities for processing
+        /// </summary>
+        /// <param name="condition"></param>
+        /// <param name="thenActivityCallback"></param>
+        /// <param name="elseActivityCallback"></param>
+        /// <returns></returns>
+        ExceptionActivityBinder<TInstance, TException> IfElse(StateMachineExceptionCondition<TInstance, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> thenActivityCallback,
+            Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> elseActivityCallback);
+
+        /// <summary>
+        /// Create a conditional branch of activities for processing
+        /// </summary>
+        /// <param name="condition"></param>
+        /// <param name="thenActivityCallback"></param>
+        /// <param name="elseActivityCallback"></param>
+        /// <returns></returns>
+        ExceptionActivityBinder<TInstance, TException> IfElseAsync(StateMachineAsyncExceptionCondition<TInstance, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> thenActivityCallback,
+            Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> elseActivityCallback);
     }
 
 
@@ -96,5 +118,27 @@ ExceptionActivityBinder<TInstance, TData, TException> If(StateMachineExceptionCo
         /// <returns></returns>
         ExceptionActivityBinder<TInstance, TData, TException> IfAsync(StateMachineAsyncExceptionCondition<TInstance, TData, TException> condition,
             Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> activityCallback);
+
+        /// <summary>
+        /// Create a conditional branch of activities for processing
+        /// </summary>
+        /// <param name="condition"></param>
+        /// <param name="thenActivityCallback"></param>
+        /// <param name="elseActivityCallback"></param>
+        /// <returns></returns>
+        ExceptionActivityBinder<TInstance, TData, TException> IfElse(StateMachineExceptionCondition<TInstance, TData, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> thenActivityCallback,
+            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> elseActivityCallback);
+
+        /// <summary>
+        /// Create a conditional branch of activities for processing
+        /// </summary>
+        /// <param name="condition"></param>
+        /// <param name="thenActivityCallback"></param>
+        /// <param name="elseActivityCallback"></param>
+        /// <returns></returns>
+        ExceptionActivityBinder<TInstance, TData, TException> IfElseAsync(StateMachineAsyncExceptionCondition<TInstance, TData, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> thenActivityCallback,
+            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> elseActivityCallback);
     }
 }
\ No newline at end of file
diff --git a/src/Automatonymous/Binders/TriggerEventActivityBinder.cs b/src/Automatonymous/Binders/TriggerEventActivityBinder.cs
index 946f984..2b36e9a 100644
--- a/src/Automatonymous/Binders/TriggerEventActivityBinder.cs
+++ b/src/Automatonymous/Binders/TriggerEventActivityBinder.cs
@@ -79,27 +79,45 @@ EventActivityBinder<TInstance> EventActivityBinder<TInstance>.Catch<T>(
         EventActivityBinder<TInstance> EventActivityBinder<TInstance>.If(StateMachineCondition<TInstance> condition,
             Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> activityCallback)
         {
-            EventActivityBinder<TInstance> binder = new TriggerEventActivityBinder<TInstance>(_machine, _event);
+            return IfElse(condition, activityCallback, _ => _);
+        }
 
-            binder = activityCallback(binder);
+        EventActivityBinder<TInstance> EventActivityBinder<TInstance>.IfAsync(StateMachineAsyncCondition<TInstance> condition,
+            Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> activityCallback)
+        {
+            return IfElseAsync(condition, activityCallback, _ => _);
+        }
+
+        public EventActivityBinder<TInstance> IfElse(StateMachineCondition<TInstance> condition,
+            Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> thenActivityCallback,
+            Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> elseActivityCallback)
+        {
+            var thenBinder = GetBinder(thenActivityCallback);
+            var elseBinder = GetBinder(elseActivityCallback);
 
-            var conditionBinder = new ConditionalActivityBinder<TInstance>(_event, condition, binder);
+            var conditionBinder = new ConditionalActivityBinder<TInstance>(_event, condition, thenBinder, elseBinder);
 
             return new TriggerEventActivityBinder<TInstance>(_machine, _event, _filter, _activities, conditionBinder);
         }
 
-        EventActivityBinder<TInstance> EventActivityBinder<TInstance>.IfAsync(StateMachineAsyncCondition<TInstance> condition,
-            Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> activityCallback)
+        public EventActivityBinder<TInstance> IfElseAsync(StateMachineAsyncCondition<TInstance> condition,
+            Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> thenActivityCallback,
+            Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> elseActivityCallback)
         {
-            EventActivityBinder<TInstance> binder = new TriggerEventActivityBinder<TInstance>(_machine, _event);
-
-            binder = activityCallback(binder);
+            var thenBinder = GetBinder(thenActivityCallback);
+            var elseBinder = GetBinder(elseActivityCallback);
 
-            var conditionBinder = new ConditionalActivityBinder<TInstance>(_event, condition, binder);
+            var conditionBinder = new ConditionalActivityBinder<TInstance>(_event, condition, thenBinder, elseBinder);
 
             return new TriggerEventActivityBinder<TInstance>(_machine, _event, _filter, _activities, conditionBinder);
         }
 
+        private EventActivityBinder<TInstance> GetBinder(Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> activityCallback)
+        {
+            EventActivityBinder<TInstance> binder = new TriggerEventActivityBinder<TInstance>(_machine, _event);
+            return activityCallback(binder);
+        }
+
         StateMachine<TInstance> EventActivityBinder<TInstance>.StateMachine => _machine;
 
         public IEnumerable<ActivityBinder<TInstance>> GetStateActivityBinders()
@@ -112,9 +130,10 @@ public IEnumerable<ActivityBinder<TInstance>> GetStateActivityBinders()
 
         ActivityBinder<TInstance> CreateConditionalActivityBinder()
         {
-            EventActivityBinder<TInstance> binder = new TriggerEventActivityBinder<TInstance>(_machine, _event, _activities);
+            EventActivityBinder<TInstance> thenBinder = new TriggerEventActivityBinder<TInstance>(_machine, _event, _activities);
+            EventActivityBinder<TInstance> elseBinder = new TriggerEventActivityBinder<TInstance>(_machine, _event);
 
-            var conditionBinder = new ConditionalActivityBinder<TInstance>(_event, context => _filter(context), binder);
+            var conditionBinder = new ConditionalActivityBinder<TInstance>(_event, context => _filter(context), thenBinder, elseBinder);
 
             return conditionBinder;
         }