diff --git a/common/async.go b/common/async.go
index 31dc2e96..49714d95 100644
--- a/common/async.go
+++ b/common/async.go
@@ -15,7 +15,6 @@ type Task func(i int) (val interface{}, err error, abort bool)
 type TaskResult struct {
 	Value interface{}
 	Error error
-	Panic interface{}
 }
 
 type TaskResultCh <-chan TaskResult
@@ -92,17 +91,6 @@ func (trs *TaskResultSet) FirstError() error {
 	return nil
 }
 
-// Returns the firstmost (by task index) panic as
-// discovered by all previous Reap() calls.
-func (trs *TaskResultSet) FirstPanic() interface{} {
-	for _, result := range trs.results {
-		if result.Panic != nil {
-			return result.Panic
-		}
-	}
-	return nil
-}
-
 //----------------------------------------
 // Parallel
 
@@ -128,7 +116,7 @@ func Parallel(tasks ...Task) (trs *TaskResultSet, ok bool) {
 			defer func() {
 				if pnk := recover(); pnk != nil {
 					atomic.AddInt32(numPanics, 1)
-					taskResultCh <- TaskResult{nil, nil, pnk}
+					taskResultCh <- TaskResult{nil, ErrorWrap(pnk, "Panic in task")}
 					taskDoneCh <- false
 				}
 			}()
@@ -136,7 +124,7 @@ func Parallel(tasks ...Task) (trs *TaskResultSet, ok bool) {
 			var val, err, abort = task(i)
 			// Send val/err to taskResultCh.
 			// NOTE: Below this line, nothing must panic/
-			taskResultCh <- TaskResult{val, err, nil}
+			taskResultCh <- TaskResult{val, err}
 			// Decrement waitgroup.
 			taskDoneCh <- abort
 		}(i, task, taskResultCh)
diff --git a/common/async_test.go b/common/async_test.go
index 2e8db26e..8d41ec35 100644
--- a/common/async_test.go
+++ b/common/async_test.go
@@ -37,9 +37,6 @@ func TestParallel(t *testing.T) {
 		} else if taskResult.Error != nil {
 			assert.Fail(t, "Task should not have errored but got %v", taskResult.Error)
 			failedTasks += 1
-		} else if taskResult.Panic != nil {
-			assert.Fail(t, "Task should not have panic'd but got %v", taskResult.Panic)
-			failedTasks += 1
 		} else if !assert.Equal(t, -1*i, taskResult.Value.(int)) {
 			assert.Fail(t, "Task should have returned %v but got %v", -1*i, taskResult.Value.(int))
 			failedTasks += 1
@@ -49,7 +46,6 @@ func TestParallel(t *testing.T) {
 	}
 	assert.Equal(t, failedTasks, 0, "No task should have failed")
 	assert.Nil(t, trs.FirstError(), "There should be no errors")
-	assert.Nil(t, trs.FirstPanic(), "There should be no panics")
 	assert.Equal(t, 0, trs.FirstValue(), "First value should be 0")
 }
 
@@ -132,8 +128,13 @@ func checkResult(t *testing.T, taskResultSet *TaskResultSet, index int, val inte
 	taskName := fmt.Sprintf("Task #%v", index)
 	assert.True(t, ok, "TaskResultCh unexpectedly closed for %v", taskName)
 	assert.Equal(t, val, taskResult.Value, taskName)
-	assert.Equal(t, err, taskResult.Error, taskName)
-	assert.Equal(t, pnk, taskResult.Panic, taskName)
+	if err != nil {
+		assert.Equal(t, err, taskResult.Error, taskName)
+	} else if pnk != nil {
+		assert.Equal(t, pnk, taskResult.Error.(Error).Cause(), taskName)
+	} else {
+		assert.Nil(t, taskResult.Error, taskName)
+	}
 }
 
 // Wait for timeout (no result)