diff --git a/openpype/hosts/unreal/api/__init__.py b/openpype/hosts/unreal/api/__init__.py
index de0fce13d5..ac6a91eae9 100644
--- a/openpype/hosts/unreal/api/__init__.py
+++ b/openpype/hosts/unreal/api/__init__.py
@@ -22,6 +22,8 @@ from .pipeline import (
     show_tools_popup,
     instantiate,
     UnrealHost,
+    set_sequence_hierarchy,
+    generate_sequence,
     maintained_selection
 )
 
@@ -41,5 +43,7 @@ __all__ = [
     "show_tools_popup",
     "instantiate",
     "UnrealHost",
+    "set_sequence_hierarchy",
+    "generate_sequence",
     "maintained_selection"
 ]
diff --git a/openpype/hosts/unreal/api/pipeline.py b/openpype/hosts/unreal/api/pipeline.py
index bb45fa8c01..72816c9b81 100644
--- a/openpype/hosts/unreal/api/pipeline.py
+++ b/openpype/hosts/unreal/api/pipeline.py
@@ -9,12 +9,14 @@ import time
 
 import pyblish.api
 
+from openpype.client import get_asset_by_name, get_assets
 from openpype.pipeline import (
     register_loader_plugin_path,
     register_creator_plugin_path,
     deregister_loader_plugin_path,
     deregister_creator_plugin_path,
     AYON_CONTAINER_ID,
+    legacy_io,
 )
 from openpype.tools.utils import host_tools
 import openpype.hosts.unreal
@@ -512,6 +514,141 @@ def get_subsequences(sequence: unreal.LevelSequence):
     return []
 
 
