diff --git a/config/schema/page_manager.schema.yml b/config/schema/page_manager.schema.yml
index 49e5cfc..95b1483 100644
--- a/config/schema/page_manager.schema.yml
+++ b/config/schema/page_manager.schema.yml
@@ -142,3 +142,12 @@ display_variant.plugin.http_status_code:
     redirect_location:
       type: string
       label: 'Redirect location'
+
+display_variant.plugin.layout_builder:
+  type: display_variant.plugin
+  label: 'Layout Builder'
+  mapping:
+    sections:
+      type: sequence
+      sequence:
+        type: layout_builder.section
diff --git a/page_manager_ui/src/Form/PageVariantConfigureForm.php b/page_manager_ui/src/Form/PageVariantConfigureForm.php
index a15cb15..8ab9cfc 100644
--- a/page_manager_ui/src/Form/PageVariantConfigureForm.php
+++ b/page_manager_ui/src/Form/PageVariantConfigureForm.php
@@ -42,7 +42,8 @@ class PageVariantConfigureForm extends FormBase {
     ];
 
     $variant_plugin = $page_variant->getVariantPlugin();
-    $form['variant_settings'] = $variant_plugin->buildConfigurationForm([], (new FormState())->setValues($form_state->getValue('variant_settings', [])));
+    // @todo
+    $form['variant_settings'] = $variant_plugin->buildConfigurationForm([], (new FormState())->setValues($form_state->getValue('variant_settings', []) + ['page_variant' => $page_variant]));
     $form['variant_settings']['#tree'] = TRUE;
 
     if (!$page->isNew()) {
diff --git a/src/Annotation/LayoutBuilderStorage.php b/src/Annotation/LayoutBuilderStorage.php
new file mode 100644
index 0000000..f343a62
--- /dev/null
+++ b/src/Annotation/LayoutBuilderStorage.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Drupal\page_manager\Annotation;
+
+use Drupal\Component\Annotation\PluginID;
+
+/**
+ * Defines a Layout Builder storage item annotation object.
+ *
+ * @see \Drupal\page_manager\Storage\PanelsStorageManager
+ * @see plugin_api
+ *
+ * @Annotation
+ */
+class PanelsStorage extends PluginID {
+
+}
diff --git a/src/Entity/LayoutBuilderStorage.php b/src/Entity/LayoutBuilderStorage.php
new file mode 100644
index 0000000..941ef64
--- /dev/null
+++ b/src/Entity/LayoutBuilderStorage.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace Drupal\page_manager\Entity;
+
+use Drupal\Core\Config\Entity\ConfigEntityStorage;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\layout_builder\Section;
+
+/**
+ * Provides storage for page manager entities that have layouts.
+ */
+class LayoutBuilderStorage extends ConfigEntityStorage {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function mapToStorageRecord(EntityInterface $entity) {
+    $record = parent::mapToStorageRecord($entity);
+
+    if (!empty($record['variant_settings']['sections'])) {
+      $record['variant_settings']['sections'] = array_map(function (Section $section) {
+        return $section->toArray();
+      }, $record['variant_settings']['sections']);
+    }
+    return $record;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function mapFromStorageRecords(array $records) {
+    foreach ($records as $id => &$record) {
+      if (!empty($record['variant_settings']['sections'])) {
+        $sections = &$record['variant_settings']['sections'];
+        $sections = array_map([Section::class, 'fromArray'], $sections);
+      }
+    }
+    return parent::mapFromStorageRecords($records);
+  }
+
+}
diff --git a/src/Entity/PageVariant.php b/src/Entity/PageVariant.php
index 58ad7f8..e3db194 100644
--- a/src/Entity/PageVariant.php
+++ b/src/Entity/PageVariant.php
@@ -23,8 +23,12 @@ use Drupal\page_manager\PageVariantInterface;
  *   id = "page_variant",
  *   label = @Translation("Page Variant"),
  *   handlers = {
+ *     "storage" = "Drupal\page_manager\Entity\LayoutBuilderStorage",
  *     "view_builder" = "Drupal\page_manager\Entity\PageVariantViewBuilder",
  *     "access" = "Drupal\page_manager\Entity\PageVariantAccess",
+ *     "form" = {
+ *       "layout_builder" = "Drupal\page_manager\Form\LayoutBuilderForm",
+ *     },
  *   },
  *   admin_permission = "administer pages",
  *   entity_keys = {
diff --git a/src/Form/LayoutBuilderForm.php b/src/Form/LayoutBuilderForm.php
new file mode 100644
index 0000000..f85501f
--- /dev/null
+++ b/src/Form/LayoutBuilderForm.php
@@ -0,0 +1,119 @@
+<?php
+
+namespace Drupal\page_manager\Form;
+
+use Drupal\Core\Form\FormBase;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Plugin\Context\EntityContext;
+use Drupal\layout_builder\Form\PreviewToggleTrait;
+use Drupal\layout_builder\LayoutTempstoreRepositoryInterface;
+use Drupal\layout_builder\SectionStorage\SectionStorageManager;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Provides a form containing the Layout Builder UI for Layout Library.
+ *
+ * @todo Refactor this after https://www.drupal.org/node/3035189 is resolved.
+ */
+class LayoutBuilderForm extends FormBase {
+
+  use PreviewToggleTrait;
+
+  /**
+   * Layout tempstore repository.
+   *
+   * @var \Drupal\layout_builder\LayoutTempstoreRepositoryInterface
+   */
+  protected $layoutTempstoreRepository;
+
+  /**
+   * The Section Storage Manager
+   *
+   * @var \Drupal\layout_builder\SectionStorage\SectionStorageManager
+   */
+  protected $sectionStorageManager;
+
+  /**
+   * The section storage.
+   *
+   * @var \Drupal\layout_builder\SectionStorageInterface
+   */
+  protected $sectionStorage;
+
+  /**
+   * Constructs a new DefaultsEntityForm.
+   *
+   * @param \Drupal\layout_builder\LayoutTempstoreRepositoryInterface $layout_tempstore_repository
+   *   The layout tempstore repository.
+   * @param \Drupal\Core\Entity\EntityType $entity_type
+   */
+  public function __construct(LayoutTempstoreRepositoryInterface $layout_tempstore_repository, SectionStorageManager $section_storage_manager) {
+    $this->layoutTempstoreRepository = $layout_tempstore_repository;
+    $this->sectionStorageManager = $section_storage_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFormId() {
+    return 'page_manager_layout_builder_form';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container) {
+    return new static(
+      $container->get('layout_builder.tempstore_repository'),
+      $container->get('plugin.manager.layout_builder.section_storage')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildForm(array $form, FormStateInterface $form_state) {
+    $page_variant = $form_state->getTemporaryValue('wizard')['page_variant'];
+
+    $section_storage = $this->sectionStorageManager->load('page_manager', [
+      'page_variant' => EntityContext::fromEntity($page_variant),
+    ]);
+
+    $section_storage = $this->layoutTempstoreRepository->get($section_storage);
+
+    $form['layout_builder'] = [
+      '#type' => 'layout_builder',
+      '#section_storage' => $section_storage,
+    ];
+    $this->sectionStorage = $section_storage;
+    return $form;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+    $this->sectionStorage->save();
+
+    // \Drupal\ctools\Wizard\EntityFormWizardBase::finish will fetch the page
+    // from the form temporary values. Let's update that with the new values.
+    $cached_values = $form_state->getTemporaryValue('wizard');
+    // Override with the updated variant.
+    $cached_values['page']->addVariant($this->sectionStorage->getContextValue('page_variant'));
+    $form_state->setTemporaryValue('wizard', $cached_values);
+
+    $this->layoutTempstoreRepository->delete($this->sectionStorage);
+    $this->messenger()->addMessage($this->t('The layout has been saved.'));
+  }
+
+  /**
+   * Retrieves the section storage object.
+   *
+   * @return \Drupal\layout_builder\SectionStorageInterface
+   *   The section storage for the current form.
+   */
+  public function getSectionStorage() {
+    return $this->sectionStorage;
+  }
+
+}
diff --git a/src/Plugin/DisplayVariant/LayoutBuilderDisplayVariant.php b/src/Plugin/DisplayVariant/LayoutBuilderDisplayVariant.php
new file mode 100644
index 0000000..0493b78
--- /dev/null
+++ b/src/Plugin/DisplayVariant/LayoutBuilderDisplayVariant.php
@@ -0,0 +1,80 @@
+<?php
+
+namespace Drupal\page_manager\Plugin\DisplayVariant;
+
+use Drupal\Core\Display\VariantBase;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\ctools\Plugin\PluginWizardInterface;
+use Drupal\layout_builder\SectionStorage\SectionStorageTrait;
+use Drupal\page_manager\Form\LayoutBuilderForm;
+
+/**
+ * Provides a Layout Builder variant.
+ *
+ * @DisplayVariant(
+ *   id = "layout_builder",
+ *   admin_label = @Translation("Layout Builder")
+ * )
+ */
+class LayoutBuilderDisplayVariant extends VariantBase implements PluginWizardInterface {
+
+  use SectionStorageTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function build() {
+    $build = [];
+    foreach ($this->getSections() as $delta => $section) {
+      $build[$delta] = $section->toRenderArray();
+    }
+    return $build;
+  }
+
+  public function buildConfigurationForm(array $form, FormStateInterface $form_state) {
+    return $form;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setSections(array $sections) {
+    $this->configuration['sections'] = array_values($sections);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getSections() {
+    if (!isset($this->configuration['sections'])) {
+      $this->configuration['sections'] = [];
+    }
+    return $this->configuration['sections'];
+  }
+
+  /**
+   * Returns instance of the layout plugin used by this page variant.
+   *
+   * @return \Drupal\Core\Layout\LayoutInterface
+   *   A layout plugin instance.
+   */
+  public function getLayout() {
+    if (!isset($this->layout)) {
+      $this->layout = $this->layoutManager->createInstance($this->configuration['layout'], $this->configuration['layout_settings']);
+    }
+    return $this->layout;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getWizardOperations($cached_values) {
+    $operations = [];
+    $operations['layout_builder'] = [
+      'title' => $this->t('Layout Builder'),
+      'form' => LayoutBuilderForm::class,
+    ];
+
+    return $operations;
+  }
+}
diff --git a/src/Plugin/LayoutBuilderStorage/PageManagerLayoutBuilderStorage.php b/src/Plugin/LayoutBuilderStorage/PageManagerLayoutBuilderStorage.php
new file mode 100644
index 0000000..05bb84e
--- /dev/null
+++ b/src/Plugin/LayoutBuilderStorage/PageManagerLayoutBuilderStorage.php
@@ -0,0 +1,122 @@
+<?php
+
+namespace Drupal\panels\Plugin\PanelsStorage;
+
+use Drupal\Core\Access\AccessResult;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\layout_builder\Element\LayoutBuilder;
+use Drupal\page_manager\Plugin\DisplayVariant\LayoutBuilderDisplayVariant;
+use Drupal\panels\Plugin\DisplayVariant\PanelsDisplayVariant;
+use Drupal\panels\Storage\PanelsStorageBase;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * A Layout Builder storage service that stores Layout Builder displays in Page Manager.
+ *
+ * @LayoutBuilderStorage("page_manager")
+ */
+class PageManagerLayoutBuilderStorage extends PluginBase implements ContainerFactoryPluginInterface {
+
+  /**
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  protected $entityTypeManager;
+
+  /**
+   * Constructs a PageManagerLayoutBuilderStorage.
+   *
+   * @param array $configuration
+   *   A configuration array containing information about the plugin instance.
+   * @param string $plugin_id
+   *   The plugin_id for the plugin instance.
+   * @param mixed $plugin_definition
+   *   The plugin implementation definition.
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
+   *   The entity type manager.
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, EntityTypeManagerInterface $entity_type_manager) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+    $this->entityTypeManager = $entity_type_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('entity_type.manager')
+    );
+  }
+
+  /**
+   * Load a page variant entity.
+   *
+   * @param string $id
+   *   The page variant entity's id.
+   *
+   * @return \Drupal\page_manager\PageVariantInterface
+   */
+  protected function loadPageVariant($id) {
+    return $this->entityTypeManager->getStorage('page_variant')->load($id);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function save(LayoutBuilderDisplayVariant $lb_display) {
+    $id = $lb_display->getStorageId();
+    if ($id && ($page_variant = $this->loadPageVariant($id))) {
+      $variant_plugin = $page_variant->getVariantPlugin();
+      if (!($variant_plugin instanceof LayoutBuilderDisplayVariant)) {
+        throw new \Exception("Page variant doesn't use a Panels display variant");
+      }
+      $variant_plugin->setConfiguration($lb_display->getConfiguration());
+      $page_variant->save();
+    }
+    else {
+      throw new \Exception("Couldn't find page variant to store Panels display");
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function load($id) {
+    if ($page_variant = $this->loadPageVariant($id)) {
+      $lb_display = $page_variant->getVariantPlugin();
+
+      // If this page variant doesn't have a Panels display on it, then we treat
+      // it the same as if there was no such page variant.
+      if (!($lb_display instanceof LayoutBuilderDisplayVariant)) {
+        return NULL;
+      }
+
+      // Pass down the contexts because the display has no other way to get them
+      // from the variant.
+      $lb_display->setContexts($page_variant->getContexts());
+
+      return $lb_display;
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function access($id, $op, AccountInterface $account) {
+    if ($op == 'change layout') {
+      $op = 'update';
+    }
+    if ($page_variant = $this->loadPageVariant($id)) {
+      return $page_variant->access($op, $account, TRUE);
+    }
+
+    return AccessResult::forbidden();
+  }
+
+}
diff --git a/src/Plugin/SectionStorage/PageManager.php b/src/Plugin/SectionStorage/PageManager.php
new file mode 100644
index 0000000..1f2cac0
--- /dev/null
+++ b/src/Plugin/SectionStorage/PageManager.php
@@ -0,0 +1,189 @@
+<?php
+
+namespace Drupal\page_manager\Plugin\SectionStorage;
+
+use Drupal\Core\Access\AccessResult;
+use Drupal\Core\Cache\RefinableCacheableDependencyInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\Core\Plugin\Context\EntityContext;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\Core\Url;
+use Drupal\layout_builder\Entity\SampleEntityGeneratorInterface;
+use Drupal\layout_builder\Plugin\SectionStorage\SectionStorageBase;
+use Drupal\page_manager\Entity\PageVariant;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * Defines the 'page_manager' section storage type.
+ *
+ * @SectionStorage(
+ *   id = "page_manager",
+ *   context_definitions = {
+ *     "page_variant" = @ContextDefinition("entity:page_variant"),
+ *   },
+ * )
+ */
+class PageManager extends SectionStorageBase implements ContainerFactoryPluginInterface {
+
+  /**
+   * The entity type manager.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  protected $entityTypeManager;
+
+  /**
+   * The sample entity generator.
+   *
+   * @var \Drupal\layout_builder\Entity\SampleEntityGeneratorInterface
+   */
+  protected $sampleEntityGenerator;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, EntityTypeManagerInterface $entity_type_manager, SampleEntityGeneratorInterface $sample_entity_generator) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+
+    $this->entityTypeManager = $entity_type_manager;
+    $this->sampleEntityGenerator = $sample_entity_generator;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('entity_type.manager'),
+      $container->get('layout_builder.sample_entity_generator')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getSectionList() {
+    return $this->getContextValue('page_variant')->getVariantPlugin();
+  }
+
+  /**
+   * Gets the page variant entity.
+   *
+   * @return \Drupal\page_manager\Entity\PageVariant
+   *   The page variant entity.
+   *
+   * @throws \Drupal\Component\Plugin\Exception\PluginException
+   */
+  protected function getPageVariant() {
+    return $this->getContextValue('page_variant');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getStorageId() {
+    return $this->getContextValue('page_variant')->id();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getRedirectUrl() {
+    // @todo
+    return Url::fromRoute('<front>');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getLayoutBuilderUrl($rel = 'view') {
+    return Url::fromRoute("layout_builder.page_manager.view", ['page_variant' => $this->getPageVariant()->id()]);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildRoutes(RouteCollection $collection) {
+    // @todo
+    $path = '/admin/structure/page_manager/{page_variant}/layout';
+
+    $options['parameters']['page_variant']['type'] = 'entity:page_variant';
+
+    $options['_admin_route'] = FALSE;
+
+    $this->buildLayoutRoutes($collection, $this->getPluginDefinition(), $path, [], [], $options, '', 'page_variant');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deriveContextsFromRoute($value, $definition, $name, array $defaults) {
+    $contexts = [];
+
+    if ($entity = $this->extractEntityFromRoute($value, $defaults)) {
+      $contexts['page_variant'] = EntityContext::fromEntity($entity);
+    }
+    return $contexts;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  private function extractEntityFromRoute($value, array $defaults) {
+    // @todo
+    if (!empty($value)) {
+      return PageVariant::load($value);
+    }
+    return PageVariant::load($defaults['page_variant']);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function label() {
+    return $this->getPageVariant()->label();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function save() {
+    $page_variant = $this->getPageVariant();
+    return $page_variant->save();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function access($operation, AccountInterface $account = NULL, $return_as_object = FALSE) {
+    // @todo
+    return AccessResult::allowed();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isApplicable(RefinableCacheableDependencyInterface $cacheability) {
+    // @todo
+    return TRUE;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getSectionListFromId($id) {
+    // @todo
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function extractIdFromRoute($value, $definition, $name, array $defaults) {
+    // @todo
+  }
+}