diff --git a/iree/task/executor.c b/iree/task/executor.c
index 13d6b27..267b681 100644
--- a/iree/task/executor.c
+++ b/iree/task/executor.c
@@ -270,6 +270,17 @@
   IREE_TRACE_ZONE_BEGIN(z0);
   iree_task_t* task = NULL;
   while ((task = iree_task_list_pop_front(&pending_submission->ready_list))) {
+    // If the scope has been marked as failing then we abort the task.
+    // This needs to happen as a poll here because one or more of the tasks we
+    // are joining may have failed.
+    if (IREE_UNLIKELY(iree_task_scope_has_failed(task->scope))) {
+      iree_task_list_t discard_worklist;
+      iree_task_list_initialize(&discard_worklist);
+      iree_task_discard(task, &discard_worklist);
+      iree_task_list_discard(&discard_worklist);
+      continue;
+    }
+
     switch (task->type) {
       case IREE_TASK_TYPE_NOP:
         // Doesn't do anything; just retire and continue on to any dependents.
diff --git a/iree/task/task.c b/iree/task/task.c
index 02cb20d..537fc77 100644
--- a/iree/task/task.c
+++ b/iree/task/task.c
@@ -326,33 +326,18 @@
                               iree_task_submission_t* pending_submission) {
   IREE_TRACE_ZONE_BEGIN(z0);
 
-  // If the scope has been marked as failing then we abort the barrier.
-  // This needs to happen as a poll here because one or more of the tasks we
-  // are joining may have failed.
-  const bool has_failed = iree_task_scope_has_failed(task->header.scope);
-  if (has_failed) {
-    // This was the last pending dependency and we know that we can safely
-    // abort the completion task by discarding.
-    iree_task_list_t discard_worklist;
-    iree_task_list_initialize(&discard_worklist);
-    iree_task_barrier_discard(task, &discard_worklist);
-    iree_task_list_discard(&discard_worklist);
-  } else {
-    // NOTE: we walk in reverse so that we enqueue in LIFO order.
-    for (iree_host_size_t i = 0; i < task->dependent_task_count; ++i) {
-      iree_task_t* dependent_task =
-          task->dependent_tasks[task->dependent_task_count - i - 1];
-      if (iree_atomic_fetch_sub_int32(&dependent_task->pending_dependency_count,
-                                      1, iree_memory_order_acq_rel) == 1) {
-        // The dependent task has retired and can now be made ready.
-        iree_task_submission_enqueue(pending_submission, dependent_task);
-      }
+  // NOTE: we walk in reverse so that we enqueue in LIFO order.
+  for (iree_host_size_t i = 0; i < task->dependent_task_count; ++i) {
+    iree_task_t* dependent_task =
+        task->dependent_tasks[task->dependent_task_count - i - 1];
+    if (iree_atomic_fetch_sub_int32(&dependent_task->pending_dependency_count,
+                                    1, iree_memory_order_acq_rel) == 1) {
+      // The dependent task has retired and can now be made ready.
+      iree_task_submission_enqueue(pending_submission, dependent_task);
     }
   }
 
-  iree_task_retire(&task->header, pending_submission,
-                   has_failed ? iree_status_from_code(IREE_STATUS_ABORTED)
-                              : iree_ok_status());
+  iree_task_retire(&task->header, pending_submission, iree_ok_status());
 
   IREE_TRACE_ZONE_END(z0);
 }
diff --git a/iree/task/task_test_fence.cc b/iree/task/task_test_fence.cc
index 95ddea4..6626378 100644
--- a/iree/task/task_test_fence.cc
+++ b/iree/task/task_test_fence.cc
@@ -11,8 +11,13 @@
 
 namespace {
 
+using iree::Status;
+using iree::StatusCode;
+using iree::testing::status::StatusIs;
+
 class TaskFenceTest : public TaskTest {};
 
+// Tests a chain of fences A -> B -> C.
 TEST_F(TaskFenceTest, IssueChained) {
   iree_task_fence_t task_a;
   iree_task_fence_initialize(&scope_, &task_a);
@@ -28,4 +33,46 @@
   IREE_ASSERT_OK(SubmitTasksAndWaitIdle(&task_a.header, &task_c.header));
 }
 
+// Tests that failures propagate through fences; task B should not be called.
+// A fails -> fence -> B
+TEST_F(TaskFenceTest, IssueChainedFailure) {
+  int did_call_a = 0;
+  iree_task_call_t task_a;
+  iree_task_call_initialize(&scope_,
+                            iree_task_make_call_closure(
+                                [](void* user_context, iree_task_t* task,
+                                   iree_task_submission_t* pending_submission) {
+                                  int* did_call_ptr = (int*)user_context;
+                                  ++(*did_call_ptr);
+                                  return iree_make_status(IREE_STATUS_DATA_LOSS,
+                                                          "whoops!");
+                                },
+                                &did_call_a),
+                            &task_a);
+
+  iree_task_fence_t fence_task;
+  iree_task_fence_initialize(&scope_, &fence_task);
+  iree_task_set_completion_task(&task_a.header, &fence_task.header);
+
+  int did_call_b = 0;
+  iree_task_call_t task_b;
+  iree_task_call_initialize(&scope_,
+                            iree_task_make_call_closure(
+                                [](void* user_context, iree_task_t* task,
+                                   iree_task_submission_t* pending_submission) {
+                                  int* did_call_ptr = (int*)user_context;
+                                  ++(*did_call_ptr);
+                                  return iree_ok_status();
+                                },
+                                &did_call_b),
+                            &task_b);
+  iree_task_set_completion_task(&fence_task.header, &task_b.header);
+
+  IREE_ASSERT_OK(SubmitTasksAndWaitIdle(&task_a.header, &task_b.header));
+  EXPECT_EQ(1, did_call_a);
+  EXPECT_EQ(0, did_call_b);
+  EXPECT_THAT(Status(iree_task_scope_consume_status(&scope_)),
+              StatusIs(StatusCode::kDataLoss));
+}
+
 }  // namespace