+def set_sequence_hierarchy(
+    seq_i, seq_j, max_frame_i, min_frame_j, max_frame_j, map_paths
+):
+    # Get existing sequencer tracks or create them if they don't exist
+    tracks = seq_i.get_master_tracks()
+    subscene_track = None
+    visibility_track = None
+    for t in tracks:
+        if t.get_class() == unreal.MovieSceneSubTrack.static_class():
+            subscene_track = t
+        if (t.get_class() ==
+                unreal.MovieSceneLevelVisibilityTrack.static_class()):
+            visibility_track = t
+    if not subscene_track:
+        subscene_track = seq_i.add_master_track(unreal.MovieSceneSubTrack)
+    if not visibility_track:
+        visibility_track = seq_i.add_master_track(
+            unreal.MovieSceneLevelVisibilityTrack)
+
+    # Create the sub-scene section
+    subscenes = subscene_track.get_sections()
+    subscene = None
+    for s in subscenes:
+        if s.get_editor_property('sub_sequence') == seq_j:
+            subscene = s
+            break
+    if not subscene:
+        subscene = subscene_track.add_section()
+        subscene.set_row_index(len(subscene_track.get_sections()))
+        subscene.set_editor_property('sub_sequence', seq_j)
+        subscene.set_range(
+            min_frame_j,
+            max_frame_j + 1)
+
+    # Create the visibility section
+    ar = unreal.AssetRegistryHelpers.get_asset_registry()
+    maps = []
+    for m in map_paths:
+        # Unreal requires to load the level to get the map name
+        unreal.EditorLevelLibrary.save_all_dirty_levels()
+        unreal.EditorLevelLibrary.load_level(m)
+        maps.append(str(ar.get_asset_by_object_path(m).asset_name))
+
+    vis_section = visibility_track.add_section()
+    index = len(visibility_track.get_sections())
+
+    vis_section.set_range(
+        min_frame_j,
+        max_frame_j + 1)
+    vis_section.set_visibility(unreal.LevelVisibility.VISIBLE)
+    vis_section.set_row_index(index)
+    vis_section.set_level_names(maps)
+
+    if min_frame_j > 1:
+        hid_section = visibility_track.add_section()
+        hid_section.set_range(
+            1,
+            min_frame_j)
+        hid_section.set_visibility(unreal.LevelVisibility.HIDDEN)
+        hid_section.set_row_index(index)
+        hid_section.set_level_names(maps)
+    if max_frame_j < max_frame_i:
+        hid_section = visibility_track.add_section()
+        hid_section.set_range(
+            max_frame_j + 1,
+            max_frame_i + 1)
+        hid_section.set_visibility(unreal.LevelVisibility.HIDDEN)
+        hid_section.set_row_index(index)
+        hid_section.set_level_names(maps)
+
+
+def generate_sequence(h, h_dir):
+    tools = unreal.AssetToolsHelpers().get_asset_tools()
+
+    sequence = tools.create_asset(
+        asset_name=h,
+        package_path=h_dir,
+        asset_class=unreal.LevelSequence,
+        factory=unreal.LevelSequenceFactoryNew()
+    )
+
+    project_name = legacy_io.active_project()
+    asset_data = get_asset_by_name(
+        project_name,
+        h_dir.split('/')[-1],
+        fields=["_id", "data.fps"]
+    )
+
+    start_frames = []
+    end_frames = []
+
+    elements = list(get_assets(
+        project_name,
+        parent_ids=[asset_data["_id"]],
+        fields=["_id", "data.clipIn", "data.clipOut"]
+    ))
+    for e in elements:
+        start_frames.append(e.get('data').get('clipIn'))
+        end_frames.append(e.get('data').get('clipOut'))
+
+        elements.extend(get_assets(
+            project_name,
+            parent_ids=[e["_id"]],
+            fields=["_id", "data.clipIn", "data.clipOut"]
+        ))
+
+    min_frame = min(start_frames)
+    max_frame = max(end_frames)
+
+    fps = asset_data.get('data').get("fps")
+
+    sequence.set_display_rate(
+        unreal.FrameRate(fps, 1.0))
+    sequence.set_playback_start(min_frame)
+    sequence.set_playback_end(max_frame)
+
+    sequence.set_work_range_start(min_frame / fps)
+    sequence.set_work_range_end(max_frame / fps)
+    sequence.set_view_range_start(min_frame / fps)
+    sequence.set_view_range_end(max_frame / fps)
+
+    tracks = sequence.get_master_tracks()
+    track = None
+    for t in tracks:
+        if (t.get_class() ==
+                unreal.MovieSceneCameraCutTrack.static_class()):
+            track = t
+            break
+    if not track:
+        track = sequence.add_master_track(
+            unreal.MovieSceneCameraCutTrack)
+
+    return sequence, (min_frame, max_frame)
+
+
 @contextmanager
 def maintained_selection():
     """Stub to be either implemented or replaced.
diff --git a/openpype/hosts/unreal/plugins/load/load_camera.py b/openpype/hosts/unreal/plugins/load/load_camera.py
index 072b3b1467..59ea14697d 100644
--- a/openpype/hosts/unreal/plugins/load/load_camera.py
+++ b/openpype/hosts/unreal/plugins/load/load_camera.py
@@ -3,16 +3,24 @@
 from pathlib import Path
 
 import unreal
-from unreal import EditorAssetLibrary
-from unreal import EditorLevelLibrary
-from unreal import EditorLevelUtils
-from openpype.client import get_assets, get_asset_by_name
+from unreal import (
+    EditorAssetLibrary,
+    EditorLevelLibrary,
+    EditorLevelUtils,
+    LevelSequenceEditorBlueprintLibrary as LevelSequenceLib,
+)
+from openpype.client import get_asset_by_name
 from openpype.pipeline import (
     AYON_CONTAINER_ID,
     legacy_io,
 )
 from openpype.hosts.unreal.api import plugin
-from openpype.hosts.unreal.api import pipeline as unreal_pipeline
+from openpype.hosts.unreal.api.pipeline import (
+    generate_sequence,
+    set_sequence_hierarchy,
+    create_container,
+    imprint,
+)
 
 
 class CameraLoader(plugin.Loader):
@@ -24,32 +32,6 @@ class CameraLoader(plugin.Loader):
     icon = "cube"
     color = "orange"
 
-    def _set_sequence_hierarchy(
-        self, seq_i, seq_j, min_frame_j, max_frame_j
-    ):
-        tracks = seq_i.get_master_tracks()
-        track = None
-        for t in tracks:
-            if t.get_class() == unreal.MovieSceneSubTrack.static_class():
-                track = t
-                break
-        if not track:
-            track = seq_i.add_master_track(unreal.MovieSceneSubTrack)
-
-        subscenes = track.get_sections()
-        subscene = None
-        for s in subscenes:
-            if s.get_editor_property('sub_sequence') == seq_j:
-                subscene = s
-                break
-        if not subscene:
-            subscene = track.add_section()
-            subscene.set_row_index(len(track.get_sections()))
-            subscene.set_editor_property('sub_sequence', seq_j)
-            subscene.set_range(
-                min_frame_j,
-                max_frame_j + 1)
-
     def _import_camera(
         self, world, sequence, bindings, import_fbx_settings, import_filename
     ):
@@ -110,10 +92,7 @@ class CameraLoader(plugin.Loader):
             hierarchy_dir_list.append(hierarchy_dir)
         asset = context.get('asset').get('name')
         suffix = "_CON"
-        if asset:
-            asset_name = "{}_{}".format(asset, name)
-        else:
-            asset_name = "{}".format(name)
+        asset_name = f"{asset}_{name}" if asset else f"{name}"
 
         tools = unreal.AssetToolsHelpers().get_asset_tools()
 
@@ -127,23 +106,15 @@ class CameraLoader(plugin.Loader):
             # Get highest number to make a unique name
             folders = [a for a in asset_content
                        if a[-1] == "/" and f"{name}_" in a]
-            f_numbers = []
-            for f in folders:
-                # Get number from folder name. Splits the string by "_" and
-                # removes the last element (which is a "/").
-                f_numbers.append(int(f.split("_")[-1][:-1]))
+            # Get number from folder name. Splits the string by "_" and
+            # removes the last element (which is a "/").
+            f_numbers = [int(f.split("_")[-1][:-1]) for f in folders]
             f_numbers.sort()
-            if not f_numbers:
-                unique_number = 1
-            else:
-                unique_number = f_numbers[-1] + 1
+            unique_number = f_numbers[-1] + 1 if f_numbers else 1
 
         asset_dir, container_name = tools.create_unique_asset_name(
             f"{hierarchy_dir}/{asset}/{name}_{unique_number:02d}", suffix="")
 
-        asset_path = Path(asset_dir)
-        asset_path_parent = str(asset_path.parent.as_posix())
-
         container_name += suffix
 
         EditorAssetLibrary.make_directory(asset_dir)
@@ -156,9 +127,9 @@ class CameraLoader(plugin.Loader):
         if not EditorAssetLibrary.does_asset_exist(master_level):
             EditorLevelLibrary.new_level(f"{h_dir}/{h_asset}_map")
 
-        level = f"{asset_path_parent}/{asset}_map.{asset}_map"
+        level = f"{asset_dir}/{asset}_map_camera.{asset}_map_camera"
         if not EditorAssetLibrary.does_asset_exist(level):
-            EditorLevelLibrary.new_level(f"{asset_path_parent}/{asset}_map")
+            EditorLevelLibrary.new_level(f"{asset_dir}/{asset}_map_camera")
 
             EditorLevelLibrary.load_level(master_level)
             EditorLevelUtils.add_level_to_world(
@@ -169,27 +140,13 @@ class CameraLoader(plugin.Loader):
         EditorLevelLibrary.save_all_dirty_levels()
         EditorLevelLibrary.load_level(level)
 
-        project_name = legacy_io.active_project()
-        # TODO refactor
-        #   - Creating of hierarchy should be a function in unreal integration
-        #       - it's used in multiple loaders but must not be loader's logic
-        #       - hard to say what is purpose of the loop
-        #   - variables does not match their meaning
-        #       - why scene is stored to sequences?
-        #       - asset documents vs. elements
-        #   - cleanup variable names in whole function
-        #       - e.g. 'asset', 'asset_name', 'asset_data', 'asset_doc'
-        #   - really inefficient queries of asset documents
-        #   - existing asset in scene is considered as "with correct values"
-        #   - variable 'elements' is modified during it's loop
         # Get all the sequences in the hierarchy. It will create them, if
         # they don't exist.
-        sequences = []
         frame_ranges = []
-        i = 0
-        for h in hierarchy_dir_list:
+        sequences = []
+        for (h_dir, h) in zip(hierarchy_dir_list, hierarchy):
             root_content = EditorAssetLibrary.list_assets(
-                h, recursive=False, include_folder=False)
+                h_dir, recursive=False, include_folder=False)
 
             existing_sequences = [
                 EditorAssetLibrary.find_asset_data(asset)
@@ -198,57 +155,17 @@ class CameraLoader(plugin.Loader):
                     asset).get_class().get_name() == 'LevelSequence'
             ]
 
-            if not existing_sequences:
-                scene = tools.create_asset(
-                    asset_name=hierarchy[i],
-                    package_path=h,
-                    asset_class=unreal.LevelSequence,
-                    factory=unreal.LevelSequenceFactoryNew()
-                )
-
-                asset_data = get_asset_by_name(
-                    project_name,
-                    h.split('/')[-1],
-                    fields=["_id", "data.fps"]
-                )
-
-                start_frames = []
-                end_frames = []
-
-                elements = list(get_assets(
-                    project_name,
-                    parent_ids=[asset_data["_id"]],
-                    fields=["_id", "data.clipIn", "data.clipOut"]
-                ))
-
-                for e in elements:
-                    start_frames.append(e.get('data').get('clipIn'))
-                    end_frames.append(e.get('data').get('clipOut'))
-
-                    elements.extend(get_assets(
-                        project_name,
-                        parent_ids=[e["_id"]],
-                        fields=["_id", "data.clipIn", "data.clipOut"]
-                    ))
-
-                min_frame = min(start_frames)
-                max_frame = max(end_frames)
-
-                scene.set_display_rate(
-                    unreal.FrameRate(asset_data.get('data').get("fps"), 1.0))
-                scene.set_playback_start(min_frame)
-                scene.set_playback_end(max_frame)
-
-                sequences.append(scene)
-                frame_ranges.append((min_frame, max_frame))
-            else:
-                for e in existing_sequences:
-                    sequences.append(e.get_asset())
+            if existing_sequences:
+                for seq in existing_sequences:
+                    sequences.append(seq.get_asset())
                     frame_ranges.append((
-                        e.get_asset().get_playback_start(),
-                        e.get_asset().get_playback_end()))
+                        seq.get_asset().get_playback_start(),
+                        seq.get_asset().get_playback_end()))
+            else:
+                sequence, frame_range = generate_sequence(h, h_dir)
 
-            i += 1
+                sequences.append(sequence)
+                frame_ranges.append(frame_range)
 
         EditorAssetLibrary.make_directory(asset_dir)
 
@@ -260,19 +177,24 @@ class CameraLoader(plugin.Loader):
         )
 
         # Add sequences data to hierarchy
-        for i in range(0, len(sequences) - 1):
-            self._set_sequence_hierarchy(
+        for i in range(len(sequences) - 1):
+            set_sequence_hierarchy(
                 sequences[i], sequences[i + 1],
-                frame_ranges[i + 1][0], frame_ranges[i + 1][1])
+                frame_ranges[i][1],
+                frame_ranges[i + 1][0], frame_ranges[i + 1][1],
+                [level])
 
+        project_name = legacy_io.active_project()
         data = get_asset_by_name(project_name, asset)["data"]
         cam_seq.set_display_rate(
             unreal.FrameRate(data.get("fps"), 1.0))
         cam_seq.set_playback_start(data.get('clipIn'))
         cam_seq.set_playback_end(data.get('clipOut') + 1)
-        self._set_sequence_hierarchy(
+        set_sequence_hierarchy(
             sequences[-1], cam_seq,
-            data.get('clipIn'), data.get('clipOut'))
+            frame_ranges[-1][1],
+            data.get('clipIn'), data.get('clipOut'),
+            [level])
 
         settings = unreal.MovieSceneUserImportFBXSettings()
         settings.set_editor_property('reduce_keys', False)
@@ -307,7 +229,7 @@ class CameraLoader(plugin.Loader):
                             key.set_time(unreal.FrameNumber(value=new_time))
 
         # Create Asset Container
-        unreal_pipeline.create_container(
+        create_container(
             container=container_name, path=asset_dir)
 
         data = {
@@ -322,14 +244,14 @@ class CameraLoader(plugin.Loader):
             "parent": context["representation"]["parent"],
             "family": context["representation"]["context"]["family"]
         }
-        unreal_pipeline.imprint(
-            "{}/{}".format(asset_dir, container_name), data)
+        imprint(f"{asset_dir}/{container_name}", data)
 
         EditorLevelLibrary.save_all_dirty_levels()
         EditorLevelLibrary.load_level(master_level)
 
+        # Save all assets in the hierarchy
         asset_content = EditorAssetLibrary.list_assets(
-            asset_dir, recursive=True, include_folder=True
+            hierarchy_dir_list[0], recursive=True, include_folder=False
         )
 
         for a in asset_content:
@@ -340,29 +262,27 @@ class CameraLoader(plugin.Loader):
     def update(self, container, representation):
         ar = unreal.AssetRegistryHelpers.get_asset_registry()
 
-        root = "/Game/ayon"
+        curr_level_sequence = LevelSequenceLib.get_current_level_sequence()
+        curr_time = LevelSequenceLib.get_current_time()
+        is_cam_lock = LevelSequenceLib.is_camera_cut_locked_to_viewport()
+
+        editor_subsystem = unreal.UnrealEditorSubsystem()
+        vp_loc, vp_rot = editor_subsystem.get_level_viewport_camera_info()
 
         asset_dir = container.get('namespace')
 
-        context = representation.get("context")
-
-        hierarchy = context.get('hierarchy').split("/")
-        h_dir = f"{root}/{hierarchy[0]}"
-        h_asset = hierarchy[0]
-        master_level = f"{h_dir}/{h_asset}_map.{h_asset}_map"
-
         EditorLevelLibrary.save_current_level()
 
-        filter = unreal.ARFilter(
+        _filter = unreal.ARFilter(
             class_names=["LevelSequence"],
             package_paths=[asset_dir],
             recursive_paths=False)
-        sequences = ar.get_assets(filter)
-        filter = unreal.ARFilter(
+        sequences = ar.get_assets(_filter)
+        _filter = unreal.ARFilter(
             class_names=["World"],
-            package_paths=[str(Path(asset_dir).parent.as_posix())],
+            package_paths=[asset_dir],
             recursive_paths=True)
-        maps = ar.get_assets(filter)
+        maps = ar.get_assets(_filter)
 
         # There should be only one map in the list
         EditorLevelLibrary.load_level(maps[0].get_asset().get_path_name())
@@ -401,12 +321,18 @@ class CameraLoader(plugin.Loader):
         root = "/Game/Ayon"
         namespace = container.get('namespace').replace(f"{root}/", "")
         ms_asset = namespace.split('/')[0]
-        filter = unreal.ARFilter(
+        _filter = unreal.ARFilter(
             class_names=["LevelSequence"],
             package_paths=[f"{root}/{ms_asset}"],
             recursive_paths=False)
-        sequences = ar.get_assets(filter)
+        sequences = ar.get_assets(_filter)
         master_sequence = sequences[0].get_asset()
+        _filter = unreal.ARFilter(
+            class_names=["World"],
+            package_paths=[f"{root}/{ms_asset}"],
+            recursive_paths=False)
+        levels = ar.get_assets(_filter)
+        master_level = levels[0].get_asset().get_path_name()
 
         sequences = [master_sequence]
 
@@ -418,26 +344,20 @@ class CameraLoader(plugin.Loader):
             for t in tracks:
                 if t.get_class() == unreal.MovieSceneSubTrack.static_class():
                     subscene_track = t
-                    break
             if subscene_track:
                 sections = subscene_track.get_sections()
                 for ss in sections:
                     if ss.get_sequence().get_name() == sequence_name:
                         parent = s
                         sub_scene = ss
-                        # subscene_track.remove_section(ss)
                         break
                     sequences.append(ss.get_sequence())
-                # Update subscenes indexes.
-                i = 0
-                for ss in sections:
+                for i, ss in enumerate(sections):
                     ss.set_row_index(i)
-                    i += 1
-
             if parent:
                 break
 
-        assert parent, "Could not find the parent sequence"
+            assert parent, "Could not find the parent sequence"
 
         EditorAssetLibrary.delete_asset(level_sequence.get_path_name())
 
@@ -466,33 +386,63 @@ class CameraLoader(plugin.Loader):
             str(representation["data"]["path"])
         )
 
+        # Set range of all sections
+        # Changing the range of the section is not enough. We need to change
+        # the frame of all the keys in the section.
+        project_name = legacy_io.active_project()
+        asset = container.get('asset')
+        data = get_asset_by_name(project_name, asset)["data"]
+
+        for possessable in new_sequence.get_possessables():
+            for tracks in possessable.get_tracks():
+                for section in tracks.get_sections():
+                    section.set_range(
+                        data.get('clipIn'),
+                        data.get('clipOut') + 1)
+                    for channel in section.get_all_channels():
+                        for key in channel.get_keys():
+                            old_time = key.get_time().get_editor_property(
+                                'frame_number')
+                            old_time_value = old_time.get_editor_property(
+                                'value')
+                            new_time = old_time_value + (
+                                data.get('clipIn') - data.get('frameStart')
+                            )
+                            key.set_time(unreal.FrameNumber(value=new_time))
+
         data = {
             "representation": str(representation["_id"]),
             "parent": str(representation["parent"])
         }
-        unreal_pipeline.imprint(
-            "{}/{}".format(asset_dir, container.get('container_name')), data)
+        imprint(f"{asset_dir}/{container.get('container_name')}", data)
 
         EditorLevelLibrary.save_current_level()
 
         asset_content = EditorAssetLibrary.list_assets(
-            asset_dir, recursive=True, include_folder=False)
+            f"{root}/{ms_asset}", recursive=True, include_folder=False)
 
         for a in asset_content:
             EditorAssetLibrary.save_asset(a)
 
         EditorLevelLibrary.load_level(master_level)
 
+        if curr_level_sequence:
+            LevelSequenceLib.open_level_sequence(curr_level_sequence)
+            LevelSequenceLib.set_current_time(curr_time)
+            LevelSequenceLib.set_lock_camera_cut_to_viewport(is_cam_lock)
+
+        editor_subsystem.set_level_viewport_camera_info(vp_loc, vp_rot)
+
     def remove(self, container):
-        path = Path(container.get("namespace"))
-        parent_path = str(path.parent.as_posix())
+        asset_dir = container.get('namespace')
+        path = Path(asset_dir)
 
         ar = unreal.AssetRegistryHelpers.get_asset_registry()
-        filter = unreal.ARFilter(
+        _filter = unreal.ARFilter(
             class_names=["LevelSequence"],
-            package_paths=[f"{str(path.as_posix())}"],
+            package_paths=[asset_dir],
             recursive_paths=False)
-        sequences = ar.get_assets(filter)
+        sequences = ar.get_assets(_filter)
 
         if not sequences:
             raise Exception("Could not find sequence.")
@@ -500,11 +450,11 @@ class CameraLoader(plugin.Loader):
         world = ar.get_asset_by_object_path(
             EditorLevelLibrary.get_editor_world().get_path_name())
 
-        filter = unreal.ARFilter(
+        _filter = unreal.ARFilter(
             class_names=["World"],
-            package_paths=[f"{parent_path}"],
+            package_paths=[asset_dir],
             recursive_paths=True)
-        maps = ar.get_assets(filter)
+        maps = ar.get_assets(_filter)
 
         # There should be only one map in the list
         if not maps:
@@ -534,12 +484,18 @@ class CameraLoader(plugin.Loader):
         root = "/Game/Ayon"
         namespace = container.get('namespace').replace(f"{root}/", "")
         ms_asset = namespace.split('/')[0]
-        filter = unreal.ARFilter(
+        _filter = unreal.ARFilter(
             class_names=["LevelSequence"],
             package_paths=[f"{root}/{ms_asset}"],
             recursive_paths=False)
-        sequences = ar.get_assets(filter)
+        sequences = ar.get_assets(_filter)
         master_sequence = sequences[0].get_asset()
+        _filter = unreal.ARFilter(
+            class_names=["World"],
+            package_paths=[f"{root}/{ms_asset}"],
+            recursive_paths=False)
+        levels = ar.get_assets(_filter)
+        master_level = levels[0].get_full_name()
 
         sequences = [master_sequence]
 
@@ -547,10 +503,13 @@ class CameraLoader(plugin.Loader):
         for s in sequences:
             tracks = s.get_master_tracks()
             subscene_track = None
+            visibility_track = None
             for t in tracks:
                 if t.get_class() == unreal.MovieSceneSubTrack.static_class():
                     subscene_track = t
-                    break
+                if (t.get_class() ==
+                        unreal.MovieSceneLevelVisibilityTrack.static_class()):
+                    visibility_track = t
             if subscene_track:
                 sections = subscene_track.get_sections()
                 for ss in sections:
@@ -560,23 +519,48 @@ class CameraLoader(plugin.Loader):
                         break
                     sequences.append(ss.get_sequence())
                 # Update subscenes indexes.
-                i = 0
-                for ss in sections:
+                for i, ss in enumerate(sections):
                     ss.set_row_index(i)
-                    i += 1
 
+            if visibility_track:
+                sections = visibility_track.get_sections()
+                for ss in sections:
+                    if (unreal.Name(f"{container.get('asset')}_map_camera")
+                            in ss.get_level_names()):
+                        visibility_track.remove_section(ss)
+                # Update visibility sections indexes.
+                i = -1
+                prev_name = []
+                for ss in sections:
+                    if prev_name != ss.get_level_names():
+                        i += 1
+                    ss.set_row_index(i)
+                    prev_name = ss.get_level_names()
             if parent:
                 break
 
         assert parent, "Could not find the parent sequence"
 
-        EditorAssetLibrary.delete_directory(str(path.as_posix()))
+        # Create a temporary level to delete the layout level.
+        EditorLevelLibrary.save_all_dirty_levels()
+        EditorAssetLibrary.make_directory(f"{root}/tmp")
+        tmp_level = f"{root}/tmp/temp_map"
+        if not EditorAssetLibrary.does_asset_exist(f"{tmp_level}.temp_map"):
+            EditorLevelLibrary.new_level(tmp_level)
+        else:
+            EditorLevelLibrary.load_level(tmp_level)
+
+        # Delete the layout directory.
+        EditorAssetLibrary.delete_directory(asset_dir)
+
+        EditorLevelLibrary.load_level(master_level)
+        EditorAssetLibrary.delete_directory(f"{root}/tmp")
 
         # Check if there isn't any more assets in the parent folder, and
         # delete it if not.
         asset_content = EditorAssetLibrary.list_assets(
-            parent_path, recursive=False, include_folder=True
+            path.parent.as_posix(), recursive=False, include_folder=True
         )
 
         if len(asset_content) == 0:
-            EditorAssetLibrary.delete_directory(parent_path)
+            EditorAssetLibrary.delete_directory(path.parent.as_posix())
diff --git a/openpype/hosts/unreal/plugins/load/load_layout.py b/openpype/hosts/unreal/plugins/load/load_layout.py
index d94e6e5837..86b2e1456c 100644
--- a/openpype/hosts/unreal/plugins/load/load_layout.py
+++ b/openpype/hosts/unreal/plugins/load/load_layout.py
@@ -5,15 +5,18 @@ import collections
 from pathlib import Path
 
 import unreal
-from unreal import EditorAssetLibrary
-from unreal import EditorLevelLibrary
-from unreal import EditorLevelUtils
-from unreal import AssetToolsHelpers
-from unreal import FBXImportType
-from unreal import MovieSceneLevelVisibilityTrack
-from unreal import MovieSceneSubTrack
+from unreal import (
+    EditorAssetLibrary,
+    EditorLevelLibrary,
+    EditorLevelUtils,
+    AssetToolsHelpers,
+    FBXImportType,
+    MovieSceneLevelVisibilityTrack,
+    MovieSceneSubTrack,
+    LevelSequenceEditorBlueprintLibrary as LevelSequenceLib,
+)
 
-from openpype.client import get_asset_by_name, get_assets, get_representations
+from openpype.client import get_asset_by_name, get_representations
 from openpype.pipeline import (
     discover_loader_plugins,
     loaders_from_representation,
@@ -25,7 +28,13 @@ from openpype.pipeline import (
 from openpype.pipeline.context_tools import get_current_project_asset
 from openpype.settings import get_current_project_settings
 from openpype.hosts.unreal.api import plugin
-from openpype.hosts.unreal.api import pipeline as unreal_pipeline
+from openpype.hosts.unreal.api.pipeline import (
+    generate_sequence,
+    set_sequence_hierarchy,
+    create_container,
+    imprint,
+    ls,
+)
 
 
 class LayoutLoader(plugin.Loader):
@@ -91,77 +100,6 @@ class LayoutLoader(plugin.Loader):
 
         return None
 
-    @staticmethod
-    def _set_sequence_hierarchy(
-        seq_i, seq_j, max_frame_i, min_frame_j, max_frame_j, map_paths
-    ):
-        # Get existing sequencer tracks or create them if they don't exist
-        tracks = seq_i.get_master_tracks()
-        subscene_track = None
-        visibility_track = None
-        for t in tracks:
-            if t.get_class() == unreal.MovieSceneSubTrack.static_class():
-                subscene_track = t
-            if (t.get_class() ==
-                    unreal.MovieSceneLevelVisibilityTrack.static_class()):
-                visibility_track = t
-        if not subscene_track:
-            subscene_track = seq_i.add_master_track(unreal.MovieSceneSubTrack)
-        if not visibility_track:
-            visibility_track = seq_i.add_master_track(
-                unreal.MovieSceneLevelVisibilityTrack)
-
-        # Create the sub-scene section
-        subscenes = subscene_track.get_sections()
-        subscene = None
-        for s in subscenes:
-            if s.get_editor_property('sub_sequence') == seq_j:
-                subscene = s
-                break
-        if not subscene:
-            subscene = subscene_track.add_section()
-            subscene.set_row_index(len(subscene_track.get_sections()))
-            subscene.set_editor_property('sub_sequence', seq_j)
-            subscene.set_range(
-                min_frame_j,
-                max_frame_j + 1)
-
-        # Create the visibility section
-        ar = unreal.AssetRegistryHelpers.get_asset_registry()
-        maps = []
-        for m in map_paths:
-            # Unreal requires to load the level to get the map name
-            EditorLevelLibrary.save_all_dirty_levels()
-            EditorLevelLibrary.load_level(m)
-            maps.append(str(ar.get_asset_by_object_path(m).asset_name))
-
-        vis_section = visibility_track.add_section()
-        index = len(visibility_track.get_sections())
-
-        vis_section.set_range(
-            min_frame_j,
-            max_frame_j + 1)
-        vis_section.set_visibility(unreal.LevelVisibility.VISIBLE)
-        vis_section.set_row_index(index)
-        vis_section.set_level_names(maps)
-
-        if min_frame_j > 1:
-            hid_section = visibility_track.add_section()
-            hid_section.set_range(
-                1,
-                min_frame_j)
-            hid_section.set_visibility(unreal.LevelVisibility.HIDDEN)
-            hid_section.set_row_index(index)
-            hid_section.set_level_names(maps)
-        if max_frame_j < max_frame_i:
-            hid_section = visibility_track.add_section()
-            hid_section.set_range(
-                max_frame_j + 1,
-                max_frame_i + 1)
-            hid_section.set_visibility(unreal.LevelVisibility.HIDDEN)
-            hid_section.set_row_index(index)
-            hid_section.set_level_names(maps)
-
     def _transform_from_basis(self, transform, basis):
         """Transform a transform from a basis to a new basis."""
         # Get the basis matrix
@@ -352,63 +290,6 @@ class LayoutLoader(plugin.Loader):
                     sec_params = section.get_editor_property('params')
                     sec_params.set_editor_property('animation', animation)
 
-    @staticmethod
-    def _generate_sequence(h, h_dir):
-        tools = unreal.AssetToolsHelpers().get_asset_tools()
-
-        sequence = tools.create_asset(
-            asset_name=h,
-            package_path=h_dir,
-            asset_class=unreal.LevelSequence,
-            factory=unreal.LevelSequenceFactoryNew()
-        )
-
-        project_name = legacy_io.active_project()
-        asset_data = get_asset_by_name(
-            project_name,
-            h_dir.split('/')[-1],
-            fields=["_id", "data.fps"]
-        )
-
-        start_frames = []
-        end_frames = []
-
-        elements = list(get_assets(
-            project_name,
-            parent_ids=[asset_data["_id"]],
-            fields=["_id", "data.clipIn", "data.clipOut"]
-        ))
-        for e in elements:
-            start_frames.append(e.get('data').get('clipIn'))
-            end_frames.append(e.get('data').get('clipOut'))
-
-            elements.extend(get_assets(
-                project_name,
-                parent_ids=[e["_id"]],
-                fields=["_id", "data.clipIn", "data.clipOut"]
-            ))
-
-        min_frame = min(start_frames)
-        max_frame = max(end_frames)
-
-        sequence.set_display_rate(
-            unreal.FrameRate(asset_data.get('data').get("fps"), 1.0))
-        sequence.set_playback_start(min_frame)
-        sequence.set_playback_end(max_frame)
-
-        tracks = sequence.get_master_tracks()
-        track = None
-        for t in tracks:
-            if (t.get_class() ==
-                    unreal.MovieSceneCameraCutTrack.static_class()):
-                track = t
-                break
-        if not track:
-            track = sequence.add_master_track(
-                unreal.MovieSceneCameraCutTrack)
-
-        return sequence, (min_frame, max_frame)
-
     def _get_repre_docs_by_version_id(self, data):
         version_ids = {
             element.get("version")
@@ -696,7 +577,7 @@ class LayoutLoader(plugin.Loader):
                 ]
 
                 if not existing_sequences:
-                    sequence, frame_range = self._generate_sequence(h, h_dir)
+                    sequence, frame_range = generate_sequence(h, h_dir)
 
                     sequences.append(sequence)
                     frame_ranges.append(frame_range)
@@ -716,7 +597,7 @@ class LayoutLoader(plugin.Loader):
 
             # sequences and frame_ranges have the same length
             for i in range(0, len(sequences) - 1):
-                self._set_sequence_hierarchy(
+                set_sequence_hierarchy(
                     sequences[i], sequences[i + 1],
                     frame_ranges[i][1],
                     frame_ranges[i + 1][0], frame_ranges[i + 1][1],
@@ -729,7 +610,7 @@ class LayoutLoader(plugin.Loader):
             shot.set_playback_start(0)
             shot.set_playback_end(data.get('clipOut') - data.get('clipIn') + 1)
             if sequences:
-                self._set_sequence_hierarchy(
+                set_sequence_hierarchy(
                     sequences[-1], shot,
                     frame_ranges[-1][1],
                     data.get('clipIn'), data.get('clipOut'),
@@ -745,7 +626,7 @@ class LayoutLoader(plugin.Loader):
         EditorLevelLibrary.save_current_level()
 
         # Create Asset Container
-        unreal_pipeline.create_container(
+        create_container(
             container=container_name, path=asset_dir)
 
         data = {
@@ -761,11 +642,13 @@ class LayoutLoader(plugin.Loader):
             "family": context["representation"]["context"]["family"],
             "loaded_assets": loaded_assets
         }
-        unreal_pipeline.imprint(
+        imprint(
             "{}/{}".format(asset_dir, container_name), data)
 
+        save_dir = hierarchy_dir_list[0] if create_sequences else asset_dir
+
         asset_content = EditorAssetLibrary.list_assets(
-            asset_dir, recursive=True, include_folder=False)
+            save_dir, recursive=True, include_folder=False)
 
         for a in asset_content:
             EditorAssetLibrary.save_asset(a)
@@ -781,16 +664,24 @@ class LayoutLoader(plugin.Loader):
 
         ar = unreal.AssetRegistryHelpers.get_asset_registry()
 
+        curr_level_sequence = LevelSequenceLib.get_current_level_sequence()
+        curr_time = LevelSequenceLib.get_current_time()
+        is_cam_lock = LevelSequenceLib.is_camera_cut_locked_to_viewport()
+
+        editor_subsystem = unreal.UnrealEditorSubsystem()
+        vp_loc, vp_rot = editor_subsystem.get_level_viewport_camera_info()
+
         root = "/Game/Ayon"
 
         asset_dir = container.get('namespace')
         context = representation.get("context")
 
+        hierarchy = context.get('hierarchy').split("/")
+
         sequence = None
         master_level = None
 
         if create_sequences:
-            hierarchy = context.get('hierarchy').split("/")
             h_dir = f"{root}/{hierarchy[0]}"
             h_asset = hierarchy[0]
             master_level = f"{h_dir}/{h_asset}_map.{h_asset}_map"
@@ -843,13 +734,15 @@ class LayoutLoader(plugin.Loader):
             "parent": str(representation["parent"]),
             "loaded_assets": loaded_assets
         }
-        unreal_pipeline.imprint(
+        imprint(
             "{}/{}".format(asset_dir, container.get('container_name')), data)
 
         EditorLevelLibrary.save_current_level()
 
+        save_dir = f"{root}/{hierarchy[0]}" if create_sequences else asset_dir
+
         asset_content = EditorAssetLibrary.list_assets(
-            asset_dir, recursive=True, include_folder=False)
+            save_dir, recursive=True, include_folder=False)
 
         for a in asset_content:
             EditorAssetLibrary.save_asset(a)
@@ -859,6 +752,13 @@ class LayoutLoader(plugin.Loader):
         elif prev_level:
             EditorLevelLibrary.load_level(prev_level)
 
+        if curr_level_sequence:
+            LevelSequenceLib.open_level_sequence(curr_level_sequence)
+            LevelSequenceLib.set_current_time(curr_time)
+            LevelSequenceLib.set_lock_camera_cut_to_viewport(is_cam_lock)
+
+        editor_subsystem.set_level_viewport_camera_info(vp_loc, vp_rot)
+
     def remove(self, container):
         """
         Delete the layout. First, check if the assets loaded with the layout
@@ -870,7 +770,7 @@ class LayoutLoader(plugin.Loader):
         root = "/Game/Ayon"
         path = Path(container.get("namespace"))
 
-        containers = unreal_pipeline.ls()
+        containers = ls()
         layout_containers = [
             c for c in containers
             if (c.get('asset_name') != container.get('asset_name') and