diff --git a/src/Access/WorkflowParticipantsAccessChecker.php b/src/Access/WorkflowParticipantsAccessChecker.php
index eb2718d..46d2052 100644
--- a/src/Access/WorkflowParticipantsAccessChecker.php
+++ b/src/Access/WorkflowParticipantsAccessChecker.php
@@ -54,28 +54,9 @@ class WorkflowParticipantsAccessChecker implements AccessInterface {
    * @todo Don't hard-code for node.
    */
   public function access(AccountInterface $account, NodeInterface $node) {
-    // If this entity cannot be moderated, deny access.
-    if (!$this->moderationInfo->isModeratedEntity($node)) {
-      return AccessResultForbidden::forbidden()->addCacheableDependency($node);
-    }
-
-    if ($account->hasPermission('manage workflow participants')) {
-      return AccessResultAllowed::allowed()->addCacheableDependency($node);
-    }
-
-    if ($node instanceof EntityOwnerInterface) {
-      // Allowed if user is a participant on the current entity. Further access
-      // for editors and reviewers is controlled at the form level.
-      $participants = $this->participantStorage->loadForModeratedEntity($node);
-      if ($participants->isEditor($account) || $participants->isReviewer($account)) {
-        return AccessResult::allowed()->addCacheableDependency($node);
-      }
-
-      // Allowed if user is the author and has appropriate permission.
-      return AccessResult::allowedIfHasPermission($account, 'manage own workflow participants')->andIf(AccessResult::allowedIf($node->getOwnerId() == $account->id()))->addCacheableDependency($node);
-    }
-
-    return AccessResult::forbidden()->addCacheableDependency($node);
+    $participants = $this->participantStorage->loadForModeratedEntity($node);
+    // Use 'view' access, since update permissions are handled by the form.
+    return $participants->access('view', $account, TRUE);
   }
 
   /**
diff --git a/src/Form/WorkflowParticipantsForm.php b/src/Form/WorkflowParticipantsForm.php
index 5ae7afa..c433c64 100644
--- a/src/Form/WorkflowParticipantsForm.php
+++ b/src/Form/WorkflowParticipantsForm.php
@@ -149,13 +149,10 @@ class WorkflowParticipantsForm extends ContentEntityForm {
    */
   public function checkAccess(array $form, FormStateInterface $form_state) {
     $entity = $this->entity->getModeratedEntity();
-    // @todo Entity access to the workflow participants entity should work
-    // here, but that isn't sorted out. Instead call the route access callback.
-    $access_checker = \Drupal::service('workflow_participants.access_checker');
     if (!$entity->access('view')) {
       $form_state->setRedirect('<front>');
     }
-    elseif (!$access_checker->access($this->currentUser(), $entity) instanceof AccessResultAllowed) {
+    elseif (!$this->entity->access('view')) {
       // User might still have access to view, but not the tab. In this case,
       // redirect to the entity.
       $form_state->setRedirectUrl($entity->toUrl());
diff --git a/src/WorkflowParticipantsAccessControlHandler.php b/src/WorkflowParticipantsAccessControlHandler.php
index 6f7cd10..31adefc 100644
--- a/src/WorkflowParticipantsAccessControlHandler.php
+++ b/src/WorkflowParticipantsAccessControlHandler.php
@@ -2,16 +2,53 @@
 
 namespace Drupal\workflow_participants;
 
+use Drupal\content_moderation\ModerationInformationInterface;
+use Drupal\Core\Access\AccessResult;
+use Drupal\Core\Access\AccessResultAllowed;
+use Drupal\Core\Access\AccessResultForbidden;
 use Drupal\Core\Entity\EntityAccessControlHandler;
+use Drupal\Core\Entity\EntityHandlerInterface;
 use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Entity\EntityTypeInterface;
 use Drupal\Core\Session\AccountInterface;
+use Drupal\user\EntityOwnerInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
 
 /**
  * Access controller for the workflow participants entity.
  *
  * @see \Drupal\workflow_participants\Entity\WorkflowParticipants
  */
-class WorkflowParticipantsAccessControlHandler extends EntityAccessControlHandler {
+class WorkflowParticipantsAccessControlHandler extends EntityAccessControlHandler implements EntityHandlerInterface {
+
+  /**
+   * The moderation information service.
+   *
+   * @var \Drupal\content_moderation\ModerationInformationInterface
+   */
+  protected $moderationInfo;
+
+  /**
+   * Construct the access checker.
+   *
+   * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type
+   *   The entity type definition.
+   * @param \Drupal\content_moderation\ModerationInformationInterface $moderation_information
+   *   The moderation information service.
+   */
+  public function __construct(EntityTypeInterface $entity_type, ModerationInformationInterface $moderation_information) {
+    parent::__construct($entity_type);
+    $this->moderationInfo = $moderation_information;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  public static function createInstance(ContainerInterface $container, EntityTypeInterface $entity_type) {
+    return new static(
+      $entity_type,
+      $container->get('content_moderation.moderation_information')
+    );
+  }
 
   /**
    * {@inheritdoc}
@@ -19,6 +56,28 @@ class WorkflowParticipantsAccessControlHandler extends EntityAccessControlHandle
   protected function checkAccess(EntityInterface $entity, $operation, AccountInterface $account) {
     $admin_access = parent::checkAccess($entity, $operation, $account);
 
+    /** @var \Drupal\workflow_participants\Entity\WorkflowParticipantsInterface $entity */
+    $moderated_entity = $entity->getModeratedEntity();
+    if (!$this->moderationInfo->isModeratedEntity($moderated_entity)) {
+      // If this entity cannot be moderated, deny access.
+      return AccessResultForbidden::forbidden()->addCacheableDependency($moderated_entity);
+    }
+
+    if ($account->hasPermission('manage workflow participants')) {
+      return AccessResultAllowed::allowed()->addCacheableDependency($moderated_entity);
+    }
+
+    if ($moderated_entity instanceof EntityOwnerInterface) {
+      // Allowed if user is a participant on the current entity. Further access
+      // for editors and reviewers is controlled at the form level.
+      if ($entity->isEditor($account) || $entity->isReviewer($account)) {
+        return AccessResultAllowed::allowed()->addCacheableDependency($moderated_entity);
+      }
+
+      // Allowed if user is the author and has appropriate permission.
+      return AccessResult::allowedIfHasPermission($account, 'manage own workflow participants')->andIf(AccessResult::allowedIf($moderated_entity->getOwnerId() == $account->id()))->addCacheableDependency($moderated_entity);
+    }
+
     return $admin_access;
   }