diff --git a/src/developer/debug/shared/event_handlers.cc b/src/developer/debug/shared/event_handlers.cc
index 8dcf5e96..e481db0 100644
--- a/src/developer/debug/shared/event_handlers.cc
+++ b/src/developer/debug/shared/event_handlers.cc
@@ -6,6 +6,7 @@
 
 #include <lib/async-loop/loop.h>
 #include <lib/async/default.h>
+#include <lib/zx/exception.h>
 
 #include "src/developer/debug/shared/logging/logging.h"
 #include "src/developer/debug/shared/message_loop_target.h"
@@ -15,6 +16,28 @@
 
 namespace debug_ipc {
 
+namespace {
+
+// |signals| are the signals we're going to observe.
+std::unique_ptr<async_wait_t>
+CreateSignalHandle(int id, zx_handle_t object, zx_signals_t signals,
+                   SignalHandlerFunc handler_func) {
+  auto handle = std::make_unique<async_wait_t>();
+  *handle = {};  // Need to zero it out.
+  handle->handler = handler_func;
+  handle->object = object;
+  handle->trigger = signals;
+
+  return handle;
+}
+
+// Sets a particular signal handler to start listening on the async loop.
+zx_status_t StartListening(async_wait_t* signal_handle) {
+  return async_begin_wait(async_get_default_dispatcher(), signal_handle);
+}
+
+}  // namespace
+
 // SignalHandler ---------------------------------------------------------------
 
 SignalHandler::SignalHandler() = default;
@@ -32,26 +55,23 @@
 
 zx_status_t SignalHandler::Init(int id, zx_handle_t object,
                                 zx_signals_t signals) {
-  handle_ = std::make_unique<async_wait_t>();
-  *handle_ = {};  // Need to zero it out.
-  handle_->handler = Handler;
-  handle_->object = object;
-  handle_->trigger = signals;
-
+  handle_ = CreateSignalHandle(id, object, signals, Handler);
   watch_info_id_ = id;
-  return WaitForSignals();
+
+  // We start listening.
+  return StartListening(handle_.get());
 }
 
-zx_status_t SignalHandler::WaitForSignals() const {
-  async_wait_t* wait = handle_.get();
-  zx_status_t status = async_begin_wait(async_get_default_dispatcher(), wait);
-  return status;
-}
-
+// static
 void SignalHandler::Handler(async_dispatcher_t*, async_wait_t* wait,
                             zx_status_t status,
                             const zx_packet_signal_t* signal) {
-  FXL_DCHECK(status == ZX_OK);
+  if (status != ZX_OK) {
+    FXL_LOG(WARNING) << "Got error on receiving exception: "
+                     << ZxStatusToString(status);
+    FXL_NOTREACHED();
+    return;
+  }
 
   auto* loop = MessageLoopTarget::Current();
   FXL_DCHECK(loop);
@@ -66,7 +86,8 @@
   FXL_DCHECK(watch_info);
 
   // async-loop will remove the handler for this event, so we need to re-add it.
-  signal_handler.WaitForSignals();
+  status = StartListening(signal_handler.handle_.get());
+  FXL_DCHECK(status == ZX_OK) << "Got: " << ZxStatusToString(status);
   switch (watch_info->type) {
     case WatchType::kFdio:
       loop->OnFdioSignal(watch_info_id, *watch_info, signal->observed);
@@ -126,6 +147,7 @@
   return status;
 }
 
+// static
 void ExceptionHandler::Handler(async_dispatcher_t*,
                                async_exception_t* exception, zx_status_t status,
                                const zx_port_packet_t* packet) {
@@ -169,24 +191,80 @@
 
 ChannelExceptionHandler::ChannelExceptionHandler(ChannelExceptionHandler&&) =
     default;
+
 ChannelExceptionHandler& ChannelExceptionHandler::operator=(
     ChannelExceptionHandler&&) = default;
 
 zx_status_t ChannelExceptionHandler::Init(int id, zx_handle_t object,
                                           zx_signals_t signals) {
-  FXL_NOTREACHED() << "Not implemented.";
-  return ZX_ERR_NOT_SUPPORTED;
+  zx_status_t status = zx_task_create_exception_channel(
+      object, ZX_EXCEPTION_CHANNEL_DEBUGGER,
+      exception_channel_.reset_and_get_address());
+  if (status != ZX_OK)
+    return status;
+
+  handle_ = CreateSignalHandle(id, exception_channel_.get(), signals, Handler);
+  watch_info_id_ = id;
+  return StartListening(handle_.get());
 }
 
-zx_status_t ChannelExceptionHandler::WaitForSignals() const {
-  FXL_NOTREACHED() << "Not implemented.";
-  return ZX_ERR_NOT_SUPPORTED;
-}
-
-void ChannelExceptionHandler::Handler(async_dispatcher_t*, async_wait_t* wait,
-                                      zx_status_t status,
+// static
+void ChannelExceptionHandler::Handler(async_dispatcher_t* dispatcher,
+                                      async_wait_t* wait, zx_status_t status,
                                       const zx_packet_signal_t* signal) {
-  FXL_NOTREACHED() << "Not implemented.";
+  if (status != ZX_OK) {
+    FXL_LOG(WARNING) << "Got error on receiving exception: "
+                     << ZxStatusToString(status);
+    FXL_NOTREACHED();
+    return;
+  }
+
+  auto* loop = MessageLoopTarget::Current();
+  FXL_DCHECK(loop);
+
+  // Search for the AsyncHandle that triggered this signal.
+  auto handler_it = loop->exception_channel_handlers().find(wait);
+  FXL_DCHECK(handler_it != loop->exception_channel_handlers().end());
+  const ChannelExceptionHandler& handler = handler_it->second;
+
+  int watch_info_id = handler.watch_info_id();
+  auto* watch_info = loop->FindWatchInfo(watch_info_id);
+  FXL_DCHECK(watch_info);
+
+  // async-loop will remove the handler for this event, so we need to re-add it.
+  status = StartListening(handler.handle_.get());
+  FXL_DCHECK(status == ZX_OK) << "Got: " << ZxStatusToString(status);
+
+  // We should only receive exceptions here.
+  if (watch_info->type != WatchType::kProcessExceptions &&
+      watch_info->type != WatchType::kJobExceptions) {
+    FXL_NOTREACHED() << "Should only watch for exceptions on this handler.";
+    return;
+  }
+
+  bool peer_closed = signal->observed & ZX_CHANNEL_PEER_CLOSED;
+  bool readable = signal->observed & ZX_CHANNEL_READABLE;
+
+  FXL_DCHECK(peer_closed || readable);
+  if (peer_closed)
+    return;
+
+  // We obtain the exception from the channel.
+  zx::exception exception;
+  zx_exception_info_t exception_info;
+
+  status = handler.exception_channel_.read(0, &exception_info,
+                                           exception.reset_and_get_address(),
+                                           sizeof(exception_info), 1,
+                                           nullptr, nullptr);
+  if (status != ZX_OK) {
+    FXL_LOG(WARNING) << "Got error when reading from exception channel: "
+                     << ZxStatusToString(status);
+    FXL_NOTREACHED();
+    return;
+  }
+
+  loop->HandleChannelException(handler, std::move(exception), exception_info);
 }
 
 }  // namespace debug_ipc
diff --git a/src/developer/debug/shared/event_handlers.h b/src/developer/debug/shared/event_handlers.h
index cbf5c1e..be1224c 100644
--- a/src/developer/debug/shared/event_handlers.h
+++ b/src/developer/debug/shared/event_handlers.h
@@ -7,11 +7,15 @@
 
 #include <lib/async/cpp/exception.h>
 #include <lib/async/cpp/wait.h>
+#include <lib/zx/channel.h>
 
 #include <memory>
 
 #include "src/lib/fxl/macros.h"
 
+// Group of classes dedicated at handling async events associated with zircon's
+// message loop.
+
 namespace debug_ipc {
 
 enum class WatchType : uint32_t;
@@ -22,8 +26,10 @@
 // 0 is an invalid ID for watchers, so is safe to use here.
 constexpr uint64_t kTaskSignalKey = 0;
 
-// Group of classes dedicated at handling async events associated with zircon's
-// message loop.
+
+// Function called when a SignalHandler gets a signal it's waiting for.
+using SignalHandlerFunc = void (*)(async_dispatcher_t*, async_wait_t*,
+                                   zx_status_t, const zx_packet_signal_t*);
 
 class SignalHandler {
  public:
@@ -43,8 +49,6 @@
   const async_wait_t* handle() const { return handle_.get(); }
 
  private:
-  zx_status_t WaitForSignals() const;
-
   int watch_info_id_ = -1;
   std::unique_ptr<async_wait_t> handle_;
 };
@@ -90,11 +94,11 @@
   const async_wait_t* handle() const { return handle_.get(); }
 
  private:
-  zx_status_t WaitForSignals() const;
-
   int watch_info_id_ = -1;
   std::unique_ptr<async_wait_t> handle_;
 
+  zx::channel exception_channel_;
+
   FXL_DISALLOW_COPY_AND_ASSIGN(ChannelExceptionHandler);
 };
 
diff --git a/src/developer/debug/shared/message_loop_target.cc b/src/developer/debug/shared/message_loop_target.cc
index f6c747c..7de8e59 100644
--- a/src/developer/debug/shared/message_loop_target.cc
+++ b/src/developer/debug/shared/message_loop_target.cc
@@ -375,6 +375,40 @@
   }
 }
 
+void MessageLoopTarget::HandleChannelException(
+    const ChannelExceptionHandler& handler, zx::exception&& exception,
+    zx_exception_info_t exception_info) {
+  WatchInfo* watch_info = nullptr;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto it = watches_.find(handler.watch_info_id());
+    FXL_DCHECK(it != watches_.end());
+    watch_info = &it->second;
+  }
+
+  if (watch_info->type != WatchType::kProcessExceptions &&
+      watch_info->type != WatchType::kJobExceptions) {
+    FXL_NOTREACHED() << "Should only receive exceptions.";
+    return;
+  }
+
+  // We should only receive exceptions here.
+  switch (watch_info->type) {
+    case WatchType::kTask:
+    case WatchType::kFdio:
+    case WatchType::kSocket:
+      FXL_NOTREACHED() << "Should only receive exceptions.";
+      return;
+    case WatchType::kProcessExceptions:
+    case WatchType::kJobExceptions:
+      break;
+  }
+
+  FXL_DCHECK(watch_info->exception_watcher);
+  watch_info->exception_watcher->OnException(std::move(exception),
+                                             exception_info);
+}
+
 uint64_t MessageLoopTarget::GetMonotonicNowNS() const {
   zx::time ret;
   zx::clock::get(&ret);
diff --git a/src/developer/debug/shared/message_loop_target.h b/src/developer/debug/shared/message_loop_target.h
index 44790d5..58bece2 100644
--- a/src/developer/debug/shared/message_loop_target.h
+++ b/src/developer/debug/shared/message_loop_target.h
@@ -10,6 +10,7 @@
 #include <lib/zx/event.h>
 #include <lib/zx/port.h>
 #include <lib/zx/thread.h>
+#include <zircon/syscalls/exception.h>
 
 #include <vector>
 
@@ -133,8 +134,9 @@
   void HandleException(const ExceptionHandler&, zx_port_packet_t packet);
 
   // Handlers exceptions channel.
-  void HandleExceptionChannel(const ChannelExceptionHandler&,
-                              zx::exception&& exception);
+  void HandleChannelException(const ChannelExceptionHandler&,
+                              zx::exception&& exception,
+                              zx_exception_info_t exception_info);
 
   // Handle an event of the given type.
   void OnFdioSignal(int watch_id, const WatchInfo& info, zx_signals_t observed);
@@ -200,6 +202,7 @@
 
   friend class SignalHandler;
   friend class ExceptionHandler;
+  friend class ChannelExceptionHandler;
 };
 
 // EventHandlers need access to the WatchInfo implementation.
diff --git a/src/developer/debug/shared/zircon_exception_watcher.h b/src/developer/debug/shared/zircon_exception_watcher.h
index 6be254e..08dba9a 100644
--- a/src/developer/debug/shared/zircon_exception_watcher.h
+++ b/src/developer/debug/shared/zircon_exception_watcher.h
@@ -7,6 +7,9 @@
 
 #include <zircon/types.h>
 
+#include <zircon/syscalls/exception.h>
+#include <lib/zx/exception.h>
+
 namespace debug_ipc {
 
 // Callbacks for exceptions from a process exception port.
@@ -20,6 +23,10 @@
   virtual void OnThreadExiting(zx_koid_t process_koid, zx_koid_t thread_koid) {}
   virtual void OnException(zx_koid_t process_koid, zx_koid_t thread_koid,
                            uint32_t type) {}
+
+  // New exception handling that uses the exception tokens.
+  virtual void OnException(zx::exception&& exception_token,
+                           zx_exception_info_t exception_info) {}
 };
 
 }  // namespace debug_ipc