diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index e3777730075..86e3638ffe2 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -35,6 +35,7 @@ body:
       label: Version
       description: What version are you running? Look to OpenPype Tray
       options:
+        - 3.17.6-nightly.3
         - 3.17.6-nightly.2
         - 3.17.6-nightly.1
         - 3.17.5
@@ -134,7 +135,6 @@ body:
         - 3.15.2-nightly.2
         - 3.15.2-nightly.1
         - 3.15.1
-        - 3.15.1-nightly.6
     validations:
       required: true
   - type: dropdown
diff --git a/openpype/hosts/blender/api/__init__.py b/openpype/hosts/blender/api/__init__.py
index e15f1193a53..ce2b444997b 100644
--- a/openpype/hosts/blender/api/__init__.py
+++ b/openpype/hosts/blender/api/__init__.py
@@ -10,6 +10,7 @@
     ls,
     publish,
     containerise,
+    BlenderHost,
 )
 
 from .plugin import (
@@ -47,6 +48,7 @@
     "ls",
     "publish",
     "containerise",
+    "BlenderHost",
 
     "Creator",
     "Loader",
diff --git a/openpype/hosts/blender/api/lib.py b/openpype/hosts/blender/api/lib.py
index 1f68dd08396..e80ed61bc81 100644
--- a/openpype/hosts/blender/api/lib.py
+++ b/openpype/hosts/blender/api/lib.py
@@ -188,7 +188,7 @@ def imprint(node: bpy.types.bpy_struct_meta_idprop, data: Dict):
             # Support values evaluated at imprint
             value = value()
 
-        if not isinstance(value, (int, float, bool, str, list)):
+        if not isinstance(value, (int, float, bool, str, list, dict)):
             raise TypeError(f"Unsupported type: {type(value)}")
 
         imprint_data[key] = value
@@ -278,9 +278,11 @@ def get_selected_collections():
         list: A list of `bpy.types.Collection` objects that are currently
         selected in the outliner.
     """
+    window = bpy.context.window or bpy.context.window_manager.windows[0]
+
     try:
         area = next(
-            area for area in bpy.context.window.screen.areas
+            area for area in window.screen.areas
             if area.type == 'OUTLINER')
         region = next(
             region for region in area.regions
@@ -290,10 +292,10 @@ def get_selected_collections():
                            "must be in the main Blender window.") from e
 
     with bpy.context.temp_override(
-        window=bpy.context.window,
+        window=window,
         area=area,
         region=region,
-        screen=bpy.context.window.screen
+        screen=window.screen
     ):
         ids = bpy.context.selected_ids
 
diff --git a/openpype/hosts/blender/api/ops.py b/openpype/hosts/blender/api/ops.py
index 208c11cfe8f..f4d96e563aa 100644
--- a/openpype/hosts/blender/api/ops.py
+++ b/openpype/hosts/blender/api/ops.py
@@ -31,6 +31,14 @@
 TIMER_INTERVAL: float = 0.01 if platform.system() == "Windows" else 0.1
 
 
+def execute_function_in_main_thread(f):
+    """Decorator to move a function call into main thread items"""
+    def wrapper(*args, **kwargs):
+        mti = MainThreadItem(f, *args, **kwargs)
+        execute_in_main_thread(mti)
+    return wrapper
+
+
 class BlenderApplication(QtWidgets.QApplication):
     _instance = None
     blender_windows = {}
@@ -238,8 +246,24 @@ def execute(self, context):
 
         self.before_window_show()
 
+        def pull_to_front(window):
+            """Pull window forward to screen.
+
+            If Window is minimized this will un-minimize, then it can be raised
+            and activated to the front.
+            """
+            window.setWindowState(
+                (window.windowState() & ~QtCore.Qt.WindowMinimized) |
+                QtCore.Qt.WindowActive
+            )
+            window.raise_()
+            window.activateWindow()
+
         if isinstance(self._window, ModuleType):
             self._window.show()
+            pull_to_front(self._window)
+
+            # Pull window to the front
             window = None
             if hasattr(self._window, "window"):
                 window = self._window.window
@@ -254,6 +278,7 @@ def execute(self, context):
             on_top_flags = origin_flags | QtCore.Qt.WindowStaysOnTopHint
             self._window.setWindowFlags(on_top_flags)
             self._window.show()
+            pull_to_front(self._window)
 
             # if on_top_flags != origin_flags:
             #     self._window.setWindowFlags(origin_flags)
@@ -275,6 +300,10 @@ class LaunchCreator(LaunchQtApp):
     def before_window_show(self):
         self._window.refresh()
 
+    def execute(self, context):
+        host_tools.show_publisher(tab="create")
+        return {"FINISHED"}
+
 
 class LaunchLoader(LaunchQtApp):
     """Launch Avalon Loader."""
@@ -299,7 +328,7 @@ class LaunchPublisher(LaunchQtApp):
     bl_label = "Publish..."
 
     def execute(self, context):
-        host_tools.show_publish()
+        host_tools.show_publisher(tab="publish")
         return {"FINISHED"}
 
 
@@ -416,7 +445,6 @@ def draw(self, context):
         layout.operator(SetResolution.bl_idname, text="Set Resolution")
         layout.separator()
         layout.operator(LaunchWorkFiles.bl_idname, text="Work Files...")
-        # TODO (jasper): maybe add 'Reload Pipeline'
 
 
 def draw_avalon_menu(self, context):
diff --git a/openpype/hosts/blender/api/pipeline.py b/openpype/hosts/blender/api/pipeline.py
index 84af0904f0d..b386dd49d3a 100644
--- a/openpype/hosts/blender/api/pipeline.py
+++ b/openpype/hosts/blender/api/pipeline.py
@@ -10,6 +10,12 @@
 
 import pyblish.api
 
+from openpype.host import (
+    HostBase,
+    IWorkfileHost,
+    IPublishHost,
+    ILoadHost
+)
 from openpype.client import get_asset_by_name
 from openpype.pipeline import (
     schema,
@@ -29,6 +35,14 @@
 )
 import openpype.hosts.blender
 from openpype.settings import get_project_settings
+from .workio import (
+    open_file,
+    save_file,
+    current_file,
+    has_unsaved_changes,
+    file_extensions,
+    work_root,
+)
 
 
 HOST_DIR = os.path.dirname(os.path.abspath(openpype.hosts.blender.__file__))
@@ -47,6 +61,101 @@
 log = Logger.get_logger(__name__)
 
 
+class BlenderHost(HostBase, IWorkfileHost, IPublishHost, ILoadHost):
+    name = "blender"
+
+    def install(self):
+        """Override install method from HostBase.
+        Install Blender host functionality."""
+        install()
+
+    def get_containers(self) -> Iterator:
+        """List containers from active Blender scene."""
+        return ls()
+
+    def get_workfile_extensions(self) -> List[str]:
+        """Override get_workfile_extensions method from IWorkfileHost.
+        Get workfile possible extensions.
+
+        Returns:
+            List[str]: Workfile extensions.
+        """
+        return file_extensions()
+
+    def save_workfile(self, dst_path: str = None):
+        """Override save_workfile method from IWorkfileHost.
+        Save currently opened workfile.
+
+        Args:
+            dst_path (str): Where the current scene should be saved. Or use
+                current path if `None` is passed.
+        """
+        save_file(dst_path if dst_path else bpy.data.filepath)
+
+    def open_workfile(self, filepath: str):
+        """Override open_workfile method from IWorkfileHost.
+        Open workfile at specified filepath in the host.
+
+        Args:
+            filepath (str): Path to workfile.
+        """
+        open_file(filepath)
+
+    def get_current_workfile(self) -> str:
+        """Override get_current_workfile method from IWorkfileHost.
+        Retrieve currently opened workfile path.
+
+        Returns:
+            str: Path to currently opened workfile.
+        """
+        return current_file()
+
+    def workfile_has_unsaved_changes(self) -> bool:
+        """Override wokfile_has_unsaved_changes method from IWorkfileHost.
+        Returns True if opened workfile has no unsaved changes.
+
+        Returns:
+            bool: True if scene is saved and False if it has unsaved
+                modifications.
+        """
+        return has_unsaved_changes()
+
+    def work_root(self, session) -> str:
+        """Override work_root method from IWorkfileHost.
+        Modify workdir per host.
+
+        Args:
+            session (dict): Session context data.
+
+        Returns:
+            str: Path to new workdir.
+        """
+        return work_root(session)
+
+    def get_context_data(self) -> dict:
+        """Override abstract method from IPublishHost.
+        Get global data related to creation-publishing from workfile.
+
+        Returns:
+            dict: Context data stored using 'update_context_data'.
+        """
+        property = bpy.context.scene.get(AVALON_PROPERTY)
+        if property:
+            return property.to_dict()
+        return {}
+
+    def update_context_data(self, data: dict, changes: dict):
+        """Override abstract method from IPublishHost.
+        Store global context data to workfile.
+
+        Args:
+            data (dict): New data as are.
+            changes (dict): Only data that has been changed. Each value has
+                tuple with '(<old>, <new>)' value.
+        """
+        bpy.context.scene[AVALON_PROPERTY] = data
+
+
 def pype_excepthook_handler(*args):
     traceback.print_exception(*args)
 
diff --git a/openpype/hosts/blender/api/plugin.py b/openpype/hosts/blender/api/plugin.py
index 2f940011ba3..8d33187da33 100644
--- a/openpype/hosts/blender/api/plugin.py
+++ b/openpype/hosts/blender/api/plugin.py
@@ -1,31 +1,34 @@
 """Shared functionality for pipeline plugins for Blender."""
 
+import itertools
 from pathlib import Path
 from typing import Dict, List, Optional
 
 import bpy
 
 from openpype.pipeline import (
-    LegacyCreator,
+    Creator,
+    CreatedInstance,
     LoaderPlugin,
+    get_current_task_name,
 )
+from openpype.lib import BoolDef
+
 from .pipeline import (
     AVALON_CONTAINERS,
+    AVALON_INSTANCES,
     AVALON_PROPERTY,
 )
 from .ops import (
     MainThreadItem,
     execute_in_main_thread
 )
-from .lib import (
-    imprint,
-    get_selection
-)
+from .lib import imprint
 
 VALID_EXTENSIONS = [".blend", ".json", ".abc", ".fbx"]
 
 
-def asset_name(
+def prepare_scene_name(
     asset: str, subset: str, namespace: Optional[str] = None
 ) -> str:
     """Return a consistent name for an asset."""
@@ -144,20 +147,211 @@ def deselect_all():
     bpy.context.view_layer.objects.active = active
 
 
-class Creator(LegacyCreator):
-    """Base class for Creator plug-ins."""
+class BaseCreator(Creator):
+    """Base class for Blender Creator plug-ins."""
     defaults = ['Main']
 
-    def process(self):
-        collection = bpy.data.collections.new(name=self.data["subset"])
-        bpy.context.scene.collection.children.link(collection)
-        imprint(collection, self.data)
+    create_as_asset_group = False
+
+    @staticmethod
+    def cache_subsets(shared_data):
+        """Cache instances for Creators shared data.
+
+        Create `blender_cached_subsets` key when needed in shared data and
+        fill it with all collected instances from the scene under its
+        respective creator identifiers.
+
+        If legacy instances are detected in the scene, create
+        `blender_cached_legacy_subsets` key and fill it with
+        all legacy subsets from this family as a value.  # key or value?
+
+        Args:
+            shared_data(Dict[str, Any]): Shared data.
+
+        Return:
+            Dict[str, Any]: Shared data with cached subsets.
+        """
+        if not shared_data.get('blender_cached_subsets'):
+            cache = {}
+            cache_legacy = {}
+
+            avalon_instances = bpy.data.collections.get(AVALON_INSTANCES)
+            avalon_instance_objs = (
+                avalon_instances.objects if avalon_instances else []
+            )
+
+            for obj_or_col in itertools.chain(
+                    avalon_instance_objs,
+                    bpy.data.collections
+            ):
+                avalon_prop = obj_or_col.get(AVALON_PROPERTY, {})
+                if not avalon_prop:
+                    continue
+
+                if avalon_prop.get('id') != 'pyblish.avalon.instance':
+                    continue
+
+                creator_id = avalon_prop.get('creator_identifier')
+                if creator_id:
+                    # Creator instance
+                    cache.setdefault(creator_id, []).append(obj_or_col)
+                else:
+                    family = avalon_prop.get('family')
+                    if family:
+                        # Legacy creator instance
+                        cache_legacy.setdefault(family, []).append(obj_or_col)
+
+            shared_data["blender_cached_subsets"] = cache
+            shared_data["blender_cached_legacy_subsets"] = cache_legacy
+
+        return shared_data
+
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+        """Override abstract method from Creator.
+        Create new instance and store it.
+
+        Args:
+            subset_name(str): Subset name of created instance.
+            instance_data(dict): Instance base data.
+            pre_create_data(dict): Data based on pre creation attributes.
+                Those may affect how creator works.
+        """
+        # Get Instance Container or create it if it does not exist
+        instances = bpy.data.collections.get(AVALON_INSTANCES)
+        if not instances:
+            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
+            bpy.context.scene.collection.children.link(instances)
+
+        # Create asset group
+        name = prepare_scene_name(instance_data["asset"], subset_name)
+        if self.create_as_asset_group:
+            # Create instance as empty
+            instance_node = bpy.data.objects.new(name=name, object_data=None)
+            instance_node.empty_display_type = 'SINGLE_ARROW'
+            instances.objects.link(instance_node)
+        else:
+            # Create instance collection
+            instance_node = bpy.data.collections.new(name=name)
+            instances.children.link(instance_node)
+
+        self.set_instance_data(subset_name, instance_data)
+
+        instance = CreatedInstance(
+            self.family, subset_name, instance_data, self
+        )
+        instance.transient_data["instance_node"] = instance_node
+        self._add_instance_to_context(instance)
+
+        imprint(instance_node, instance_data)
+
+        return instance_node
+
+    def collect_instances(self):
+        """Override abstract method from BaseCreator.
+        Collect existing instances related to this creator plugin."""
 
-        if (self.options or {}).get("useSelection"):
-            for obj in get_selection():
-                collection.objects.link(obj)
+        # Cache subsets in shared data
+        self.cache_subsets(self.collection_shared_data)
+
+        # Get cached subsets
+        cached_subsets = self.collection_shared_data.get(
+            "blender_cached_subsets"
+        )
+        if not cached_subsets:
+            return
+
+        # Process only instances that were created by this creator
+        for instance_node in cached_subsets.get(self.identifier, []):
+            property = instance_node.get(AVALON_PROPERTY)
+            # Create instance object from existing data
+            instance = CreatedInstance.from_existing(
+                instance_data=property.to_dict(),
+                creator=self
+            )
+            instance.transient_data["instance_node"] = instance_node
+
+            # Add instance to create context
+            self._add_instance_to_context(instance)
+
+    def update_instances(self, update_list):
+        """Override abstract method from BaseCreator.
+        Store changes of existing instances so they can be recollected.
+
+        Args:
+            update_list(List[UpdateData]): Changed instances
+                and their changes, as a list of tuples."""
+        for created_instance, changes in update_list:
+            data = created_instance.data_to_store()
+            node = created_instance.transient_data["instance_node"]
+            if not node:
+                # We can't update if we don't know the node
+                self.log.error(
+                    f"Unable to update instance {created_instance} "
+                    f"without instance node."
+                )
+                return
+
+            # Rename the instance node in the scene if subset or asset changed
+            if (
+                    "subset" in changes.changed_keys
+                    or "asset" in changes.changed_keys
+            ):
+                name = prepare_scene_name(
+                    asset=data["asset"], subset=data["subset"]
+                )
+                node.name = name
+
+            imprint(node, data)
+
+    def remove_instances(self, instances: List[CreatedInstance]):
+
+        for instance in instances:
+            node = instance.transient_data["instance_node"]
+
+            if isinstance(node, bpy.types.Collection):
+                for children in node.children_recursive:
+                    if isinstance(children, bpy.types.Collection):
+                        bpy.data.collections.remove(children)
+                    else:
+                        bpy.data.objects.remove(children)
+
+                bpy.data.collections.remove(node)
+            elif isinstance(node, bpy.types.Object):
+                bpy.data.objects.remove(node)
+
+            self._remove_instance_from_context(instance)
+
+    def set_instance_data(
+        self,
+        subset_name: str,
+        instance_data: dict
+    ):
+        """Fill instance data with required items.
+
+        Args:
+            subset_name(str): Subset name of created instance.
+            instance_data(dict): Instance base data.
+            instance_node(bpy.types.ID): Instance node in blender scene.
+        """
+        if not instance_data:
+            instance_data = {}
+
+        instance_data.update(
+            {
+                "id": "pyblish.avalon.instance",
+                "creator_identifier": self.identifier,
+                "subset": subset_name,
+            }
+        )
 
-        return collection
+    def get_pre_create_attr_defs(self):
+        return [
+            BoolDef("use_selection",
+                    label="Use selection",
+                    default=True)
+        ]
 
 
 class Loader(LoaderPlugin):
@@ -251,7 +445,7 @@ def _load(self,
             namespace: Use pre-defined namespace
             options: Additional settings dictionary
         """
-        # TODO (jasper): make it possible to add the asset several times by
+        # TODO: make it possible to add the asset several times by
         # just re-using the collection
         filepath = self.filepath_from_context(context)
         assert Path(filepath).exists(), f"{filepath} doesn't exist."
@@ -262,7 +456,7 @@ def _load(self,
             asset, subset
         )
         namespace = namespace or f"{asset}_{unique_number}"
-        name = name or asset_name(
+        name = name or prepare_scene_name(
             asset, subset, unique_number
         )
 
@@ -291,7 +485,9 @@ def _load(self,
 
         # asset = context["asset"]["name"]
         # subset = context["subset"]["name"]
-        # instance_name = asset_name(asset, subset, unique_number) + '_CON'
+        # instance_name = prepare_scene_name(
+        #     asset, subset, unique_number
+        # ) + '_CON'
 
         # return self._get_instance_collection(instance_name, nodes)
 
diff --git a/openpype/hosts/blender/blender_addon/startup/init.py b/openpype/hosts/blender/blender_addon/startup/init.py
index 8dbff8a91de..603691675df 100644
--- a/openpype/hosts/blender/blender_addon/startup/init.py
+++ b/openpype/hosts/blender/blender_addon/startup/init.py
@@ -1,9 +1,9 @@
 from openpype.pipeline import install_host
-from openpype.hosts.blender import api
+from openpype.hosts.blender.api import BlenderHost
 
 
 def register():
-    install_host(api)
+    install_host(BlenderHost())
 
 
 def unregister():
diff --git a/openpype/hosts/blender/plugins/create/convert_legacy.py b/openpype/hosts/blender/plugins/create/convert_legacy.py
new file mode 100644
index 00000000000..f05a6b1f5a4
--- /dev/null
+++ b/openpype/hosts/blender/plugins/create/convert_legacy.py
@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+"""Converter for legacy Houdini subsets."""
+from openpype.pipeline.create.creator_plugins import SubsetConvertorPlugin
+from openpype.hosts.blender.api.lib import imprint
+
+
+class BlenderLegacyConvertor(SubsetConvertorPlugin):
+    """Find and convert any legacy subsets in the scene.
+
+    This Converter will find all legacy subsets in the scene and will
+    transform them to the current system. Since the old subsets doesn't
+    retain any information about their original creators, the only mapping
+    we can do is based on their families.
+
+    Its limitation is that you can have multiple creators creating subset
+    of the same family and there is no way to handle it. This code should
+    nevertheless cover all creators that came with OpenPype.
+
+    """
+    identifier = "io.openpype.creators.blender.legacy"
+    family_to_id = {
+        "action": "io.openpype.creators.blender.action",
+        "camera": "io.openpype.creators.blender.camera",
+        "animation": "io.openpype.creators.blender.animation",
+        "blendScene": "io.openpype.creators.blender.blendscene",
+        "layout": "io.openpype.creators.blender.layout",
+        "model": "io.openpype.creators.blender.model",
+        "pointcache": "io.openpype.creators.blender.pointcache",
+        "render": "io.openpype.creators.blender.render",
+        "review": "io.openpype.creators.blender.review",
+        "rig": "io.openpype.creators.blender.rig",
+    }
+
+    def __init__(self, *args, **kwargs):
+        super(BlenderLegacyConvertor, self).__init__(*args, **kwargs)
+        self.legacy_subsets = {}
+
+    def find_instances(self):
+        """Find legacy subsets in the scene.
+
+        Legacy subsets are the ones that doesn't have `creator_identifier`
+        parameter on them.
+
+        This is using cached entries done in
+        :py:meth:`~BaseCreator.cache_subsets()`
+
+        """
+        self.legacy_subsets = self.collection_shared_data.get(
+            "blender_cached_legacy_subsets")
+        if not self.legacy_subsets:
+            return
+        self.add_convertor_item(
+            "Found {} incompatible subset{}".format(
+                len(self.legacy_subsets),
+                "s" if len(self.legacy_subsets) > 1 else ""
+            )
+        )
+
+    def convert(self):
+        """Convert all legacy subsets to current.
+
+        It is enough to add `creator_identifier` and `instance_node`.
+
+        """
+        if not self.legacy_subsets:
+            return
+
+        for family, instance_nodes in self.legacy_subsets.items():
+            if family in self.family_to_id:
+                for instance_node in instance_nodes:
+                    creator_identifier = self.family_to_id[family]
+                    self.log.info(
+                        "Converting {} to {}".format(instance_node.name,
+                                                     creator_identifier)
+                    )
+                    imprint(instance_node, data={
+                        "creator_identifier": creator_identifier
+                    })
diff --git a/openpype/hosts/blender/plugins/create/create_action.py b/openpype/hosts/blender/plugins/create/create_action.py
index 0203ba74c08..caaa72fe8d2 100644
--- a/openpype/hosts/blender/plugins/create/create_action.py
+++ b/openpype/hosts/blender/plugins/create/create_action.py
@@ -2,30 +2,29 @@
 
 import bpy
 
-from openpype.pipeline import get_current_task_name
-import openpype.hosts.blender.api.plugin
-from openpype.hosts.blender.api import lib
+from openpype.hosts.blender.api import lib, plugin
 
 
-class CreateAction(openpype.hosts.blender.api.plugin.Creator):
-    """Action output for character rigs"""
+class CreateAction(plugin.BaseCreator):
+    """Action output for character rigs."""
 
-    name = "actionMain"
+    identifier = "io.openpype.creators.blender.action"
     label = "Action"
     family = "action"
     icon = "male"
 
-    def process(self):
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+        # Run parent create method
+        collection = super().create(
+            subset_name, instance_data, pre_create_data
+        )
 
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = openpype.hosts.blender.api.plugin.asset_name(asset, subset)
-        collection = bpy.data.collections.new(name=name)
-        bpy.context.scene.collection.children.link(collection)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(collection, self.data)
+        # Get instance name
+        name = plugin.prepare_scene_name(instance_data["asset"], subset_name)
 
-        if (self.options or {}).get("useSelection"):
+        if pre_create_data.get("use_selection"):
             for obj in lib.get_selection():
                 if (obj.animation_data is not None
                         and obj.animation_data.action is not None):
diff --git a/openpype/hosts/blender/plugins/create/create_animation.py b/openpype/hosts/blender/plugins/create/create_animation.py
index bc2840952b6..3a91b2d5ff5 100644
--- a/openpype/hosts/blender/plugins/create/create_animation.py
+++ b/openpype/hosts/blender/plugins/create/create_animation.py
@@ -1,51 +1,32 @@
 """Create an animation asset."""
 
-import bpy
+from openpype.hosts.blender.api import plugin, lib
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
 
+class CreateAnimation(plugin.BaseCreator):
+    """Animation output for character rigs."""
 
-class CreateAnimation(plugin.Creator):
-    """Animation output for character rigs"""
-
-    name = "animationMain"
+    identifier = "io.openpype.creators.blender.animation"
     label = "Animation"
     family = "animation"
     icon = "male"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
-
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+        # Run parent create method
+        collection = super().create(
+            subset_name, instance_data, pre_create_data
+        )
 
-        # Create instance object
-        # name = self.name
-        # if not name:
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        # asset_group = bpy.data.objects.new(name=name, object_data=None)
-        # asset_group.empty_display_type = 'SINGLE_ARROW'
-        asset_group = bpy.data.collections.new(name=name)
-        instances.children.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
-
-        if (self.options or {}).get("useSelection"):
+        if pre_create_data.get("use_selection"):
             selected = lib.get_selection()
             for obj in selected:
-                asset_group.objects.link(obj)
-        elif (self.options or {}).get("asset_group"):
-            obj = (self.options or {}).get("asset_group")
-            asset_group.objects.link(obj)
-
-        return asset_group
+                collection.objects.link(obj)
+        elif pre_create_data.get("asset_group"):
+            # Use for Load Blend automated creation of animation instances
+            # upon loading rig files
+            obj = pre_create_data.get("asset_group")
+            collection.objects.link(obj)
+
+        return collection
diff --git a/openpype/hosts/blender/plugins/create/create_blendScene.py b/openpype/hosts/blender/plugins/create/create_blendScene.py
index bb57a16888c..e1026282c0b 100644
--- a/openpype/hosts/blender/plugins/create/create_blendScene.py
+++ b/openpype/hosts/blender/plugins/create/create_blendScene.py
@@ -2,51 +2,33 @@
 
 import bpy
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
 
 
-class CreateBlendScene(plugin.Creator):
-    """Generic group of assets"""
+class CreateBlendScene(plugin.BaseCreator):
+    """Generic group of assets."""
 
-    name = "blendScene"
+    identifier = "io.openpype.creators.blender.blendscene"
     label = "Blender Scene"
     family = "blendScene"
     icon = "cubes"
 
     maintain_selection = False
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
-
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-
-        # Create the new asset group as collection
-        asset_group = bpy.data.collections.new(name=name)
-        instances.children.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
-
-        if (self.options or {}).get("useSelection"):
-            selection = lib.get_selection(include_collections=True)
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+
+        instance_node = super().create(subset_name,
+                                       instance_data,
+                                       pre_create_data)
 
+        if pre_create_data.get("use_selection"):
+            selection = lib.get_selection(include_collections=True)
             for data in selection:
                 if isinstance(data, bpy.types.Collection):
-                    asset_group.children.link(data)
+                    instance_node.children.link(data)
                 elif isinstance(data, bpy.types.Object):
-                    asset_group.objects.link(data)
+                    instance_node.objects.link(data)
 
-        return asset_group
+        return instance_node
diff --git a/openpype/hosts/blender/plugins/create/create_camera.py b/openpype/hosts/blender/plugins/create/create_camera.py
index 7a770a3e77e..2e2e6cec22c 100644
--- a/openpype/hosts/blender/plugins/create/create_camera.py
+++ b/openpype/hosts/blender/plugins/create/create_camera.py
@@ -2,62 +2,41 @@
 
 import bpy
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
+from openpype.hosts.blender.api import plugin, lib
 from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
 
 
-class CreateCamera(plugin.Creator):
-    """Polygonal static geometry"""
+class CreateCamera(plugin.BaseCreator):
+    """Polygonal static geometry."""
 
-    name = "cameraMain"
+    identifier = "io.openpype.creators.blender.camera"
     label = "Camera"
     family = "camera"
     icon = "video-camera"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
-
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-
-        asset_group = bpy.data.objects.new(name=name, object_data=None)
-        asset_group.empty_display_type = 'SINGLE_ARROW'
-        instances.objects.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        print(f"self.data: {self.data}")
-        lib.imprint(asset_group, self.data)
-
-        if (self.options or {}).get("useSelection"):
-            bpy.context.view_layer.objects.active = asset_group
-            selected = lib.get_selection()
-            for obj in selected:
-                if obj.parent in selected:
-                    obj.select_set(False)
-                    continue
-            selected.append(asset_group)
-            bpy.ops.object.parent_set(keep_transform=True)
+    create_as_asset_group = True
+
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+
+        asset_group = super().create(subset_name,
+                                     instance_data,
+                                     pre_create_data)
+
+        bpy.context.view_layer.objects.active = asset_group
+        if pre_create_data.get("use_selection"):
+            for obj in lib.get_selection():
+                obj.parent = asset_group
         else:
             plugin.deselect_all()
-            camera = bpy.data.cameras.new(subset)
-            camera_obj = bpy.data.objects.new(subset, camera)
+            camera = bpy.data.cameras.new(subset_name)
+            camera_obj = bpy.data.objects.new(subset_name, camera)
 
+            instances = bpy.data.collections.get(AVALON_INSTANCES)
             instances.objects.link(camera_obj)
 
-            camera_obj.select_set(True)
-            asset_group.select_set(True)
             bpy.context.view_layer.objects.active = asset_group
-            bpy.ops.object.parent_set(keep_transform=True)
+            camera_obj.parent = asset_group
 
         return asset_group
diff --git a/openpype/hosts/blender/plugins/create/create_layout.py b/openpype/hosts/blender/plugins/create/create_layout.py
index 73ed6832560..16d227e50e4 100644
--- a/openpype/hosts/blender/plugins/create/create_layout.py
+++ b/openpype/hosts/blender/plugins/create/create_layout.py
@@ -2,50 +2,31 @@
 
 import bpy
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
 
 
-class CreateLayout(plugin.Creator):
-    """Layout output for character rigs"""
+class CreateLayout(plugin.BaseCreator):
+    """Layout output for character rigs."""
 
-    name = "layoutMain"
+    identifier = "io.openpype.creators.blender.layout"
     label = "Layout"
     family = "layout"
     icon = "cubes"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
-
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.objects.new(name=name, object_data=None)
-        asset_group.empty_display_type = 'SINGLE_ARROW'
-        instances.objects.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
+    create_as_asset_group = True
+
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+
+        asset_group = super().create(subset_name,
+                                     instance_data,
+                                     pre_create_data)
 
         # Add selected objects to instance
-        if (self.options or {}).get("useSelection"):
+        if pre_create_data.get("use_selection"):
             bpy.context.view_layer.objects.active = asset_group
-            selected = lib.get_selection()
-            for obj in selected:
-                if obj.parent in selected:
-                    obj.select_set(False)
-                    continue
-            selected.append(asset_group)
-            bpy.ops.object.parent_set(keep_transform=True)
+            for obj in lib.get_selection():
+                obj.parent = asset_group
 
         return asset_group
diff --git a/openpype/hosts/blender/plugins/create/create_model.py b/openpype/hosts/blender/plugins/create/create_model.py
index 51fc6683f6e..2f3f61728b2 100644
--- a/openpype/hosts/blender/plugins/create/create_model.py
+++ b/openpype/hosts/blender/plugins/create/create_model.py
@@ -2,50 +2,30 @@
 
 import bpy
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
 
 
-class CreateModel(plugin.Creator):
-    """Polygonal static geometry"""
+class CreateModel(plugin.BaseCreator):
+    """Polygonal static geometry."""
 
-    name = "modelMain"
+    identifier = "io.openpype.creators.blender.model"
     label = "Model"
     family = "model"
     icon = "cube"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
-
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.objects.new(name=name, object_data=None)
-        asset_group.empty_display_type = 'SINGLE_ARROW'
-        instances.objects.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
+    create_as_asset_group = True
+
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+        asset_group = super().create(subset_name,
+                                     instance_data,
+                                     pre_create_data)
 
         # Add selected objects to instance
-        if (self.options or {}).get("useSelection"):
+        if pre_create_data.get("use_selection"):
             bpy.context.view_layer.objects.active = asset_group
-            selected = lib.get_selection()
-            for obj in selected:
-                if obj.parent in selected:
-                    obj.select_set(False)
-                    continue
-            selected.append(asset_group)
-            bpy.ops.object.parent_set(keep_transform=True)
+            for obj in lib.get_selection():
+                obj.parent = asset_group
 
         return asset_group
diff --git a/openpype/hosts/blender/plugins/create/create_pointcache.py b/openpype/hosts/blender/plugins/create/create_pointcache.py
index 65cf18472d4..b3329bcb3ba 100644
--- a/openpype/hosts/blender/plugins/create/create_pointcache.py
+++ b/openpype/hosts/blender/plugins/create/create_pointcache.py
@@ -1,51 +1,29 @@
 """Create a pointcache asset."""
 
-import bpy
+from openpype.hosts.blender.api import plugin, lib
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
 
+class CreatePointcache(plugin.BaseCreator):
+    """Polygonal static geometry."""
 
-class CreatePointcache(plugin.Creator):
-    """Polygonal static geometry"""
-
-    name = "pointcacheMain"
+    identifier = "io.openpype.creators.blender.pointcache"
     label = "Point Cache"
     family = "pointcache"
     icon = "gears"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
-
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.objects.new(name=name, object_data=None)
-        asset_group.empty_display_type = 'SINGLE_ARROW'
-        instances.objects.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
-
-        # Add selected objects to instance
-        if (self.options or {}).get("useSelection"):
-            bpy.context.view_layer.objects.active = asset_group
-            selected = lib.get_selection()
-            for obj in selected:
-                if obj.parent in selected:
-                    obj.select_set(False)
-                    continue
-            selected.append(asset_group)
-            bpy.ops.object.parent_set(keep_transform=True)
-
-        return asset_group
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+        # Run parent create method
+        collection = super().create(
+            subset_name, instance_data, pre_create_data
+        )
+
+        if pre_create_data.get("use_selection"):
+            objects = lib.get_selection()
+            for obj in objects:
+                collection.objects.link(obj)
+                if obj.type == 'EMPTY':
+                    objects.extend(obj.children)
+
+        return collection
diff --git a/openpype/hosts/blender/plugins/create/create_render.py b/openpype/hosts/blender/plugins/create/create_render.py
index f938a218082..7fb3e5eb006 100644
--- a/openpype/hosts/blender/plugins/create/create_render.py
+++ b/openpype/hosts/blender/plugins/create/create_render.py
@@ -1,42 +1,31 @@
 """Create render."""
 import bpy
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib
+from openpype.hosts.blender.api import plugin
 from openpype.hosts.blender.api.render_lib import prepare_rendering
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
 
 
-class CreateRenderlayer(plugin.Creator):
-    """Single baked camera"""
+class CreateRenderlayer(plugin.BaseCreator):
+    """Single baked camera."""
 
-    name = "renderingMain"
+    identifier = "io.openpype.creators.blender.render"
     label = "Render"
     family = "render"
     icon = "eye"
 
-    def process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.collections.new(name=name)
-
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
         try:
-            instances.children.link(asset_group)
-            self.data['task'] = get_current_task_name()
-            lib.imprint(asset_group, self.data)
+            # Run parent create method
+            collection = super().create(
+                subset_name, instance_data, pre_create_data
+            )
 
-            prepare_rendering(asset_group)
+            prepare_rendering(collection)
         except Exception:
             # Remove the instance if there was an error
-            bpy.data.collections.remove(asset_group)
+            bpy.data.collections.remove(collection)
             raise
 
         # TODO: this is undesiderable, but it's the only way to be sure that
@@ -50,4 +39,4 @@ def process(self):
         # now it is to force the file to be saved.
         bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
 
-        return asset_group
+        return collection
diff --git a/openpype/hosts/blender/plugins/create/create_review.py b/openpype/hosts/blender/plugins/create/create_review.py
index 914f249891e..940bcbea227 100644
--- a/openpype/hosts/blender/plugins/create/create_review.py
+++ b/openpype/hosts/blender/plugins/create/create_review.py
@@ -1,47 +1,27 @@
 """Create review."""
 
-import bpy
+from openpype.hosts.blender.api import plugin, lib
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
 
+class CreateReview(plugin.BaseCreator):
+    """Single baked camera."""
 
-class CreateReview(plugin.Creator):
-    """Single baked camera"""
-
-    name = "reviewDefault"
+    identifier = "io.openpype.creators.blender.review"
     label = "Review"
     family = "review"
     icon = "video-camera"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
-
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.collections.new(name=name)
-        instances.children.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+        # Run parent create method
+        collection = super().create(
+            subset_name, instance_data, pre_create_data
+        )
 
-        if (self.options or {}).get("useSelection"):
+        if pre_create_data.get("use_selection"):
             selected = lib.get_selection()
             for obj in selected:
-                asset_group.objects.link(obj)
-        elif (self.options or {}).get("asset_group"):
-            obj = (self.options or {}).get("asset_group")
-            asset_group.objects.link(obj)
+                collection.objects.link(obj)
 
-        return asset_group
+        return collection
diff --git a/openpype/hosts/blender/plugins/create/create_rig.py b/openpype/hosts/blender/plugins/create/create_rig.py
index 08cc46ee3e3..d63b8d56ff2 100644
--- a/openpype/hosts/blender/plugins/create/create_rig.py
+++ b/openpype/hosts/blender/plugins/create/create_rig.py
@@ -2,50 +2,30 @@
 
 import bpy
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
 
 
-class CreateRig(plugin.Creator):
-    """Artist-friendly rig with controls to direct motion"""
+class CreateRig(plugin.BaseCreator):
+    """Artist-friendly rig with controls to direct motion."""
 
-    name = "rigMain"
+    identifier = "io.openpype.creators.blender.rig"
     label = "Rig"
     family = "rig"
     icon = "wheelchair"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
-
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.objects.new(name=name, object_data=None)
-        asset_group.empty_display_type = 'SINGLE_ARROW'
-        instances.objects.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
+    create_as_asset_group = True
+
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+        asset_group = super().create(subset_name,
+                                     instance_data,
+                                     pre_create_data)
 
         # Add selected objects to instance
-        if (self.options or {}).get("useSelection"):
+        if pre_create_data.get("use_selection"):
             bpy.context.view_layer.objects.active = asset_group
-            selected = lib.get_selection()
-            for obj in selected:
-                if obj.parent in selected:
-                    obj.select_set(False)
-                    continue
-            selected.append(asset_group)
-            bpy.ops.object.parent_set(keep_transform=True)
+            for obj in lib.get_selection():
+                obj.parent = asset_group
 
         return asset_group
diff --git a/openpype/hosts/blender/plugins/create/create_workfile.py b/openpype/hosts/blender/plugins/create/create_workfile.py
new file mode 100644
index 00000000000..92454347663
--- /dev/null
+++ b/openpype/hosts/blender/plugins/create/create_workfile.py
@@ -0,0 +1,105 @@
+import bpy
+
+from openpype.pipeline import CreatedInstance, AutoCreator
+from openpype.client import get_asset_by_name
+from openpype.hosts.blender.api.plugin import BaseCreator
+from openpype.hosts.blender.api.pipeline import (
+    AVALON_PROPERTY,
+    AVALON_CONTAINERS
+)
+
+
+class CreateWorkfile(BaseCreator, AutoCreator):
+    """Workfile auto-creator.
+
+    The workfile instance stores its data on the `AVALON_CONTAINERS` collection
+    as custom attributes, because unlike other instances it doesn't have an
+    instance node of its own.
+
+    """
+    identifier = "io.openpype.creators.blender.workfile"
+    label = "Workfile"
+    family = "workfile"
+    icon = "fa5.file"
+
+    def create(self):
+        """Create workfile instances."""
+        current_instance = next(
+            (
+                instance for instance in self.create_context.instances
+                if instance.creator_identifier == self.identifier
+            ),
+            None,
+        )
+
+        project_name = self.project_name
+        asset_name = self.create_context.get_current_asset_name()
+        task_name = self.create_context.get_current_task_name()
+        host_name = self.create_context.host_name
+
+        if not current_instance:
+            asset_doc = get_asset_by_name(project_name, asset_name)
+            subset_name = self.get_subset_name(
+                task_name, task_name, asset_doc, project_name, host_name
+            )
+            data = {
+                "asset": asset_name,
+                "task": task_name,
+                "variant": task_name,
+            }
+            data.update(
+                self.get_dynamic_data(
+                    task_name,
+                    task_name,
+                    asset_doc,
+                    project_name,
+                    host_name,
+                    current_instance,
+                )
+            )
+            self.log.info("Auto-creating workfile instance...")
+            current_instance = CreatedInstance(
+                self.family, subset_name, data, self
+            )
+            instance_node = bpy.data.collections.get(AVALON_CONTAINERS, {})
+            current_instance.transient_data["instance_node"] = instance_node
+            self._add_instance_to_context(current_instance)
+        elif (
+            current_instance["asset"] != asset_name
+            or current_instance["task"] != task_name
+        ):
+            # Update instance context if it's different
+            asset_doc = get_asset_by_name(project_name, asset_name)
+            subset_name = self.get_subset_name(
+                task_name, task_name, asset_doc, project_name, host_name
+            )
+            current_instance["asset"] = asset_name
+            current_instance["task"] = task_name
+            current_instance["subset"] = subset_name
+
+    def collect_instances(self):
+
+        instance_node = bpy.data.collections.get(AVALON_CONTAINERS)
+        if not instance_node:
+            return
+
+        property = instance_node.get(AVALON_PROPERTY)
+        if not property:
+            return
+
+        # Create instance object from existing data
+        instance = CreatedInstance.from_existing(
+            instance_data=property.to_dict(),
+            creator=self
+        )
+        instance.transient_data["instance_node"] = instance_node
+
+        # Add instance to create context
+        self._add_instance_to_context(instance)
+
+    def remove_instances(self, instances):
+        for instance in instances:
+            node = instance.transient_data["instance_node"]
+            del node[AVALON_PROPERTY]
+
+            self._remove_instance_from_context(instance)
diff --git a/openpype/hosts/blender/plugins/load/import_workfile.py b/openpype/hosts/blender/plugins/load/import_workfile.py
index 4f5016d422a..331f6a8bdbf 100644
--- a/openpype/hosts/blender/plugins/load/import_workfile.py
+++ b/openpype/hosts/blender/plugins/load/import_workfile.py
@@ -7,7 +7,7 @@ def append_workfile(context, fname, do_import):
     asset = context['asset']['name']
     subset = context['subset']['name']
 
-    group_name = plugin.asset_name(asset, subset)
+    group_name = plugin.prepare_scene_name(asset, subset)
 
     # We need to preserve the original names of the scenes, otherwise,
     # if there are duplicate names in the current workfile, the imported
diff --git a/openpype/hosts/blender/plugins/load/load_abc.py b/openpype/hosts/blender/plugins/load/load_abc.py
index 8d1863d4d55..d7e82d1900c 100644
--- a/openpype/hosts/blender/plugins/load/load_abc.py
+++ b/openpype/hosts/blender/plugins/load/load_abc.py
@@ -137,9 +137,9 @@ def process_asset(
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         containers = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_action.py b/openpype/hosts/blender/plugins/load/load_action.py
index 3447e67ebf8..f7d32f92a5e 100644
--- a/openpype/hosts/blender/plugins/load/load_action.py
+++ b/openpype/hosts/blender/plugins/load/load_action.py
@@ -7,7 +7,7 @@
 
 import bpy
 from openpype.pipeline import get_representation_path
-import openpype.hosts.blender.api.plugin
+from openpype.hosts.blender.api import plugin
 from openpype.hosts.blender.api.pipeline import (
     containerise_existing,
     AVALON_PROPERTY,
@@ -16,7 +16,7 @@
 logger = logging.getLogger("openpype").getChild("blender").getChild("load_action")
 
 
-class BlendActionLoader(openpype.hosts.blender.api.plugin.AssetLoader):
+class BlendActionLoader(plugin.AssetLoader):
     """Load action from a .blend file.
 
     Warning:
@@ -46,8 +46,8 @@ def process_asset(
         libpath = self.filepath_from_context(context)
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
-        lib_container = openpype.hosts.blender.api.plugin.asset_name(asset, subset)
-        container_name = openpype.hosts.blender.api.plugin.asset_name(
+        lib_container = plugin.prepare_scene_name(asset, subset)
+        container_name = plugin.prepare_scene_name(
             asset, subset, namespace
         )
 
@@ -152,7 +152,7 @@ def update(self, container: Dict, representation: Dict):
         assert libpath.is_file(), (
             f"The file doesn't exist: {libpath}"
         )
-        assert extension in openpype.hosts.blender.api.plugin.VALID_EXTENSIONS, (
+        assert extension in plugin.VALID_EXTENSIONS, (
             f"Unsupported file: {libpath}"
         )
 
diff --git a/openpype/hosts/blender/plugins/load/load_audio.py b/openpype/hosts/blender/plugins/load/load_audio.py
index ac8f3633166..1e5bd39a320 100644
--- a/openpype/hosts/blender/plugins/load/load_audio.py
+++ b/openpype/hosts/blender/plugins/load/load_audio.py
@@ -42,9 +42,9 @@ def process_asset(
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_blend.py b/openpype/hosts/blender/plugins/load/load_blend.py
index f7bbc630de5..f437e667958 100644
--- a/openpype/hosts/blender/plugins/load/load_blend.py
+++ b/openpype/hosts/blender/plugins/load/load_blend.py
@@ -4,11 +4,11 @@
 import bpy
 
 from openpype.pipeline import (
-    legacy_create,
     get_representation_path,
     AVALON_CONTAINER_ID,
+    registered_host
 )
-from openpype.pipeline.create import get_legacy_creator_by_name
+from openpype.pipeline.create import CreateContext
 from openpype.hosts.blender.api import plugin
 from openpype.hosts.blender.api.lib import imprint
 from openpype.hosts.blender.api.pipeline import (
@@ -57,19 +57,21 @@ def _post_process_layout(self, container, asset, representation):
                 obj.get(AVALON_PROPERTY).get('family') == 'rig'
             )
         ]
+        if not rigs:
+            return
+
+        # Create animation instances for each rig
+        creator_identifier = "io.openpype.creators.blender.animation"
+        host = registered_host()
+        create_context = CreateContext(host)
 
         for rig in rigs:
-            creator_plugin = get_legacy_creator_by_name("CreateAnimation")
-            legacy_create(
-                creator_plugin,
-                name=rig.name.split(':')[-1] + "_animation",
-                asset=asset,
-                options={
-                    "useSelection": False,
+            create_context.create(
+                creator_identifier=creator_identifier,
+                variant=rig.name.split(':')[-1],
+                pre_create_data={
+                    "use_selection": False,
                     "asset_group": rig
-                },
-                data={
-                    "dependencies": representation
                 }
             )
 
@@ -90,7 +92,6 @@ def _process_data(self, libpath, group_name):
                 members.append(data)
 
         container = self._get_asset_container(data_to.objects)
-        print(container)
         assert container, "No asset group found"
 
         container.name = group_name
@@ -104,8 +105,6 @@ def _process_data(self, libpath, group_name):
             print(obj)
             bpy.context.scene.collection.objects.link(obj)
 
-        print("")
-
         # Remove the library from the blend file
         library = bpy.data.libraries.get(bpy.path.basename(libpath))
         bpy.data.libraries.remove(library)
@@ -134,9 +133,9 @@ def process_asset(
 
         representation = str(context["representation"]["_id"])
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_blendscene.py b/openpype/hosts/blender/plugins/load/load_blendscene.py
index 2c955af9e82..6cc7f39d030 100644
--- a/openpype/hosts/blender/plugins/load/load_blendscene.py
+++ b/openpype/hosts/blender/plugins/load/load_blendscene.py
@@ -85,9 +85,9 @@ def process_asset(
         except ValueError:
             family = "model"
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_camera_abc.py b/openpype/hosts/blender/plugins/load/load_camera_abc.py
index 05d3fb764dd..ecd6bb98f19 100644
--- a/openpype/hosts/blender/plugins/load/load_camera_abc.py
+++ b/openpype/hosts/blender/plugins/load/load_camera_abc.py
@@ -87,9 +87,9 @@ def process_asset(
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_camera_fbx.py b/openpype/hosts/blender/plugins/load/load_camera_fbx.py
index 3cca6e7fd31..2d53d3e573f 100644
--- a/openpype/hosts/blender/plugins/load/load_camera_fbx.py
+++ b/openpype/hosts/blender/plugins/load/load_camera_fbx.py
@@ -90,9 +90,9 @@ def process_asset(
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_fbx.py b/openpype/hosts/blender/plugins/load/load_fbx.py
index e129ea6754f..8fce53a5d54 100644
--- a/openpype/hosts/blender/plugins/load/load_fbx.py
+++ b/openpype/hosts/blender/plugins/load/load_fbx.py
@@ -134,9 +134,9 @@ def process_asset(
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_layout_json.py b/openpype/hosts/blender/plugins/load/load_layout_json.py
index 81683b8de81..748ac619b64 100644
--- a/openpype/hosts/blender/plugins/load/load_layout_json.py
+++ b/openpype/hosts/blender/plugins/load/load_layout_json.py
@@ -123,6 +123,7 @@ def _process(self, libpath, asset, asset_group, actions):
         #     raise ValueError("Creator plugin \"CreateCamera\" was "
         #                      "not found.")
 
+        # TODO: Refactor legacy create usage to new style creators
         # legacy_create(
         #     creator_plugin,
         #     name="camera",
@@ -148,9 +149,9 @@ def process_asset(self,
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_look.py b/openpype/hosts/blender/plugins/load/load_look.py
index c121f556333..8d3118d83b4 100644
--- a/openpype/hosts/blender/plugins/load/load_look.py
+++ b/openpype/hosts/blender/plugins/load/load_look.py
@@ -96,14 +96,14 @@ def process_asset(
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        lib_container = plugin.asset_name(
+        lib_container = plugin.prepare_scene_name(
             asset, subset
         )
         unique_number = plugin.get_unique_number(
             asset, subset
         )
         namespace = namespace or f"{asset}_{unique_number}"
-        container_name = plugin.asset_name(
+        container_name = plugin.prepare_scene_name(
             asset, subset, unique_number
         )
 
diff --git a/openpype/hosts/blender/plugins/publish/collect_current_file.py b/openpype/hosts/blender/plugins/publish/collect_current_file.py
index c2d8a96a18a..91c88f2e282 100644
--- a/openpype/hosts/blender/plugins/publish/collect_current_file.py
+++ b/openpype/hosts/blender/plugins/publish/collect_current_file.py
@@ -1,72 +1,15 @@
-import os
-import bpy
-
 import pyblish.api
-from openpype.pipeline import get_current_task_name, get_current_asset_name
 from openpype.hosts.blender.api import workio
 
 
-class SaveWorkfiledAction(pyblish.api.Action):
-    """Save Workfile."""
-    label = "Save Workfile"
-    on = "failed"
-    icon = "save"
-
-    def process(self, context, plugin):
-        bpy.ops.wm.avalon_workfiles()
-
-
 class CollectBlenderCurrentFile(pyblish.api.ContextPlugin):
     """Inject the current working file into context"""
 
     order = pyblish.api.CollectorOrder - 0.5
     label = "Blender Current File"
     hosts = ["blender"]
-    actions = [SaveWorkfiledAction]
 
     def process(self, context):
         """Inject the current working file"""
         current_file = workio.current_file()
-
         context.data["currentFile"] = current_file
-
-        assert current_file, (
-            "Current file is empty. Save the file before continuing."
-        )
-
-        folder, file = os.path.split(current_file)
-        filename, ext = os.path.splitext(file)
-
-        task = get_current_task_name()
-
-        data = {}
-
-        # create instance
-        instance = context.create_instance(name=filename)
-        subset = "workfile" + task.capitalize()
-
-        data.update({
-            "subset": subset,
-            "asset": get_current_asset_name(),
-            "label": subset,
-            "publish": True,
-            "family": "workfile",
-            "families": ["workfile"],
-            "setMembers": [current_file],
-            "frameStart": bpy.context.scene.frame_start,
-            "frameEnd": bpy.context.scene.frame_end,
-        })
-
-        data["representations"] = [{
-            "name": ext.lstrip("."),
-            "ext": ext.lstrip("."),
-            "files": file,
-            "stagingDir": folder,
-        }]
-
-        instance.data.update(data)
-
-        self.log.info("Collected instance: {}".format(file))
-        self.log.info("Scene path: {}".format(current_file))
-        self.log.info("staging Dir: {}".format(folder))
-        self.log.info("subset: {}".format(subset))
diff --git a/openpype/hosts/blender/plugins/publish/collect_instance.py b/openpype/hosts/blender/plugins/publish/collect_instance.py
new file mode 100644
index 00000000000..4685472213e
--- /dev/null
+++ b/openpype/hosts/blender/plugins/publish/collect_instance.py
@@ -0,0 +1,43 @@
+import bpy
+
+import pyblish.api
+
+from openpype.pipeline.publish import KnownPublishError
+from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
+
+
+class CollectBlenderInstanceData(pyblish.api.InstancePlugin):
+    """Validator to verify that the instance is not empty"""
+
+    order = pyblish.api.CollectorOrder
+    hosts = ["blender"]
+    families = ["model", "pointcache", "animation", "rig", "camera", "layout",
+                "blendScene"]
+    label = "Collect Instance"
+
+    def process(self, instance):
+        instance_node = instance.data["transientData"]["instance_node"]
+
+        # Collect members of the instance
+        members = [instance_node]
+        if isinstance(instance_node, bpy.types.Collection):
+            members.extend(instance_node.objects)
+            members.extend(instance_node.children)
+
+            # Special case for animation instances, include armatures
+            if instance.data["family"] == "animation":
+                for obj in instance_node.objects:
+                    if obj.type == 'EMPTY' and obj.get(AVALON_PROPERTY):
+                        members.extend(
+                            child for child in obj.children
+                            if child.type == 'ARMATURE'
+                        )
+        elif isinstance(instance_node, bpy.types.Object):
+            members.extend(instance_node.children_recursive)
+        else:
+            raise KnownPublishError(
+                f"Unsupported instance node type '{type(instance_node)}' "
+                f"for instance '{instance}'"
+            )
+
+        instance[:] = members
diff --git a/openpype/hosts/blender/plugins/publish/collect_instances.py b/openpype/hosts/blender/plugins/publish/collect_instances.py
deleted file mode 100644
index 2d56e5fd7be..00000000000
--- a/openpype/hosts/blender/plugins/publish/collect_instances.py
+++ /dev/null
@@ -1,70 +0,0 @@
-from typing import Generator
-
-import bpy
-
-import pyblish.api
-from openpype.hosts.blender.api.pipeline import (
-    AVALON_INSTANCES,
-    AVALON_PROPERTY,
-)
-
-
-class CollectInstances(pyblish.api.ContextPlugin):
-    """Collect the data of a model."""
-
-    hosts = ["blender"]
-    label = "Collect Instances"
-    order = pyblish.api.CollectorOrder
-
-    @staticmethod
-    def get_asset_groups() -> Generator:
-        """Return all instances that are empty objects asset groups.
-        """
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        for obj in list(instances.objects) + list(instances.children):
-            avalon_prop = obj.get(AVALON_PROPERTY) or {}
-            if avalon_prop.get('id') == 'pyblish.avalon.instance':
-                yield obj
-
-    @staticmethod
-    def create_instance(context, group):
-        avalon_prop = group[AVALON_PROPERTY]
-        asset = avalon_prop['asset']
-        family = avalon_prop['family']
-        subset = avalon_prop['subset']
-        task = avalon_prop['task']
-        name = f"{asset}_{subset}"
-        return context.create_instance(
-            name=name,
-            family=family,
-            families=[family],
-            subset=subset,
-            asset=asset,
-            task=task,
-        )
-
-    def process(self, context):
-        """Collect the models from the current Blender scene."""
-        asset_groups = self.get_asset_groups()
-
-        for group in asset_groups:
-            instance = self.create_instance(context, group)
-            instance.data["instance_group"] = group
-            members = []
-            if isinstance(group, bpy.types.Collection):
-                members = list(group.objects)
-                family = instance.data["family"]
-                if family == "animation":
-                    for obj in group.objects:
-                        if obj.type == 'EMPTY' and obj.get(AVALON_PROPERTY):
-                            members.extend(
-                                child for child in obj.children
-                                if child.type == 'ARMATURE')
-            else:
-                members = group.children_recursive
-
-            members.append(group)
-            instance[:] = members
-            self.log.debug(instance.data)
-            for obj in instance:
-                self.log.debug(obj)
diff --git a/openpype/hosts/blender/plugins/publish/collect_render.py b/openpype/hosts/blender/plugins/publish/collect_render.py
index 92e2473a95e..00faf85aed1 100644
--- a/openpype/hosts/blender/plugins/publish/collect_render.py
+++ b/openpype/hosts/blender/plugins/publish/collect_render.py
@@ -73,11 +73,12 @@ def generate_expected_aovs(
     def process(self, instance):
         context = instance.context
 
-        render_data = bpy.data.collections[str(instance)].get("render_data")
+        instance_node = instance.data["transientData"]["instance_node"]
+        render_data = instance_node.get("render_data")
 
         assert render_data, "No render data found."
 
-        self.log.info(f"render_data: {dict(render_data)}")
+        self.log.debug(f"render_data: {dict(render_data)}")
 
         render_product = render_data.get("render_product")
         aov_file_product = render_data.get("aov_file_product")
@@ -120,4 +121,4 @@ def process(self, instance):
             "renderProducts": colorspace.ARenderProduct(),
         })
 
-        self.log.info(f"data: {instance.data}")
+        self.log.debug(f"data: {instance.data}")
diff --git a/openpype/hosts/blender/plugins/publish/collect_review.py b/openpype/hosts/blender/plugins/publish/collect_review.py
index 2760ab98115..2c077398dad 100644
--- a/openpype/hosts/blender/plugins/publish/collect_review.py
+++ b/openpype/hosts/blender/plugins/publish/collect_review.py
@@ -16,10 +16,12 @@ def process(self, instance):
 
         self.log.debug(f"instance: {instance}")
 
+        datablock = instance.data["transientData"]["instance_node"]
+
         # get cameras
         cameras = [
             obj
-            for obj in instance
+            for obj in datablock.all_objects
             if isinstance(obj, bpy.types.Object) and obj.type == "CAMERA"
         ]
 
diff --git a/openpype/hosts/blender/plugins/publish/collect_workfile.py b/openpype/hosts/blender/plugins/publish/collect_workfile.py
new file mode 100644
index 00000000000..6561c896052
--- /dev/null
+++ b/openpype/hosts/blender/plugins/publish/collect_workfile.py
@@ -0,0 +1,37 @@
+from pathlib import Path
+
+from pyblish.api import InstancePlugin, CollectorOrder
+
+
+class CollectWorkfile(InstancePlugin):
+    """Inject workfile data into its instance."""
+
+    order = CollectorOrder
+    label = "Collect Workfile"
+    hosts = ["blender"]
+    families = ["workfile"]
+
+    def process(self, instance):
+        """Process collector."""
+
+        context = instance.context
+        filepath = Path(context.data["currentFile"])
+        ext = filepath.suffix
+
+        instance.data.update(
+            {
+                "setMembers": [filepath.as_posix()],
+                "frameStart": context.data.get("frameStart", 1),
+                "frameEnd": context.data.get("frameEnd", 1),
+                "handleStart": context.data.get("handleStart", 1),
+                "handledEnd": context.data.get("handleEnd", 1),
+                "representations": [
+                    {
+                        "name": ext.lstrip("."),
+                        "ext": ext.lstrip("."),
+                        "files": filepath.name,
+                        "stagingDir": filepath.parent,
+                    }
+                ],
+            }
+        )
diff --git a/openpype/hosts/blender/plugins/publish/extract_abc.py b/openpype/hosts/blender/plugins/publish/extract_abc.py
index b17d7cc6e40..12d062d925e 100644
--- a/openpype/hosts/blender/plugins/publish/extract_abc.py
+++ b/openpype/hosts/blender/plugins/publish/extract_abc.py
@@ -4,10 +4,9 @@
 
 from openpype.pipeline import publish
 from openpype.hosts.blender.api import plugin
-from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
-class ExtractABC(publish.Extractor):
+class ExtractABC(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """Extract as ABC."""
 
     label = "Extract ABC"
@@ -15,6 +14,9 @@ class ExtractABC(publish.Extractor):
     families = ["pointcache"]
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
         filename = f"{instance.name}.abc"
@@ -25,18 +27,16 @@ def process(self, instance):
 
         plugin.deselect_all()
 
-        selected = []
-        active = None
+        asset_group = instance.data["transientData"]["instance_node"]
 
+        selected = []
         for obj in instance:
-            obj.select_set(True)
-            selected.append(obj)
-            # Set as active the asset group
-            if obj.get(AVALON_PROPERTY):
-                active = obj
+            if isinstance(obj, bpy.types.Object):
+                obj.select_set(True)
+                selected.append(obj)
 
         context = plugin.create_blender_context(
-            active=active, selected=selected)
+            active=asset_group, selected=selected)
 
         with bpy.context.temp_override(**context):
             # We export the abc
@@ -59,8 +59,8 @@ def process(self, instance):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)
 
 
 class ExtractModelABC(ExtractABC):
diff --git a/openpype/hosts/blender/plugins/publish/extract_abc_animation.py b/openpype/hosts/blender/plugins/publish/extract_abc_animation.py
index 6866b05feae..1c23fc8acb6 100644
--- a/openpype/hosts/blender/plugins/publish/extract_abc_animation.py
+++ b/openpype/hosts/blender/plugins/publish/extract_abc_animation.py
@@ -6,7 +6,10 @@
 from openpype.hosts.blender.api import plugin
 
 
-class ExtractAnimationABC(publish.Extractor):
+class ExtractAnimationABC(
+        publish.Extractor,
+        publish.OptionalPyblishPluginMixin,
+):
     """Extract as ABC."""
 
     label = "Extract Animation ABC"
@@ -15,6 +18,9 @@ class ExtractAnimationABC(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
         filename = f"{instance.name}.abc"
@@ -26,7 +32,7 @@ def process(self, instance):
         plugin.deselect_all()
 
         selected = []
-        asset_group = None
+        asset_group = instance.data["transientData"]["instance_node"]
 
         objects = []
         for obj in instance:
@@ -66,5 +72,5 @@ def process(self, instance):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_blend.py b/openpype/hosts/blender/plugins/publish/extract_blend.py
index 17e574c1bef..a1b49dcd8f9 100644
--- a/openpype/hosts/blender/plugins/publish/extract_blend.py
+++ b/openpype/hosts/blender/plugins/publish/extract_blend.py
@@ -5,7 +5,7 @@
 from openpype.pipeline import publish
 
 
-class ExtractBlend(publish.Extractor):
+class ExtractBlend(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """Extract a blend file."""
 
     label = "Extract Blend"
@@ -14,6 +14,9 @@ class ExtractBlend(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
 
         stagingdir = self.staging_dir(instance)
@@ -60,5 +63,5 @@ def process(self, instance):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_blend_animation.py b/openpype/hosts/blender/plugins/publish/extract_blend_animation.py
index 661cecce811..2e0de9317e9 100644
--- a/openpype/hosts/blender/plugins/publish/extract_blend_animation.py
+++ b/openpype/hosts/blender/plugins/publish/extract_blend_animation.py
@@ -5,7 +5,10 @@
 from openpype.pipeline import publish
 
 
-class ExtractBlendAnimation(publish.Extractor):
+class ExtractBlendAnimation(
+        publish.Extractor,
+        publish.OptionalPyblishPluginMixin,
+):
     """Extract a blend file."""
 
     label = "Extract Blend"
@@ -14,6 +17,9 @@ class ExtractBlendAnimation(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
 
         stagingdir = self.staging_dir(instance)
@@ -50,5 +56,5 @@ def process(self, instance):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_camera_abc.py b/openpype/hosts/blender/plugins/publish/extract_camera_abc.py
index 5916564ac0f..9d0b7f132b1 100644
--- a/openpype/hosts/blender/plugins/publish/extract_camera_abc.py
+++ b/openpype/hosts/blender/plugins/publish/extract_camera_abc.py
@@ -7,7 +7,7 @@
 from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
-class ExtractCameraABC(publish.Extractor):
+class ExtractCameraABC(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """Extract camera as ABC."""
 
     label = "Extract Camera (ABC)"
@@ -16,6 +16,9 @@ class ExtractCameraABC(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
         filename = f"{instance.name}.abc"
@@ -26,12 +29,7 @@ def process(self, instance):
 
         plugin.deselect_all()
 
-        asset_group = None
-        for obj in instance:
-            if obj.get(AVALON_PROPERTY):
-                asset_group = obj
-                break
-        assert asset_group, "No asset group found"
+        asset_group = instance.data["transientData"]["instance_node"]
 
         # Need to cast to list because children is a tuple
         selected = list(asset_group.children)
@@ -64,5 +62,5 @@ def process(self, instance):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_camera_fbx.py b/openpype/hosts/blender/plugins/publish/extract_camera_fbx.py
index a541f5b3755..9bbcf047cc3 100644
--- a/openpype/hosts/blender/plugins/publish/extract_camera_fbx.py
+++ b/openpype/hosts/blender/plugins/publish/extract_camera_fbx.py
@@ -6,7 +6,7 @@
 from openpype.hosts.blender.api import plugin
 
 
-class ExtractCamera(publish.Extractor):
+class ExtractCamera(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """Extract as the camera as FBX."""
 
     label = "Extract Camera (FBX)"
@@ -15,6 +15,9 @@ class ExtractCamera(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
         filename = f"{instance.name}.fbx"
@@ -73,5 +76,5 @@ def process(self, instance):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_fbx.py b/openpype/hosts/blender/plugins/publish/extract_fbx.py
index f2ce117dcdd..0ba82eca4e5 100644
--- a/openpype/hosts/blender/plugins/publish/extract_fbx.py
+++ b/openpype/hosts/blender/plugins/publish/extract_fbx.py
@@ -7,7 +7,7 @@
 from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
-class ExtractFBX(publish.Extractor):
+class ExtractFBX(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """Extract as FBX."""
 
     label = "Extract FBX"
@@ -16,6 +16,9 @@ class ExtractFBX(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
         filename = f"{instance.name}.fbx"
@@ -26,14 +29,12 @@ def process(self, instance):
 
         plugin.deselect_all()
 
-        selected = []
-        asset_group = None
+        asset_group = instance.data["transientData"]["instance_node"]
 
+        selected = []
         for obj in instance:
             obj.select_set(True)
             selected.append(obj)
-            if obj.get(AVALON_PROPERTY):
-                asset_group = obj
 
         context = plugin.create_blender_context(
             active=asset_group, selected=selected)
@@ -84,5 +85,5 @@ def process(self, instance):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_fbx_animation.py b/openpype/hosts/blender/plugins/publish/extract_fbx_animation.py
index 5fe5931e65d..a705345edbd 100644
--- a/openpype/hosts/blender/plugins/publish/extract_fbx_animation.py
+++ b/openpype/hosts/blender/plugins/publish/extract_fbx_animation.py
@@ -10,7 +10,41 @@
 from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
-class ExtractAnimationFBX(publish.Extractor):
+def get_all_parents(obj):
+    """Get all recursive parents of object"""
+    result = []
+    while True:
+        obj = obj.parent
+        if not obj:
+            break
+        result.append(obj)
+    return result
+
+
+def get_highest_root(objects):
+    # Get the highest object that is also in the collection
+    included_objects = {obj.name_full for obj in objects}
+    num_parents_to_obj = {}
+    for obj in objects:
+        if isinstance(obj, bpy.types.Object):
+            parents = get_all_parents(obj)
+            # included parents
+            parents = [parent for parent in parents if
+                       parent.name_full in included_objects]
+            if not parents:
+                # A node without parents must be a highest root
+                return obj
+
+            num_parents_to_obj.setdefault(len(parents), obj)
+
+    minimum_parent = min(num_parents_to_obj)
+    return num_parents_to_obj[minimum_parent]
+
+
+class ExtractAnimationFBX(
+        publish.Extractor,
+        publish.OptionalPyblishPluginMixin,
+):
     """Extract as animation."""
 
     label = "Extract FBX"
@@ -19,23 +53,43 @@ class ExtractAnimationFBX(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
 
         # Perform extraction
         self.log.debug("Performing extraction..")
 
-        # The first collection object in the instance is taken, as there
-        # should be only one that contains the asset group.
-        collection = [
-            obj for obj in instance if type(obj) is bpy.types.Collection][0]
-
-        # Again, the first object in the collection is taken , as there
-        # should be only the asset group in the collection.
-        asset_group = collection.objects[0]
-
-        armature = [
-            obj for obj in asset_group.children if obj.type == 'ARMATURE'][0]
+        asset_group = instance.data["transientData"]["instance_node"]
+
+        # Get objects in this collection (but not in children collections)
+        # and for those objects include the children hierarchy
+        # TODO: Would it make more sense for the Collect Instance collector
+        #   to also always retrieve all the children?
+        objects = set(asset_group.objects)
+
+        # From the direct children of the collection find the 'root' node
+        # that we want to export - it is the 'highest' node in a hierarchy
+        root = get_highest_root(objects)
+
+        for obj in list(objects):
+            objects.update(obj.children_recursive)
+
+        # Find all armatures among the objects, assume to find only one
+        armatures = [obj for obj in objects if obj.type == "ARMATURE"]
+        if not armatures:
+            raise RuntimeError(
+                f"Unable to find ARMATURE in collection: "
+                f"{asset_group.name}"
+            )
+        elif len(armatures) > 1:
+            self.log.warning(
+                "Found more than one ARMATURE, using "
+                f"only first of: {armatures}"
+            )
+        armature = armatures[0]
 
         object_action_pairs = []
         original_actions = []
@@ -44,9 +98,6 @@ def process(self, instance):
         ending_frames = []
 
         # For each armature, we make a copy of the current action
-        curr_action = None
-        copy_action = None
-
         if armature.animation_data and armature.animation_data.action:
             curr_action = armature.animation_data.action
             copy_action = curr_action.copy()
@@ -56,12 +107,20 @@ def process(self, instance):
             starting_frames.append(curr_frame_range[0])
             ending_frames.append(curr_frame_range[1])
         else:
-            self.log.info("Object have no animation.")
+            self.log.info(
+                f"Armature '{armature.name}' has no animation, "
+                f"skipping FBX animation extraction for {instance}."
+            )
             return
 
         asset_group_name = asset_group.name
-        asset_group.name = asset_group.get(AVALON_PROPERTY).get("asset_name")
+        asset_name = asset_group.get(AVALON_PROPERTY).get("asset_name")
+        if asset_name:
+            # Rename for the export; this data is only present when loaded
+            # from a JSON Layout (layout family)
+            asset_group.name = asset_name
 
+        # Remove : from the armature name for the export
         armature_name = armature.name
         original_name = armature_name.split(':')[1]
         armature.name = original_name
@@ -84,13 +143,13 @@ def process(self, instance):
         for obj in bpy.data.objects:
             obj.select_set(False)
 
-        asset_group.select_set(True)
+        root.select_set(True)
         armature.select_set(True)
         fbx_filename = f"{instance.name}_{armature.name}.fbx"
         filepath = os.path.join(stagingdir, fbx_filename)
 
         override = plugin.create_blender_context(
-            active=asset_group, selected=[asset_group, armature])
+            active=root, selected=[root, armature])
         bpy.ops.export_scene.fbx(
             override,
             filepath=filepath,
@@ -104,7 +163,7 @@ def process(self, instance):
         )
         armature.name = armature_name
         asset_group.name = asset_group_name
-        asset_group.select_set(False)
+        root.select_set(True)
         armature.select_set(False)
 
         # We delete the baked action and set the original one back
@@ -158,5 +217,5 @@ def process(self, instance):
         instance.data["representations"].append(fbx_representation)
         instance.data["representations"].append(json_representation)
 
-        self.log.info("Extracted instance '{}' to: {}".format(
-                      instance.name, fbx_representation))
+        self.log.debug("Extracted instance '{}' to: {}".format(
+                       instance.name, fbx_representation))
diff --git a/openpype/hosts/blender/plugins/publish/extract_layout.py b/openpype/hosts/blender/plugins/publish/extract_layout.py
index 05f86b8370e..73d92961bc3 100644
--- a/openpype/hosts/blender/plugins/publish/extract_layout.py
+++ b/openpype/hosts/blender/plugins/publish/extract_layout.py
@@ -11,7 +11,7 @@
 from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
-class ExtractLayout(publish.Extractor):
+class ExtractLayout(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """Extract a layout."""
 
     label = "Extract Layout"
@@ -45,7 +45,7 @@ def _export_animation(self, asset, instance, stagingdir, fbx_count):
                 starting_frames.append(curr_frame_range[0])
                 ending_frames.append(curr_frame_range[1])
             else:
-                self.log.info("Object have no animation.")
+                self.log.info("Object has no animation.")
                 continue
 
             asset_group_name = asset.name
@@ -113,6 +113,9 @@ def _export_animation(self, asset, instance, stagingdir, fbx_count):
         return None, n
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
 
@@ -125,13 +128,22 @@ def process(self, instance):
         json_data = []
         fbx_files = []
 
-        asset_group = bpy.data.objects[str(instance)]
+        asset_group = instance.data["transientData"]["instance_node"]
 
         fbx_count = 0
 
         project_name = instance.context.data["projectEntity"]["name"]
         for asset in asset_group.children:
             metadata = asset.get(AVALON_PROPERTY)
+            if not metadata:
+                # Avoid raising error directly if there's just invalid data
+                # inside the instance; better to log it to the artist
+                # TODO: This should actually be validated in a validator
+                self.log.warning(
+                    f"Found content in layout that is not a loaded "
+                    f"asset, skipping: {asset.name_full}"
+                )
+                continue
 
             version_id = metadata["parent"]
             family = metadata["family"]
@@ -245,5 +257,5 @@ def process(self, instance):
             }
             instance.data["representations"].append(fbx_representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, json_representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, json_representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_playblast.py b/openpype/hosts/blender/plugins/publish/extract_playblast.py
index b0099cce850..fe005c6593d 100644
--- a/openpype/hosts/blender/plugins/publish/extract_playblast.py
+++ b/openpype/hosts/blender/plugins/publish/extract_playblast.py
@@ -9,7 +9,7 @@
 from openpype.hosts.blender.api.lib import maintained_time
 
 
-class ExtractPlayblast(publish.Extractor):
+class ExtractPlayblast(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """
     Extract viewport playblast.
 
@@ -24,7 +24,8 @@ class ExtractPlayblast(publish.Extractor):
     order = pyblish.api.ExtractorOrder + 0.01
 
     def process(self, instance):
-        self.log.debug("Extracting capture..")
+        if not self.is_active(instance.data):
+            return
 
         # get scene fps
         fps = instance.data.get("fps")
diff --git a/openpype/hosts/blender/plugins/publish/increment_workfile_version.py b/openpype/hosts/blender/plugins/publish/increment_workfile_version.py
index 6ace14d77cf..7e33fd53fa3 100644
--- a/openpype/hosts/blender/plugins/publish/increment_workfile_version.py
+++ b/openpype/hosts/blender/plugins/publish/increment_workfile_version.py
@@ -1,8 +1,12 @@
 import pyblish.api
+from openpype.pipeline.publish import OptionalPyblishPluginMixin
 from openpype.hosts.blender.api.workio import save_file
 
 
-class IncrementWorkfileVersion(pyblish.api.ContextPlugin):
+class IncrementWorkfileVersion(
+        pyblish.api.ContextPlugin,
+        OptionalPyblishPluginMixin
+):
     """Increment current workfile version."""
 
     order = pyblish.api.IntegratorOrder + 0.9
@@ -13,6 +17,8 @@ class IncrementWorkfileVersion(pyblish.api.ContextPlugin):
                 "pointcache", "render"]
 
     def process(self, context):
+        if not self.is_active(context.data):
+            return
 
         assert all(result["success"] for result in context.data["results"]), (
             "Publishing not successful so version is not increased.")
@@ -23,4 +29,4 @@ def process(self, context):
 
         save_file(filepath, copy=False)
 
-        self.log.info('Incrementing script version')
+        self.log.debug('Incrementing blender workfile version')
diff --git a/openpype/hosts/blender/plugins/publish/integrate_animation.py b/openpype/hosts/blender/plugins/publish/integrate_animation.py
index d9a85bc79b8..623da9c5854 100644
--- a/openpype/hosts/blender/plugins/publish/integrate_animation.py
+++ b/openpype/hosts/blender/plugins/publish/integrate_animation.py
@@ -1,9 +1,13 @@
 import json
 
 import pyblish.api
+from openpype.pipeline.publish import OptionalPyblishPluginMixin
 
 
-class IntegrateAnimation(pyblish.api.InstancePlugin):
+class IntegrateAnimation(
+        pyblish.api.InstancePlugin,
+        OptionalPyblishPluginMixin,
+):
     """Generate a JSON file for animation."""
 
     label = "Integrate Animation"
@@ -13,7 +17,7 @@ class IntegrateAnimation(pyblish.api.InstancePlugin):
     families = ["setdress"]
 
     def process(self, instance):
-        self.log.info("Integrate Animation")
+        self.log.debug("Integrate Animation")
 
         representation = instance.data.get('representations')[0]
         json_path = representation.get('publishedFiles')[0]
diff --git a/openpype/hosts/blender/plugins/publish/validate_camera_zero_keyframe.py b/openpype/hosts/blender/plugins/publish/validate_camera_zero_keyframe.py
index 48c267fd18c..9b6e5138978 100644
--- a/openpype/hosts/blender/plugins/publish/validate_camera_zero_keyframe.py
+++ b/openpype/hosts/blender/plugins/publish/validate_camera_zero_keyframe.py
@@ -5,10 +5,15 @@
 import pyblish.api
 
 import openpype.hosts.blender.api.action
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+    ValidateContentsOrder,
+    PublishValidationError,
+    OptionalPyblishPluginMixin
+)
 
 
-class ValidateCameraZeroKeyframe(pyblish.api.InstancePlugin):
+class ValidateCameraZeroKeyframe(pyblish.api.InstancePlugin,
+                                 OptionalPyblishPluginMixin):
     """Camera must have a keyframe at frame 0.
 
     Unreal shifts the first keyframe to frame 0. Forcing the camera to have
@@ -40,8 +45,12 @@ def get_invalid(instance) -> List:
         return invalid
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         invalid = self.get_invalid(instance)
         if invalid:
-            raise RuntimeError(
-                f"Camera must have a keyframe at frame 0: {invalid}"
+            names = ", ".join(obj.name for obj in invalid)
+            raise PublishValidationError(
+                f"Camera must have a keyframe at frame 0: {names}"
             )
diff --git a/openpype/hosts/blender/plugins/publish/validate_deadline_publish.py b/openpype/hosts/blender/plugins/publish/validate_deadline_publish.py
index 14220b5c9cd..d8826adc9ca 100644
--- a/openpype/hosts/blender/plugins/publish/validate_deadline_publish.py
+++ b/openpype/hosts/blender/plugins/publish/validate_deadline_publish.py
@@ -36,12 +36,12 @@ def process(self, instance):
                 "Render output folder "
                 "doesn't match the blender scene name! "
                 "Use Repair action to "
-                "fix the folder file path.."
+                "fix the folder file path."
             )
 
     @classmethod
     def repair(cls, instance):
-        container = bpy.data.collections[str(instance)]
+        container = instance.data["transientData"]["instance_node"]
         prepare_rendering(container)
         bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
         cls.log.debug("Reset the render output folder...")
diff --git a/openpype/hosts/blender/plugins/publish/validate_file_saved.py b/openpype/hosts/blender/plugins/publish/validate_file_saved.py
index e191585c555..442f856e058 100644
--- a/openpype/hosts/blender/plugins/publish/validate_file_saved.py
+++ b/openpype/hosts/blender/plugins/publish/validate_file_saved.py
@@ -2,8 +2,24 @@
 
 import pyblish.api
 
+from openpype.pipeline.publish import (
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 
-class ValidateFileSaved(pyblish.api.InstancePlugin):
+
+class SaveWorkfileAction(pyblish.api.Action):
+    """Save Workfile."""
+    label = "Save Workfile"
+    on = "failed"
+    icon = "save"
+
+    def process(self, context, plugin):
+        bpy.ops.wm.avalon_workfiles()
+
+
+class ValidateFileSaved(pyblish.api.ContextPlugin,
+                        OptionalPyblishPluginMixin):
     """Validate that the workfile has been saved."""
 
     order = pyblish.api.ValidatorOrder - 0.01
@@ -11,10 +27,35 @@ class ValidateFileSaved(pyblish.api.InstancePlugin):
     label = "Validate File Saved"
     optional = False
     exclude_families = []
+    actions = [SaveWorkfileAction]
+
+    def process(self, context):
+        if not self.is_active(context.data):
+            return
+
+        if not context.data["currentFile"]:
+            # File has not been saved at all and has no filename
+            raise PublishValidationError(
+                "Current file is empty. Save the file before continuing."
+            )
+
+        # Do not validate workfile has unsaved changes if only instances
+        # present of families that should be excluded
+        families = {
+            instance.data["family"] for instance in context
+            # Consider only enabled instances
+            if instance.data.get("publish", True)
+            and instance.data.get("active", True)
+        }
 
-    def process(self, instance):
-        if [ef for ef in self.exclude_families
-                if instance.data["family"] in ef]:
+        def is_excluded(family):
+            return any(family in exclude_family
+                       for exclude_family in self.exclude_families)
+
+        if all(is_excluded(family) for family in families):
+            self.log.debug("Only excluded families found, skipping workfile "
+                           "unsaved changes validation..")
             return
+
         if bpy.data.is_dirty:
-            raise RuntimeError("Workfile is not saved.")
+            raise PublishValidationError("Workfile has unsaved changes.")
diff --git a/openpype/hosts/blender/plugins/publish/validate_instance_empty.py b/openpype/hosts/blender/plugins/publish/validate_instance_empty.py
index 3ebc6515d37..51a1dcf6ca6 100644
--- a/openpype/hosts/blender/plugins/publish/validate_instance_empty.py
+++ b/openpype/hosts/blender/plugins/publish/validate_instance_empty.py
@@ -1,6 +1,5 @@
-import bpy
-
 import pyblish.api
+from openpype.pipeline.publish import PublishValidationError
 
 
 class ValidateInstanceEmpty(pyblish.api.InstancePlugin):
@@ -13,11 +12,8 @@ class ValidateInstanceEmpty(pyblish.api.InstancePlugin):
     optional = False
 
     def process(self, instance):
-        asset_group = instance.data["instance_group"]
-
-        if isinstance(asset_group, bpy.types.Collection):
-            if not (asset_group.objects or asset_group.children):
-                raise RuntimeError(f"Instance {instance.name} is empty.")
-        elif isinstance(asset_group, bpy.types.Object):
-            if not asset_group.children:
-                raise RuntimeError(f"Instance {instance.name} is empty.")
+        # Members are collected by `collect_instance` so we only need to check
+        # whether any member is included. The instance node will be included
+        # as a member as well, hence we will check for at least 2 members
+        if len(instance) < 2:
+            raise PublishValidationError(f"Instance {instance.name} is empty.")
diff --git a/openpype/hosts/blender/plugins/publish/validate_mesh_has_uv.py b/openpype/hosts/blender/plugins/publish/validate_mesh_has_uv.py
index edf47193bee..060bccbd04f 100644
--- a/openpype/hosts/blender/plugins/publish/validate_mesh_has_uv.py
+++ b/openpype/hosts/blender/plugins/publish/validate_mesh_has_uv.py
@@ -4,17 +4,24 @@
 
 import pyblish.api
 
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+    ValidateContentsOrder,
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 import openpype.hosts.blender.api.action
 
 
-class ValidateMeshHasUvs(pyblish.api.InstancePlugin):
+class ValidateMeshHasUvs(
+        pyblish.api.InstancePlugin,
+        OptionalPyblishPluginMixin,
+):
     """Validate that the current mesh has UV's."""
 
     order = ValidateContentsOrder
     hosts = ["blender"]
     families = ["model"]
-    label = "Mesh Has UV's"
+    label = "Mesh Has UVs"
     actions = [openpype.hosts.blender.api.action.SelectInvalidAction]
     optional = True
 
@@ -49,8 +56,11 @@ def get_invalid(cls, instance) -> List:
         return invalid
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         invalid = self.get_invalid(instance)
         if invalid:
-            raise RuntimeError(
+            raise PublishValidationError(
                 f"Meshes found in instance without valid UV's: {invalid}"
             )
diff --git a/openpype/hosts/blender/plugins/publish/validate_mesh_no_negative_scale.py b/openpype/hosts/blender/plugins/publish/validate_mesh_no_negative_scale.py
index 618feb95c15..7f77bbe38ce 100644
--- a/openpype/hosts/blender/plugins/publish/validate_mesh_no_negative_scale.py
+++ b/openpype/hosts/blender/plugins/publish/validate_mesh_no_negative_scale.py
@@ -4,11 +4,16 @@
 
 import pyblish.api
 
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+    ValidateContentsOrder,
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 import openpype.hosts.blender.api.action
 
 
-class ValidateMeshNoNegativeScale(pyblish.api.Validator):
+class ValidateMeshNoNegativeScale(pyblish.api.Validator,
+                                  OptionalPyblishPluginMixin):
     """Ensure that meshes don't have a negative scale."""
 
     order = ValidateContentsOrder
@@ -27,8 +32,12 @@ def get_invalid(instance) -> List:
         return invalid
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         invalid = self.get_invalid(instance)
         if invalid:
-            raise RuntimeError(
-                f"Meshes found in instance with negative scale: {invalid}"
+            names = ", ".join(obj.name for obj in invalid)
+            raise PublishValidationError(
+                f"Meshes found in instance with negative scale: {names}"
             )
diff --git a/openpype/hosts/blender/plugins/publish/validate_no_colons_in_name.py b/openpype/hosts/blender/plugins/publish/validate_no_colons_in_name.py
index 1a98ec4c1db..caf555b5352 100644
--- a/openpype/hosts/blender/plugins/publish/validate_no_colons_in_name.py
+++ b/openpype/hosts/blender/plugins/publish/validate_no_colons_in_name.py
@@ -5,10 +5,15 @@
 import pyblish.api
 
 import openpype.hosts.blender.api.action
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+    ValidateContentsOrder,
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 
 
-class ValidateNoColonsInName(pyblish.api.InstancePlugin):
+class ValidateNoColonsInName(pyblish.api.InstancePlugin,
+                             OptionalPyblishPluginMixin):
     """There cannot be colons in names
 
     Object or bone names cannot include colons. Other software do not
@@ -36,8 +41,12 @@ def get_invalid(instance) -> List:
         return invalid
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         invalid = self.get_invalid(instance)
         if invalid:
-            raise RuntimeError(
-                f"Objects found with colon in name: {invalid}"
+            names = ", ".join(obj.name for obj in invalid)
+            raise PublishValidationError(
+                f"Objects found with colon in name: {names}"
             )
diff --git a/openpype/hosts/blender/plugins/publish/validate_object_mode.py b/openpype/hosts/blender/plugins/publish/validate_object_mode.py
index ac60e00f897..ab5f4bb467c 100644
--- a/openpype/hosts/blender/plugins/publish/validate_object_mode.py
+++ b/openpype/hosts/blender/plugins/publish/validate_object_mode.py
@@ -3,10 +3,17 @@
 import bpy
 
 import pyblish.api
+from openpype.pipeline.publish import (
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 import openpype.hosts.blender.api.action
 
 
-class ValidateObjectIsInObjectMode(pyblish.api.InstancePlugin):
+class ValidateObjectIsInObjectMode(
+        pyblish.api.InstancePlugin,
+        OptionalPyblishPluginMixin,
+):
     """Validate that the objects in the instance are in Object Mode."""
 
     order = pyblish.api.ValidatorOrder - 0.01
@@ -25,8 +32,12 @@ def get_invalid(instance) -> List:
         return invalid
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         invalid = self.get_invalid(instance)
         if invalid:
-            raise RuntimeError(
-                f"Object found in instance is not in Object Mode: {invalid}"
+            names = ", ".join(obj.name for obj in invalid)
+            raise PublishValidationError(
+                f"Object found in instance is not in Object Mode: {names}"
             )
diff --git a/openpype/hosts/blender/plugins/publish/validate_render_camera_is_set.py b/openpype/hosts/blender/plugins/publish/validate_render_camera_is_set.py
index ba3a796f35c..86d1fcc6815 100644
--- a/openpype/hosts/blender/plugins/publish/validate_render_camera_is_set.py
+++ b/openpype/hosts/blender/plugins/publish/validate_render_camera_is_set.py
@@ -2,8 +2,14 @@
 
 import pyblish.api
 
+from openpype.pipeline.publish import (
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 
-class ValidateRenderCameraIsSet(pyblish.api.InstancePlugin):
+
+class ValidateRenderCameraIsSet(pyblish.api.InstancePlugin,
+                                OptionalPyblishPluginMixin):
     """Validate that there is a camera set as active for rendering."""
 
     order = pyblish.api.ValidatorOrder
@@ -13,5 +19,8 @@ class ValidateRenderCameraIsSet(pyblish.api.InstancePlugin):
     optional = False
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         if not bpy.context.scene.camera:
-            raise RuntimeError("No camera is active for rendering.")
+            raise PublishValidationError("No camera is active for rendering.")
diff --git a/openpype/hosts/blender/plugins/publish/validate_transform_zero.py b/openpype/hosts/blender/plugins/publish/validate_transform_zero.py
index 66ef731e6e2..1fb9535ee41 100644
--- a/openpype/hosts/blender/plugins/publish/validate_transform_zero.py
+++ b/openpype/hosts/blender/plugins/publish/validate_transform_zero.py
@@ -6,10 +6,15 @@
 import pyblish.api
 
 import openpype.hosts.blender.api.action
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+    ValidateContentsOrder,
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 
 
-class ValidateTransformZero(pyblish.api.InstancePlugin):
+class ValidateTransformZero(pyblish.api.InstancePlugin,
+                            OptionalPyblishPluginMixin):
     """Transforms can't have any values
 
     To solve this issue, try freezing the transforms. So long
@@ -38,9 +43,13 @@ def get_invalid(cls, instance) -> List:
         return invalid
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         invalid = self.get_invalid(instance)
         if invalid:
-            raise RuntimeError(
-                "Object found in instance has not"
-                f" transform to zero: {invalid}"
+            names = ", ".join(obj.name for obj in invalid)
+            raise PublishValidationError(
+                "Objects found in instance which do not"
+                f" have transform set to zero: {names}"
             )
diff --git a/openpype/hosts/houdini/plugins/publish/validate_houdini_license_category.py b/openpype/hosts/houdini/plugins/publish/validate_houdini_license_category.py
index f1c52f22c19..5076acda601 100644
--- a/openpype/hosts/houdini/plugins/publish/validate_houdini_license_category.py
+++ b/openpype/hosts/houdini/plugins/publish/validate_houdini_license_category.py
@@ -1,32 +1,39 @@
 # -*- coding: utf-8 -*-
 import pyblish.api
 from openpype.pipeline import PublishValidationError
+import hou
 
 
-class ValidateHoudiniCommercialLicense(pyblish.api.InstancePlugin):
-    """Validate the Houdini instance runs a Commercial license.
+class ValidateHoudiniNotApprenticeLicense(pyblish.api.InstancePlugin):
+    """Validate the Houdini instance runs a non Apprentice license.
 
-    When extracting USD files from a non-commercial Houdini license, even with
-    Houdini Indie license, the resulting files will get "scrambled" with
-    a license protection and get a special .usdnc or .usdlc suffix.
+    USD ROPs:
+        When extracting USD files from an apprentice Houdini license,
+        the resulting files will get "scrambled" with a license protection
+        and get a special .usdnc suffix.
 
-    This currently breaks the Subset/representation pipeline so we disallow
-    any publish with those licenses. Only the commercial license is valid.
+        This currently breaks the Subset/representation pipeline so we disallow
+        any publish with apprentice license.
 
+    Alembic ROPs:
+        Houdini Apprentice does not export Alembic.
     """
 
     order = pyblish.api.ValidatorOrder
-    families = ["usd"]
+    families = ["usd", "abc"]
     hosts = ["houdini"]
-    label = "Houdini Commercial License"
+    label = "Houdini Apprentice License"
 
     def process(self, instance):
 
-        import hou
+        if hou.isApprentice():
+            # Find which family was matched with the plug-in
+            families = {instance.data["family"]}
+            families.update(instance.data.get("families", []))
+            disallowed_families = families.intersection(self.families)
+            families = " ".join(sorted(disallowed_families)).title()
 
-        license = hou.licenseCategory()
-        if license != hou.licenseCategoryType.Commercial:
             raise PublishValidationError(
-                ("USD Publishing requires a full Commercial "
-                 "license. You are on: {}").format(license),
+                "{} publishing requires a non apprentice license."
+                .format(families),
                 title=self.label)
diff --git a/openpype/hosts/max/plugins/create/create_review.py b/openpype/hosts/max/plugins/create/create_review.py
index 331d2f30ead..78d27a722b0 100644
--- a/openpype/hosts/max/plugins/create/create_review.py
+++ b/openpype/hosts/max/plugins/create/create_review.py
@@ -12,6 +12,32 @@ class CreateReview(plugin.MaxCreator):
     family = "review"
     icon = "video-camera"
 
+    review_width = 1920
+    review_height = 1080
+    percentSize = 100
+    keep_images = False
+    image_format = "png"
+    visual_style = "Realistic"
+    viewport_preset = "Quality"
+    vp_texture = True
+    anti_aliasing = "None"
+
+    def apply_settings(self, project_settings):
+        settings = project_settings["max"]["CreateReview"]  # noqa
+
+        # Take some defaults from settings
+        self.review_width = settings.get("review_width", self.review_width)
+        self.review_height = settings.get("review_height", self.review_height)
+        self.percentSize = settings.get("percentSize", self.percentSize)
+        self.keep_images = settings.get("keep_images", self.keep_images)
+        self.image_format = settings.get("image_format", self.image_format)
+        self.visual_style = settings.get("visual_style", self.visual_style)
+        self.viewport_preset = settings.get(
+            "viewport_preset", self.viewport_preset)
+        self.anti_aliasing = settings.get(
+            "anti_aliasing", self.anti_aliasing)
+        self.vp_texture = settings.get("vp_texture", self.vp_texture)
+
     def create(self, subset_name, instance_data, pre_create_data):
         # Transfer settings from pre create to instance
         creator_attributes = instance_data.setdefault(
@@ -53,39 +79,39 @@ def get_instance_attr_defs(self):
                       label="Review width",
                       decimals=0,
                       minimum=0,
-                      default=1920),
+                      default=self.review_width),
             NumberDef("review_height",
                       label="Review height",
                       decimals=0,
                       minimum=0,
-                      default=1080),
+                      default=self.review_height),
+            NumberDef("percentSize",
+                      label="Percent of Output",
+                      default=self.percentSize,
+                      minimum=1,
+                      decimals=0),
             BoolDef("keepImages",
                     label="Keep Image Sequences",
-                    default=False),
+                    default=self.keep_images),
             EnumDef("imageFormat",
                     image_format_enum,
-                    default="png",
+                    default=self.image_format,
                     label="Image Format Options"),
-            NumberDef("percentSize",
-                      label="Percent of Output",
-                      default=100,
-                      minimum=1,
-                      decimals=0),
             EnumDef("visualStyleMode",
                     visual_style_preset_enum,
-                    default="Realistic",
+                    default=self.visual_style,
                     label="Preference"),
             EnumDef("viewportPreset",
                     preview_preset_enum,
-                    default="Quality",
-                    label="Pre-View Preset"),
+                    default=self.viewport_preset,
+                    label="Preview Preset"),
             EnumDef("antialiasingQuality",
                     anti_aliasing_enum,
-                    default="None",
+                    default=self.anti_aliasing,
                     label="Anti-aliasing Quality"),
             BoolDef("vpTexture",
                     label="Viewport Texture",
-                    default=False)
+                    default=self.vp_texture)
         ]
 
     def get_pre_create_attr_defs(self):
diff --git a/openpype/hosts/maya/api/lib.py b/openpype/hosts/maya/api/lib.py
index 7c49c837e9b..2ecaf87fce9 100644
--- a/openpype/hosts/maya/api/lib.py
+++ b/openpype/hosts/maya/api/lib.py
@@ -62,19 +62,6 @@
                "doubleSided",
                "opposite"}
 
-RENDER_ATTRS = {"vray": {
-    "node": "vraySettings",
-    "prefix": "fileNamePrefix",
-    "padding": "fileNamePadding",
-    "ext": "imageFormatStr"
-},
-    "default": {
-    "node": "defaultRenderGlobals",
-    "prefix": "imageFilePrefix",
-    "padding": "extensionPadding"
-}
-}
-
 
 DEFAULT_MATRIX = [1.0, 0.0, 0.0, 0.0,
                   0.0, 1.0, 0.0, 0.0,
diff --git a/openpype/hosts/maya/api/lib_rendersettings.py b/openpype/hosts/maya/api/lib_rendersettings.py
index 20264c2cdfc..8b57c2e481f 100644
--- a/openpype/hosts/maya/api/lib_rendersettings.py
+++ b/openpype/hosts/maya/api/lib_rendersettings.py
@@ -33,6 +33,14 @@ class RenderSettings(object):
     def get_image_prefix_attr(cls, renderer):
         return cls._image_prefix_nodes[renderer]
 
+    @staticmethod
+    def get_padding_attr(renderer):
+        """Return attribute for renderer that defines frame padding amount"""
+        if renderer == "vray":
+            return "vraySettings.fileNamePadding"
+        else:
+            return "defaultRenderGlobals.extensionPadding"
+
     def __init__(self, project_settings=None):
         if not project_settings:
             project_settings = get_project_settings(
diff --git a/openpype/hosts/maya/api/plugin.py b/openpype/hosts/maya/api/plugin.py
index 07167a9a32a..212c4df4927 100644
--- a/openpype/hosts/maya/api/plugin.py
+++ b/openpype/hosts/maya/api/plugin.py
@@ -271,7 +271,7 @@ def _default_remove_instances(self, instances):
 @six.add_metaclass(ABCMeta)
 class MayaCreator(NewCreator, MayaCreatorBase):
 
-    settings_name = None
+    settings_category = "maya"
 
     def create(self, subset_name, instance_data, pre_create_data):
 
@@ -317,24 +317,6 @@ def get_pre_create_attr_defs(self):
                     default=True)
         ]
 
-    def apply_settings(self, project_settings):
-        """Method called on initialization of plugin to apply settings."""
-
-        settings_name = self.settings_name
-        if settings_name is None:
-            settings_name = self.__class__.__name__
-
-        settings = project_settings["maya"]["create"]
-        settings = settings.get(settings_name)
-        if settings is None:
-            self.log.debug(
-                "No settings found for {}".format(self.__class__.__name__)
-            )
-            return
-
-        for key, value in settings.items():
-            setattr(self, key, value)
-
 
 class MayaAutoCreator(AutoCreator, MayaCreatorBase):
     """Automatically triggered creator for Maya.
@@ -343,6 +325,8 @@ class MayaAutoCreator(AutoCreator, MayaCreatorBase):
         any arguments.
     """
 
+    settings_category = "maya"
+
     def collect_instances(self):
         return self._default_collect_instances()
 
@@ -360,6 +344,8 @@ class MayaHiddenCreator(HiddenCreator, MayaCreatorBase):
         arguments for 'create' method.
     """
 
+    settings_category = "maya"
+
     def create(self, *args, **kwargs):
         return MayaCreator.create(self, *args, **kwargs)
 
diff --git a/openpype/hosts/maya/plugins/publish/validate_rendersettings.py b/openpype/hosts/maya/plugins/publish/validate_rendersettings.py
index dccb4ade78f..3409b4ec91d 100644
--- a/openpype/hosts/maya/plugins/publish/validate_rendersettings.py
+++ b/openpype/hosts/maya/plugins/publish/validate_rendersettings.py
@@ -12,6 +12,7 @@
     PublishValidationError,
 )
 from openpype.hosts.maya.api import lib
+from openpype.hosts.maya.api.lib_rendersettings import RenderSettings
 
 
 def convert_to_int_or_float(string_value):
@@ -129,13 +130,13 @@ def get_invalid(cls, instance):
         layer = instance.data['renderlayer']
         cameras = instance.data.get("cameras", [])
 
-        # Get the node attributes for current renderer
-        attrs = lib.RENDER_ATTRS.get(renderer, lib.RENDER_ATTRS['default'])
         # Prefix attribute can return None when a value was never set
         prefix = lib.get_attr_in_layer(cls.ImagePrefixes[renderer],
                                        layer=layer) or ""
-        padding = lib.get_attr_in_layer("{node}.{padding}".format(**attrs),
-                                        layer=layer)
+        padding = lib.get_attr_in_layer(
+            attr=RenderSettings.get_padding_attr(renderer),
+            layer=layer
+        )
 
         anim_override = lib.get_attr_in_layer("defaultRenderGlobals.animation",
                                               layer=layer)
@@ -372,8 +373,6 @@ def repair(cls, instance):
                 lib.set_attribute(data["attribute"], data["values"][0], node)
 
         with lib.renderlayer(layer_node):
-            default = lib.RENDER_ATTRS['default']
-            render_attrs = lib.RENDER_ATTRS.get(renderer, default)
 
             # Repair animation must be enabled
             cmds.setAttr("defaultRenderGlobals.animation", True)
@@ -391,15 +390,13 @@ def repair(cls, instance):
                         default_prefix = default_prefix.replace(variant, "")
 
             if renderer != "renderman":
-                node = render_attrs["node"]
-                prefix_attr = render_attrs["prefix"]
-
+                prefix_attr = RenderSettings.get_image_prefix_attr(renderer)
                 fname_prefix = default_prefix
                 cmds.setAttr("{}.{}".format(node, prefix_attr),
                              fname_prefix, type="string")
 
                 # Repair padding
-                padding_attr = render_attrs["padding"]
+                padding_attr = RenderSettings.get_padding_attr(renderer)
                 cmds.setAttr("{}.{}".format(node, padding_attr),
                              cls.DEFAULT_PADDING)
             else:
diff --git a/openpype/hosts/traypublisher/plugins/create/create_editorial.py b/openpype/hosts/traypublisher/plugins/create/create_editorial.py
index 8640500b189..a2746f115fe 100644
--- a/openpype/hosts/traypublisher/plugins/create/create_editorial.py
+++ b/openpype/hosts/traypublisher/plugins/create/create_editorial.py
@@ -701,6 +701,8 @@ def _get_base_instance_data(
             # parent time properties
             "trackStartFrame": track_start_frame,
             "timelineOffset": timeline_offset,
+            "isEditorial": True,
+
             # creator_attributes
             "creator_attributes": creator_attributes
         }
diff --git a/openpype/hosts/traypublisher/plugins/publish/collect_sequence_frame_data.py b/openpype/hosts/traypublisher/plugins/publish/collect_sequence_frame_data.py
index db70d4fe0a9..92cedf6b5b3 100644
--- a/openpype/hosts/traypublisher/plugins/publish/collect_sequence_frame_data.py
+++ b/openpype/hosts/traypublisher/plugins/publish/collect_sequence_frame_data.py
@@ -27,6 +27,12 @@ def process(self, instance):
         if not self.is_active(instance.data):
             return
 
+        # editorial would fail since they might not be in database yet
+        is_editorial = instance.data.get("isEditorial")
+        if is_editorial:
+            self.log.debug("Instance is Editorial. Skipping.")
+            return
+
         frame_data = self.get_frame_data_from_repre_sequence(instance)
 
         if not frame_data:
diff --git a/openpype/hosts/traypublisher/plugins/publish/validate_frame_ranges.py b/openpype/hosts/traypublisher/plugins/publish/validate_frame_ranges.py
index 09de2d8db25..4977a133748 100644
--- a/openpype/hosts/traypublisher/plugins/publish/validate_frame_ranges.py
+++ b/openpype/hosts/traypublisher/plugins/publish/validate_frame_ranges.py
@@ -30,12 +30,17 @@ def process(self, instance):
         if not self.is_active(instance.data):
             return
 
+        # editorial would fail since they might not be in database yet
+        is_editorial = instance.data.get("isEditorial")
+        if is_editorial:
+            self.log.debug("Instance is Editorial. Skipping.")
+            return
+
         if (self.skip_timelines_check and
             any(re.search(pattern, instance.data["task"])
                 for pattern in self.skip_timelines_check)):
             self.log.info("Skipping for {} task".format(instance.data["task"]))
 
-        asset_doc = instance.data["assetEntity"]
         asset_data = asset_doc["data"]
         frame_start = asset_data["frameStart"]
         frame_end = asset_data["frameEnd"]
diff --git a/openpype/hosts/tvpaint/plugins/load/load_reference_image.py b/openpype/hosts/tvpaint/plugins/load/load_reference_image.py
index 3707ef97aae..53061c68858 100644
--- a/openpype/hosts/tvpaint/plugins/load/load_reference_image.py
+++ b/openpype/hosts/tvpaint/plugins/load/load_reference_image.py
@@ -190,7 +190,7 @@ def _remove_container(self, container):
 
         if pop_idx is None:
             self.log.warning(
-                "Didn't found container in workfile containers. {}".format(
+                "Didn't find container in workfile containers. {}".format(
                     container
                 )
             )
diff --git a/openpype/modules/deadline/repository/custom/plugins/Ayon/Ayon.py b/openpype/modules/deadline/repository/custom/plugins/Ayon/Ayon.py
index 2c55e7c9516..a1f752605d9 100644
--- a/openpype/modules/deadline/repository/custom/plugins/Ayon/Ayon.py
+++ b/openpype/modules/deadline/repository/custom/plugins/Ayon/Ayon.py
@@ -85,7 +85,7 @@ def RenderExecutable(self):
         }
 
         for env, val in environment.items():
-            self.SetProcessEnvironmentVariable(env, val)
+            self.SetEnvironmentVariable(env, val)
 
         exe_list = self.GetConfigEntry("AyonExecutable")
         # clean '\ ' for MacOS pasting
@@ -101,11 +101,11 @@ def RenderExecutable(self):
 
         if exe == "":
             self.FailRender(
-                "Ayon executable was not found " +
-                "in the semicolon separated list " +
-                "\"" + ";".join(exe_list) + "\". " +
-                "The path to the render executable can be configured " +
-                "from the Plugin Configuration in the Deadline Monitor.")
+                "Ayon executable was not found in the semicolon separated "
+                "list: \"{}\". The path to the render executable can be "
+                "configured from the Plugin Configuration in the Deadline "
+                "Monitor.".format(exe_list)
+            )
         return exe
 
     def RenderArgument(self):
diff --git a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
index e9b81369cac..642608f9911 100644
--- a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
+++ b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
@@ -495,7 +495,10 @@ def inject_ayon_environment(deadlinePlugin):
             "AYON_BUNDLE_NAME": ayon_bundle_name,
         }
         for env, val in environment.items():
+            # Add the env var for the Render Plugin that is about to render
             deadlinePlugin.SetEnvironmentVariable(env, val)
+            # Add the env var for current calls to `DeadlinePlugin.RunProcess`
+            deadlinePlugin.SetProcessEnvironmentVariable(env, val)
 
         args_str = subprocess.list2cmdline(args)
         print(">>> Executing: {} {}".format(exe, args_str))
diff --git a/openpype/modules/ftrack/event_handlers_server/action_tranfer_hierarchical_values.py b/openpype/modules/ftrack/event_handlers_server/action_tranfer_hierarchical_values.py
index f6899843a39..1d73318f6ec 100644
--- a/openpype/modules/ftrack/event_handlers_server/action_tranfer_hierarchical_values.py
+++ b/openpype/modules/ftrack/event_handlers_server/action_tranfer_hierarchical_values.py
@@ -66,7 +66,7 @@ def _selection_interface(self, session, event_values=None):
                 "items": [{
                     "type": "label",
                     "value": (
-                        "Didn't found custom attributes"
+                        "Didn't find custom attributes"
                         " that can be transferred."
                     )
                 }]
diff --git a/openpype/modules/ftrack/event_handlers_server/event_next_task_update.py b/openpype/modules/ftrack/event_handlers_server/event_next_task_update.py
index 07a8ff433ed..8632f038b8e 100644
--- a/openpype/modules/ftrack/event_handlers_server/event_next_task_update.py
+++ b/openpype/modules/ftrack/event_handlers_server/event_next_task_update.py
@@ -257,7 +257,7 @@ def set_next_task_statuses(
             new_task_name = mapping.get(old_status_name)
             if not new_task_name:
                 self.log.debug(
-                    "Didn't found mapping for status \"{}\".".format(
+                    "Didn't find mapping for status \"{}\".".format(
                         task_status["name"]
                     )
                 )
diff --git a/openpype/modules/ftrack/event_handlers_server/event_sync_to_avalon.py b/openpype/modules/ftrack/event_handlers_server/event_sync_to_avalon.py
index 0aa0b9f9f54..d4dc53b6558 100644
--- a/openpype/modules/ftrack/event_handlers_server/event_sync_to_avalon.py
+++ b/openpype/modules/ftrack/event_handlers_server/event_sync_to_avalon.py
@@ -387,7 +387,7 @@ def get_found_data(entity):
             if not data:
                 # TODO logging
                 self.log.warning(
-                    "Didn't found entity by key/value \"{}\" / \"{}\"".format(
+                    "Didn't find entity by key/value \"{}\" / \"{}\"".format(
                         key, value
                     )
                 )
diff --git a/openpype/modules/ftrack/event_handlers_user/action_component_open.py b/openpype/modules/ftrack/event_handlers_user/action_component_open.py
index c731713c106..0efade9d8f3 100644
--- a/openpype/modules/ftrack/event_handlers_user/action_component_open.py
+++ b/openpype/modules/ftrack/event_handlers_user/action_component_open.py
@@ -51,7 +51,7 @@ def launch(self, session, entities, event):
         else:
             return {
                 'success': False,
-                'message': "Didn't found file: " + fpath
+                'message': "Didn't find file: " + fpath
             }
 
         return {
diff --git a/openpype/modules/ftrack/event_handlers_user/action_delete_asset.py b/openpype/modules/ftrack/event_handlers_user/action_delete_asset.py
index 72a5efbcfee..e1df8e15376 100644
--- a/openpype/modules/ftrack/event_handlers_user/action_delete_asset.py
+++ b/openpype/modules/ftrack/event_handlers_user/action_delete_asset.py
@@ -169,7 +169,7 @@ def interface(self, session, entities, event):
             return {
                 "success": True,
                 "message": (
-                    "Didn't found entities in avalon."
+                    "Didn't find entities in avalon."
                     " You can use Ftrack's Delete button for the selection."
                 )
             }
diff --git a/openpype/modules/ftrack/event_handlers_user/action_delivery.py b/openpype/modules/ftrack/event_handlers_user/action_delivery.py
index 559de3a24d7..c198389b988 100644
--- a/openpype/modules/ftrack/event_handlers_user/action_delivery.py
+++ b/openpype/modules/ftrack/event_handlers_user/action_delivery.py
@@ -61,7 +61,7 @@ def interface(self, session, entities, event):
             return {
                 "success": False,
                 "message": (
-                    "Didn't found project \"{}\" in avalon."
+                    "Didn't find project \"{}\" in avalon."
                 ).format(project_name)
             }
 
diff --git a/openpype/modules/ftrack/event_handlers_user/action_job_killer.py b/openpype/modules/ftrack/event_handlers_user/action_job_killer.py
index dd68c75f846..250670f016f 100644
--- a/openpype/modules/ftrack/event_handlers_user/action_job_killer.py
+++ b/openpype/modules/ftrack/event_handlers_user/action_job_killer.py
@@ -29,7 +29,7 @@ def interface(self, session, entities, event):
         if not jobs:
             return {
                 "success": True,
-                "message": "Didn't found any running jobs"
+                "message": "Didn't find any running jobs"
             }
 
         # Collect user ids from jobs
diff --git a/openpype/modules/muster/plugins/publish/submit_maya_muster.py b/openpype/modules/muster/plugins/publish/submit_maya_muster.py
index 5c95744876b..f6b3bfbbfd4 100644
--- a/openpype/modules/muster/plugins/publish/submit_maya_muster.py
+++ b/openpype/modules/muster/plugins/publish/submit_maya_muster.py
@@ -10,6 +10,7 @@
 import pyblish.api
 from openpype.lib import requests_post
 from openpype.hosts.maya.api import lib
+from openpype.hosts.maya.api.lib_rendersettings import RenderSettings
 from openpype.pipeline import legacy_io
 from openpype.settings import get_system_settings
 
@@ -68,10 +69,8 @@ def get_renderer_variables(renderlayer=None):
     """
 
     renderer = lib.get_renderer(renderlayer or lib.get_current_renderlayer())
-    render_attrs = lib.RENDER_ATTRS.get(renderer, lib.RENDER_ATTRS["default"])
 
-    padding = cmds.getAttr("{}.{}".format(render_attrs["node"],
-                                          render_attrs["padding"]))
+    padding = cmds.getAttr(RenderSettings.get_padding_attr(renderer))
 
     filename_0 = cmds.renderSettings(fullPath=True, firstImageName=True)[0]
 
diff --git a/openpype/pipeline/create/creator_plugins.py b/openpype/pipeline/create/creator_plugins.py
index 6aa08cae705..b51f69379ca 100644
--- a/openpype/pipeline/create/creator_plugins.py
+++ b/openpype/pipeline/create/creator_plugins.py
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 import copy
 import collections
 
@@ -193,6 +194,12 @@ class BaseCreator:
     # QUESTION make this required?
     host_name = None
 
+    # Settings auto-apply helpers
+    # Root key in project settings (mandatory for auto-apply to work)
+    settings_category = None
+    # Name of plugin in create settings > class name is used if not set
+    settings_name = None
+
     def __init__(
         self, project_settings, system_settings, create_context, headless=False
     ):
@@ -233,14 +240,90 @@ def __init__(
                 " need to keep system settings."
             ).format(self.__class__.__name__))
 
+    @staticmethod
+    def _get_settings_values(project_settings, category_name, plugin_name):
+        """Helper method to get settings values.
+
+        Args:
+            project_settings (dict[str, Any]): Project settings.
+            category_name (str): Category of settings.
+            plugin_name (str): Name of settings.
+
+        Returns:
+            Union[dict[str, Any], None]: Settings values or None.
+        """
+
+        settings = project_settings.get(category_name)
+        if not settings:
+            return None
+
+        create_settings = settings.get("create")
+        if not create_settings:
+            return None
+
+        return create_settings.get(plugin_name)
+
     def apply_settings(self, project_settings):
         """Method called on initialization of plugin to apply settings.
 
+        Default implementation tries to auto-apply settings values if are
+            in expected hierarchy.
+
+        Data hierarchy to auto-apply settings:
+            ├─ {self.settings_category}                 - Root key in settings
+            │ └─ "create"                               - Hardcoded key
+            │   └─ {self.settings_name} | {class name}  - Name of plugin
+            │     ├─ ... attribute values...            - Attribute/value pair
+
+        It is mandatory to define 'settings_category' attribute. Attribute
+        'settings_name' is optional and class name is used if is not defined.
+
+        Example data:
+            ProjectSettings {
+                "maya": {                    # self.settings_category
+                    "create": {              # Hardcoded key
+                        "CreateAnimation": { # self.settings_name / class name
+                            "enabled": True, # --- Attributes to set ---
+                            "optional": True,#
+                            "active": True,  #
+                            "fps": 25,       # -------------------------
+                        },
+                        ...
+                    },
+                    ...
+                },
+                ...
+            }
+
         Args:
             project_settings (dict[str, Any]): Project settings.
         """
 
-        pass
+        settings_category = self.settings_category
+        if not settings_category:
+            return
+
+        cls_name = self.__class__.__name__
+        settings_name = self.settings_name or cls_name
+
+        settings = self._get_settings_values(
+            project_settings, settings_category, settings_name
+        )
+        if settings is None:
+            self.log.debug("No settings found for {}".format(cls_name))
+            return
+
+        for key, value in settings.items():
+            # Log out attributes that are not defined on plugin object
+            # - those may be potential dangerous typos in settings
+            if not hasattr(self, key):
+                self.log.debug((
+                    "Applying settings to unknown attribute '{}' on '{}'."
+                ).format(
+                    key, cls_name
+                ))
+            setattr(self, key, value)
+
 
     @property
     def identifier(self):
diff --git a/openpype/plugins/publish/cleanup_explicit.py b/openpype/plugins/publish/cleanup_explicit.py
index 983c9223c66..cc6b99e8f88 100644
--- a/openpype/plugins/publish/cleanup_explicit.py
+++ b/openpype/plugins/publish/cleanup_explicit.py
@@ -58,21 +58,21 @@ def _remove_full_paths(self, full_paths):
         # Store failed paths with exception
         failed = []
         # Store removed filepaths for logging
-        succeded_files = set()
+        succeeded_files = set()
         # Remove file by file
         for filepath in filepaths:
             try:
                 os.remove(filepath)
-                succeded_files.add(filepath)
+                succeeded_files.add(filepath)
             except Exception as exc:
                 failed.append((filepath, exc))
 
-        if succeded_files:
+        if succeeded_files:
             self.log.info(
-                "Removed files:\n{}".format("\n".join(succeded_files))
+                "Removed files:\n{}".format("\n".join(sorted(succeeded_files)))
             )
 
-        # Delete folders with it's content
+        # Delete folders with its content
         succeeded = set()
         for dirpath in dirpaths:
             # Check if directory still exists
@@ -87,17 +87,21 @@ def _remove_full_paths(self, full_paths):
 
         if succeeded:
             self.log.info(
-                "Removed directories:\n{}".format("\n".join(succeeded))
+                "Removed directories:\n{}".format(
+                    "\n".join(sorted(succeeded))
+                )
             )
 
-        # Prepare lines for report of failed removements
+        # Prepare lines for report of failed removals
         lines = []
         for filepath, exc in failed:
             lines.append("{}: {}".format(filepath, str(exc)))
 
         if lines:
             self.log.warning(
-                "Failed to remove filepaths:\n{}".format("\n".join(lines))
+                "Failed to remove filepaths:\n{}".format(
+                    "\n".join(sorted(lines))
+                )
             )
 
     def _remove_empty_dirs(self, empty_dirpaths):
@@ -134,8 +138,8 @@ def _remove_empty_dirs(self, empty_dirpaths):
 
         if to_skip_dirpaths:
             self.log.debug(
-                "Skipped directories because contain files:\n{}".format(
-                    "\n".join(to_skip_dirpaths)
+                "Skipped directories because they contain files:\n{}".format(
+                    "\n".join(sorted(to_skip_dirpaths))
                 )
             )
 
@@ -147,6 +151,6 @@ def _remove_empty_dirs(self, empty_dirpaths):
         if to_delete_dirpaths:
             self.log.debug(
                 "Deleted empty directories:\n{}".format(
-                    "\n".join(to_delete_dirpaths)
+                    "\n".join(sorted(to_delete_dirpaths))
                 )
             )
diff --git a/openpype/plugins/publish/collect_comment.py b/openpype/plugins/publish/collect_comment.py
index 9f41e37f222..38d61a70710 100644
--- a/openpype/plugins/publish/collect_comment.py
+++ b/openpype/plugins/publish/collect_comment.py
@@ -103,10 +103,10 @@ def process(self, context):
 
             instance.data["comment"] = instance_comment
             if instance_comment:
-                msg_end = " has comment set to: \"{}\"".format(
+                msg_end = "has comment set to: \"{}\"".format(
                     instance_comment)
             else:
-                msg_end = " does not have set comment"
+                msg_end = "does not have set comment"
             self.log.debug("Instance {} {}".format(instance_label, msg_end))
 
     def cleanup_comment(self, comment):
diff --git a/openpype/plugins/publish/collect_rendered_files.py b/openpype/plugins/publish/collect_rendered_files.py
index a249b3acda7..6160b4f5c84 100644
--- a/openpype/plugins/publish/collect_rendered_files.py
+++ b/openpype/plugins/publish/collect_rendered_files.py
@@ -54,6 +54,8 @@ def _fill_staging_dir(self, data_object, anatomy):
         staging_dir = data_object.get("stagingDir")
         if staging_dir:
             data_object["stagingDir"] = anatomy.fill_root(staging_dir)
+            self.log.debug("Filling stagingDir with root to: %s",
+                           data_object["stagingDir"])
 
     def _process_path(self, data, anatomy):
         """Process data of a single JSON publish metadata file.
@@ -108,7 +110,6 @@ def _process_path(self, data, anatomy):
             instance = self._context.create_instance(
                 instance_data.get("subset")
             )
-            self.log.debug("Filling stagingDir...")
 
             self._fill_staging_dir(instance_data, anatomy)
             instance.data.update(instance_data)
@@ -161,7 +162,7 @@ def process(self, context):
             anatomy.project_name
         ))
 
-        self.log.debug("anatomy: {}".format(anatomy.roots))
+        self.log.debug("Anatomy roots: {}".format(anatomy.roots))
         try:
             session_is_set = False
             for path in paths:
diff --git a/openpype/plugins/publish/collect_resources_path.py b/openpype/plugins/publish/collect_resources_path.py
index cfb4d63c1b3..14c13310dfe 100644
--- a/openpype/plugins/publish/collect_resources_path.py
+++ b/openpype/plugins/publish/collect_resources_path.py
@@ -68,6 +68,12 @@ class CollectResourcesPath(pyblish.api.InstancePlugin):
                 ]
 
     def process(self, instance):
+        # editorial would fail since they might not be in database yet
+        is_editorial = instance.data.get("isEditorial")
+        if is_editorial:
+            self.log.debug("Instance is Editorial. Skipping.")
+            return
+
         anatomy = instance.context.data["anatomy"]
 
         template_data = copy.deepcopy(instance.data["anatomyData"])
diff --git a/openpype/plugins/publish/extract_burnin.py b/openpype/plugins/publish/extract_burnin.py
index dc8aab6ce4a..9a978ed286a 100644
--- a/openpype/plugins/publish/extract_burnin.py
+++ b/openpype/plugins/publish/extract_burnin.py
@@ -171,8 +171,6 @@ def main_process(self, instance):
             ).format(host_name, family, task_name, task_type, subset))
             return
 
-        self.log.debug("profile: {}".format(profile))
-
         # Pre-filter burnin definitions by instance families
         burnin_defs = self.filter_burnins_defs(profile, instance)
         if not burnin_defs:
@@ -450,7 +448,7 @@ def prepare_basic_data(self, instance):
                 filling burnin strings. `temp_data` are for repre pre-process
                 preparation.
         """
-        self.log.debug("Prepring basic data for burnins")
+        self.log.debug("Preparing basic data for burnins")
         context = instance.context
 
         version = instance.data.get("version")
diff --git a/openpype/plugins/publish/extract_color_transcode.py b/openpype/plugins/publish/extract_color_transcode.py
index dbf1b6c8a6b..faacb7af2ea 100644
--- a/openpype/plugins/publish/extract_color_transcode.py
+++ b/openpype/plugins/publish/extract_color_transcode.py
@@ -326,7 +326,6 @@ def _get_profile(self, instance):
               " | Task type \"{}\" | Subset \"{}\" "
             ).format(host_name, family, task_name, task_type, subset))
 
-        self.log.debug("profile: {}".format(profile))
         return profile
 
     def _repre_is_valid(self, repre):
diff --git a/openpype/plugins/publish/extract_review.py b/openpype/plugins/publish/extract_review.py
index db8a030dfa3..cd0f78530ae 100644
--- a/openpype/plugins/publish/extract_review.py
+++ b/openpype/plugins/publish/extract_review.py
@@ -143,7 +143,7 @@ def _get_outputs_per_representations(self, instance, profile_outputs):
             custom_tags = repre.get("custom_tags")
             if "review" not in tags:
                 self.log.debug((
-                    "Repre: {} - Didn't found \"review\" in tags. Skipping"
+                    "Repre: {} - Didn't find \"review\" in tags. Skipping"
                 ).format(repre_name))
                 continue
 
diff --git a/openpype/plugins/publish/integrate_thumbnail.py b/openpype/plugins/publish/integrate_thumbnail.py
index 0c12255d384..b154940469b 100644
--- a/openpype/plugins/publish/integrate_thumbnail.py
+++ b/openpype/plugins/publish/integrate_thumbnail.py
@@ -200,7 +200,7 @@ def _get_thumbnail_path_from_published(self, published_representations):
 
         if thumb_repre_doc is None:
             self.log.debug(
-                "There is not representation with name \"thumbnail\""
+                "There is no representation with name \"thumbnail\""
             )
             return None
 
diff --git a/openpype/plugins/publish/integrate_thumbnail_ayon.py b/openpype/plugins/publish/integrate_thumbnail_ayon.py
index cf05327ce80..f9b48eebecb 100644
--- a/openpype/plugins/publish/integrate_thumbnail_ayon.py
+++ b/openpype/plugins/publish/integrate_thumbnail_ayon.py
@@ -137,7 +137,7 @@ def _get_instance_thumbnail_path(self, published_representations):
 
         if thumb_repre_doc is None:
             self.log.debug(
-                "There is not representation with name \"thumbnail\""
+                "There is no representation with name \"thumbnail\""
             )
             return None
 
diff --git a/openpype/settings/defaults/project_settings/max.json b/openpype/settings/defaults/project_settings/max.json
index 24a87020bbe..fdaa8d2b910 100644
--- a/openpype/settings/defaults/project_settings/max.json
+++ b/openpype/settings/defaults/project_settings/max.json
@@ -16,6 +16,17 @@
         "image_format": "exr",
         "multipass": true
     },
+    "CreateReview": {
+        "review_width": 1920,
+        "review_height": 1080,
+        "percentSize": 100.0,
+        "keep_images": false,
+        "image_format": "png",
+        "visual_style": "Realistic",
+        "viewport_preset": "Quality",
+        "anti_aliasing": "None",
+        "vp_texture": true
+    },
     "PointCloud": {
         "attribute": {
             "Age": "age",
diff --git a/openpype/settings/defaults/project_settings/nuke.json b/openpype/settings/defaults/project_settings/nuke.json
index 1cadedd797a..20df0ad5c2b 100644
--- a/openpype/settings/defaults/project_settings/nuke.json
+++ b/openpype/settings/defaults/project_settings/nuke.json
@@ -19,16 +19,16 @@
             "rules": {}
         },
         "viewer": {
-            "viewerProcess": "sRGB"
+            "viewerProcess": "sRGB (default)"
         },
         "baking": {
-            "viewerProcess": "rec709"
+            "viewerProcess": "rec709 (default)"
         },
         "workfile": {
-            "colorManagement": "Nuke",
+            "colorManagement": "OCIO",
             "OCIO_config": "nuke-default",
-            "workingSpaceLUT": "linear",
-            "monitorLut": "sRGB"
+            "workingSpaceLUT": "scene_linear",
+            "monitorLut": "sRGB (default)"
         },
         "nodes": {
             "requiredNodes": [
@@ -76,7 +76,7 @@
                         {
                             "type": "text",
                             "name": "colorspace",
-                            "value": "linear"
+                            "value": "scene_linear"
                         },
                         {
                             "type": "bool",
@@ -129,7 +129,7 @@
                         {
                             "type": "text",
                             "name": "colorspace",
-                            "value": "linear"
+                            "value": "scene_linear"
                         },
                         {
                             "type": "bool",
@@ -177,7 +177,7 @@
                         {
                             "type": "text",
                             "name": "colorspace",
-                            "value": "sRGB"
+                            "value": "texture_paint"
                         },
                         {
                             "type": "bool",
@@ -193,7 +193,7 @@
             "inputs": [
                 {
                     "regex": "(beauty).*(?=.exr)",
-                    "colorspace": "linear"
+                    "colorspace": "scene_linear"
                 }
             ]
         }
diff --git a/openpype/settings/entities/dict_conditional.py b/openpype/settings/entities/dict_conditional.py
index 88d2dc82963..f26d86e6df1 100644
--- a/openpype/settings/entities/dict_conditional.py
+++ b/openpype/settings/entities/dict_conditional.py
@@ -352,7 +352,7 @@ def get_child_path(self, child_obj):
                     break
 
         if result_key is None:
-            raise ValueError("Didn't found child {}".format(child_obj))
+            raise ValueError("Didn't find child {}".format(child_obj))
 
         return "/".join([self.path, result_key])
 
diff --git a/openpype/settings/entities/dict_immutable_keys_entity.py b/openpype/settings/entities/dict_immutable_keys_entity.py
index 0209681e956..a25c22aa196 100644
--- a/openpype/settings/entities/dict_immutable_keys_entity.py
+++ b/openpype/settings/entities/dict_immutable_keys_entity.py
@@ -232,7 +232,7 @@ def get_child_path(self, child_obj):
                 break
 
         if result_key is None:
-            raise ValueError("Didn't found child {}".format(child_obj))
+            raise ValueError("Didn't find child {}".format(child_obj))
 
         return "/".join([self.path, result_key])
 
diff --git a/openpype/settings/entities/dict_mutable_keys_entity.py b/openpype/settings/entities/dict_mutable_keys_entity.py
index e6d332b9adb..c11a7cf0593 100644
--- a/openpype/settings/entities/dict_mutable_keys_entity.py
+++ b/openpype/settings/entities/dict_mutable_keys_entity.py
@@ -284,7 +284,7 @@ def get_child_path(self, child_obj):
                 break
 
         if result_key is None:
-            raise ValueError("Didn't found child {}".format(child_obj))
+            raise ValueError("Didn't find child {}".format(child_obj))
 
         return "/".join([self.path, result_key])
 
diff --git a/openpype/settings/entities/item_entities.py b/openpype/settings/entities/item_entities.py
index 3b756e4ede3..c888cf3b78f 100644
--- a/openpype/settings/entities/item_entities.py
+++ b/openpype/settings/entities/item_entities.py
@@ -295,7 +295,7 @@ def get_child_path(self, child_obj):
                 break
 
         if result_idx is None:
-            raise ValueError("Didn't found child {}".format(child_obj))
+            raise ValueError("Didn't find child {}".format(child_obj))
 
         return "/".join([self.path, str(result_idx)])
 
diff --git a/openpype/settings/entities/list_entity.py b/openpype/settings/entities/list_entity.py
index 5d6a64b3eaf..d9a18e01774 100644
--- a/openpype/settings/entities/list_entity.py
+++ b/openpype/settings/entities/list_entity.py
@@ -258,7 +258,7 @@ def get_child_path(self, child_obj):
                 break
 
         if result_idx is None:
-            raise ValueError("Didn't found child {}".format(child_obj))
+            raise ValueError("Didn't find child {}".format(child_obj))
 
         return "/".join([self.path, str(result_idx)])
 
diff --git a/openpype/settings/entities/root_entities.py b/openpype/settings/entities/root_entities.py
index f2e24fb522b..bd617c6b7c4 100644
--- a/openpype/settings/entities/root_entities.py
+++ b/openpype/settings/entities/root_entities.py
@@ -270,7 +270,7 @@ def get_child_path(self, child_entity):
         for key, _child_entity in self.non_gui_children.items():
             if _child_entity is child_entity:
                 return key
-        raise ValueError("Didn't found child {}".format(child_entity))
+        raise ValueError("Didn't find child {}".format(child_entity))
 
     @property
     def value(self):
diff --git a/openpype/settings/entities/schemas/projects_schema/schema_project_max.json b/openpype/settings/entities/schemas/projects_schema/schema_project_max.json
index e314174dff5..78cca357a39 100644
--- a/openpype/settings/entities/schemas/projects_schema/schema_project_max.json
+++ b/openpype/settings/entities/schemas/projects_schema/schema_project_max.json
@@ -65,6 +65,104 @@
                 }
             ]
         },
+        {
+            "type": "dict",
+            "collapsible": true,
+            "key": "CreateReview",
+            "label": "Create Review",
+            "children": [
+                {
+                    "type": "number",
+                    "key": "review_width",
+                    "label": "Review Width"
+                },
+                {
+                    "type": "number",
+                    "key": "review_height",
+                    "label": "Review Height"
+                },
+                {
+                    "type": "number",
+                    "key": "percentSize",
+                    "label": "Percent of Output"
+                },
+                {
+                    "type": "boolean",
+                    "key": "keep_images",
+                    "label": "Keep Image Sequences"
+                },
+                {
+                  "key": "image_format",
+                  "label": "Image Format Options",
+                  "type": "enum",
+                  "multiselection": false,
+                  "defaults": "exr",
+                  "enum_items": [
+                    {"exr": "exr"},
+                    {"jpg": "jpg"},
+                    {"png": "png"},
+                    {"tga": "tga"}
+                  ]
+                },
+                {
+                    "key": "visual_style",
+                    "label": "Preference",
+                    "type": "enum",
+                    "multiselection": false,
+                    "defaults": "Realistic",
+                    "enum_items": [
+                      {"Realistic": "Realistic"},
+                      {"Shaded": "Shaded"},
+                      {"Facets": "Facets"},
+                      {"ConsistentColors": "ConsistentColors"},
+                      {"HiddenLine": "HiddenLine"},
+                      {"Wireframe": "Wireframe"},
+                      {"BoundingBox": "BoundingBox"},
+                      {"Ink": "Ink"},
+                      {"ColorInk": "ColorInk"},
+                      {"Acrylic": "Acrylic"},
+                      {"Tech": "Tech"},
+                      {"Graphite": "Graphite"},
+                      {"ColorPencil": "ColorPencil"},
+                      {"Pastel": "Pastel"},
+                      {"Clay": "Clay"},
+                      {"ModelAssist": "ModelAssist"}
+                    ]
+                },
+                {
+                    "key": "viewport_preset",
+                    "label": "Pre-View Preset",
+                    "type": "enum",
+                    "multiselection": false,
+                    "defaults": "Quality",
+                    "enum_items": [
+                      {"Quality": "Quality"},
+                      {"Standard": "Standard"},
+                      {"Performance": "Performance"},
+                      {"DXMode": "DXMode"},
+                      {"Customize": "Customize"}
+                    ]
+                },
+                {
+                    "key": "anti_aliasing",
+                    "label": "Anti-aliasing Quality",
+                    "type": "enum",
+                    "multiselection": false,
+                    "defaults": "None",
+                    "enum_items": [
+                      {"None": "None"},
+                      {"2X": "2X"},
+                      {"4X": "4X"},
+                      {"8X": "8X"}
+                    ]
+                },
+                {
+                    "type": "boolean",
+                    "key": "vp_texture",
+                    "label": "Viewport Texture"
+                }
+            ]
+        },
         {
             "type": "dict",
             "collapsible": true,
diff --git a/openpype/tools/ayon_utils/models/__init__.py b/openpype/tools/ayon_utils/models/__init__.py
index 69722b5e219..8895515b1a5 100644
--- a/openpype/tools/ayon_utils/models/__init__.py
+++ b/openpype/tools/ayon_utils/models/__init__.py
@@ -13,6 +13,7 @@
     HIERARCHY_MODEL_SENDER,
 )
 from .thumbnails import ThumbnailsModel
+from .selection import HierarchyExpectedSelection
 
 
 __all__ = (
@@ -29,4 +30,6 @@
     "HIERARCHY_MODEL_SENDER",
 
     "ThumbnailsModel",
+
+    "HierarchyExpectedSelection",
 )
diff --git a/openpype/tools/ayon_utils/models/cache.py b/openpype/tools/ayon_utils/models/cache.py
index 44b97e930df..221a14160ca 100644
--- a/openpype/tools/ayon_utils/models/cache.py
+++ b/openpype/tools/ayon_utils/models/cache.py
@@ -81,11 +81,11 @@ class NestedCacheItem:
     """Helper for cached items stored in nested structure.
 
     Example:
-        >>> cache = NestedCacheItem(levels=2)
+        >>> cache = NestedCacheItem(levels=2, default_factory=lambda: 0)
         >>> cache["a"]["b"].is_valid
         False
         >>> cache["a"]["b"].get_data()
-        None
+        0
         >>> cache["a"]["b"] = 1
         >>> cache["a"]["b"].is_valid
         True
@@ -167,8 +167,51 @@ def get(self, key):
 
         return self[key]
 
+    def cached_count(self):
+        """Amount of cached items.
+
+        Returns:
+            int: Amount of cached items.
+        """
+
+        return len(self._data_by_key)
+
+    def clear_key(self, key):
+        """Clear cached item by key.
+
+        Args:
+            key (str): Key of the cache item.
+        """
+
+        self._data_by_key.pop(key, None)
+
+    def clear_invalid(self):
+        """Clear all invalid cache items.
+
+        Note:
+            To clear all cache items use 'reset'.
+        """
+
+        changed = {}
+        children_are_nested = self._levels > 1
+        for key, cache in tuple(self._data_by_key.items()):
+            if children_are_nested:
+                output = cache.clear_invalid()
+                if output:
+                    changed[key] = output
+                if not cache.cached_count():
+                    self._data_by_key.pop(key)
+            elif not cache.is_valid:
+                changed[key] = cache.get_data()
+                self._data_by_key.pop(key)
+        return changed
+
     def reset(self):
-        """Reset cache."""
+        """Reset cache.
+
+        Note:
+            To clear only invalid cache items use 'clear_invalid'.
+        """
 
         self._data_by_key = {}
 
diff --git a/openpype/tools/ayon_utils/models/selection.py b/openpype/tools/ayon_utils/models/selection.py
new file mode 100644
index 00000000000..0ff239882b4
--- /dev/null
+++ b/openpype/tools/ayon_utils/models/selection.py
@@ -0,0 +1,179 @@
+class _ExampleController:
+    def emit_event(self, topic, data, **kwargs):
+        pass
+
+
+class HierarchyExpectedSelection:
+    """Base skeleton of expected selection model.
+
+    Expected selection model holds information about which entities should be
+    selected. The order of selection is very important as change of project
+    will affect what folders are available in folders UI and so on. Because
+    of that should expected selection model know what is current entity
+    to select.
+
+    If any of 'handle_project', 'handle_folder' or 'handle_task' is set to
+    'False' expected selection data won't contain information about the
+    entity type at all. Also if project is not handled then it is not
+    necessary to call 'expected_project_selected'. Same goes for folder and
+    task.
+
+    Model is triggering event with 'expected_selection_changed' topic and
+    data > data structure is matching 'get_expected_selection_data' method.
+
+    Questions:
+        Require '_ExampleController' as abstraction?
+
+    Args:
+        controller (Any): Controller object. ('_ExampleController')
+        handle_project (bool): Project can be considered as can have expected
+            selection.
+        handle_folder (bool): Folder can be considered as can have expected
+            selection.
+        handle_task (bool): Task can be considered as can have expected
+            selection.
+    """
+
+    def __init__(
+        self,
+        controller,
+        handle_project=True,
+        handle_folder=True,
+        handle_task=True
+    ):
+        self._project_name = None
+        self._folder_id = None
+        self._task_name = None
+
+        self._project_selected = True
+        self._folder_selected = True
+        self._task_selected = True
+
+        self._controller = controller
+
+        self._handle_project = handle_project
+        self._handle_folder = handle_folder
+        self._handle_task = handle_task
+
+    def set_expected_selection(
+        self,
+        project_name=None,
+        folder_id=None,
+        task_name=None
+    ):
+        """Sets expected selection.
+
+        Args:
+            project_name (Optional[str]): Project name.
+            folder_id (Optional[str]): Folder id.
+            task_name (Optional[str]): Task name.
+        """
+
+        self._project_name = project_name
+        self._folder_id = folder_id
+        self._task_name = task_name
+
+        self._project_selected = not self._handle_project
+        self._folder_selected = not self._handle_folder
+        self._task_selected = not self._handle_task
+        self._emit_change()
+
+    def get_expected_selection_data(self):
+        project_current = False
+        folder_current = False
+        task_current = False
+        if not self._project_selected:
+            project_current = True
+        elif not self._folder_selected:
+            folder_current = True
+        elif not self._task_selected:
+            task_current = True
+        data = {}
+        if self._handle_project:
+            data["project"] = {
+                "name": self._project_name,
+                "current": project_current,
+                "selected": self._project_selected,
+            }
+        if self._handle_folder:
+            data["folder"] = {
+                "id": self._folder_id,
+                "current": folder_current,
+                "selected": self._folder_selected,
+            }
+        if self._handle_task:
+            data["task"] = {
+                "name": self._task_name,
+                "current": task_current,
+                "selected": self._task_selected,
+            }
+
+        return data
+
+    def is_expected_project_selected(self, project_name):
+        if not self._handle_project:
+            return True
+        return project_name == self._project_name and self._project_selected
+
+    def is_expected_folder_selected(self, folder_id):
+        if not self._handle_folder:
+            return True
+        return folder_id == self._folder_id and self._folder_selected
+
+    def expected_project_selected(self, project_name):
+        """UI selected requested project.
+
+        Other entity types can be requested for selection.
+
+        Args:
+            project_name (str): Name of project.
+        """
+
+        if project_name != self._project_name:
+            return False
+        self._project_selected = True
+        self._emit_change()
+        return True
+
+    def expected_folder_selected(self, folder_id):
+        """UI selected requested folder.
+
+        Other entity types can be requested for selection.
+
+        Args:
+            folder_id (str): Folder id.
+        """
+
+        if folder_id != self._folder_id:
+            return False
+        self._folder_selected = True
+        self._emit_change()
+        return True
+
+    def expected_task_selected(self, folder_id, task_name):
+        """UI selected requested task.
+
+        Other entity types can be requested for selection.
+
+        Because task name is not unique across project a folder id is also
+        required to confirm the right task has been selected.
+
+        Args:
+            folder_id (str): Folder id.
+            task_name (str): Task name.
+        """
+
+        if self._folder_id != folder_id:
+            return False
+
+        if task_name != self._task_name:
+            return False
+        self._task_selected = True
+        self._emit_change()
+        return True
+
+    def _emit_change(self):
+        self._controller.emit_event(
+            "expected_selection_changed",
+            self.get_expected_selection_data(),
+        )
diff --git a/openpype/tools/ayon_utils/widgets/projects_widget.py b/openpype/tools/ayon_utils/widgets/projects_widget.py
index f98bfcdf8a5..728433f929d 100644
--- a/openpype/tools/ayon_utils/widgets/projects_widget.py
+++ b/openpype/tools/ayon_utils/widgets/projects_widget.py
@@ -503,17 +503,6 @@ def set_current_context_project(self, project_name):
         self._projects_model.set_current_context_project(project_name)
         self._projects_proxy_model.invalidateFilter()
 
-    def _update_select_item_visiblity(self, **kwargs):
-        if not self._select_item_visible:
-            return
-        if "project_name" not in kwargs:
-            project_name = self.get_selected_project_name()
-        else:
-            project_name = kwargs.get("project_name")
-
-        # Hide the item if a project is selected
-        self._projects_model.set_selected_project(project_name)
-
     def set_select_item_visible(self, visible):
         self._select_item_visible = visible
         self._projects_model.set_select_item_visible(visible)
@@ -534,6 +523,17 @@ def set_standard_filter_enabled(self, enabled):
     def set_library_filter_enabled(self, enabled):
         return self._projects_proxy_model.set_library_filter_enabled(enabled)
 
+    def _update_select_item_visiblity(self, **kwargs):
+        if not self._select_item_visible:
+            return
+        if "project_name" not in kwargs:
+            project_name = self.get_selected_project_name()
+        else:
+            project_name = kwargs.get("project_name")
+
+        # Hide the item if a project is selected
+        self._projects_model.set_selected_project(project_name)
+
     def _on_current_index_changed(self, idx):
         if not self._listen_selection_change:
             return
diff --git a/openpype/tools/ayon_workfiles/abstract.py b/openpype/tools/ayon_workfiles/abstract.py
index ce399fd4c62..260f701d4b2 100644
--- a/openpype/tools/ayon_workfiles/abstract.py
+++ b/openpype/tools/ayon_workfiles/abstract.py
@@ -443,8 +443,11 @@ def project_settings(self):
         pass
 
     @abstractmethod
-    def get_project_entity(self):
-        """Get current project entity.
+    def get_project_entity(self, project_name):
+        """Get project entity by name.
+
+        Args:
+            project_name (str): Project name.
 
         Returns:
             dict[str, Any]: Project entity data.
@@ -453,10 +456,11 @@ def get_project_entity(self):
         pass
 
     @abstractmethod
-    def get_folder_entity(self, folder_id):
+    def get_folder_entity(self, project_name, folder_id):
         """Get folder entity by id.
 
         Args:
+            project_name (str): Project name.
             folder_id (str): Folder id.
 
         Returns:
@@ -466,10 +470,11 @@ def get_folder_entity(self, folder_id):
         pass
 
     @abstractmethod
-    def get_task_entity(self, task_id):
+    def get_task_entity(self, project_name, task_id):
         """Get task entity by id.
 
         Args:
+            project_name (str): Project name.
             task_id (str): Task id.
 
         Returns:
@@ -574,12 +579,10 @@ def get_selected_task_name(self):
         pass
 
     @abstractmethod
-    def set_selected_task(self, folder_id, task_id, task_name):
+    def set_selected_task(self, task_id, task_name):
         """Change selected task.
 
         Args:
-            folder_id (Union[str, None]): Folder id or None if no folder
-                is selected.
             task_id (Union[str, None]): Task id or None if no task
                 is selected.
             task_name (Union[str, None]): Task name or None if no task
@@ -711,21 +714,27 @@ def expected_task_selected(self, folder_id, task_name):
         pass
 
     @abstractmethod
-    def expected_representation_selected(self, representation_id):
+    def expected_representation_selected(
+        self, folder_id, task_name, representation_id
+    ):
         """Expected representation was selected in UI.
 
         Args:
+            folder_id (str): Folder id under which representation is.
+            task_name (str): Task name under which representation is.
             representation_id (str): Representation id which was selected.
         """
 
         pass
 
     @abstractmethod
-    def expected_workfile_selected(self, workfile_path):
+    def expected_workfile_selected(self, folder_id, task_name, workfile_name):
         """Expected workfile was selected in UI.
 
         Args:
-            workfile_path (str): Workfile path which was selected.
+            folder_id (str): Folder id under which workfile is.
+            task_name (str): Task name under which workfile is.
+            workfile_name (str): Workfile filename which was selected.
         """
 
         pass
@@ -738,7 +747,7 @@ def go_to_current_context(self):
 
     # Model functions
     @abstractmethod
-    def get_folder_items(self, sender):
+    def get_folder_items(self, project_name, sender):
         """Folder items to visualize project hierarchy.
 
         This function may trigger events 'folders.refresh.started' and
@@ -746,6 +755,7 @@ def get_folder_items(self, sender):
         That may help to avoid re-refresh of folder items in UI elements.
 
         Args:
+            project_name (str): Project name for which are folders requested.
             sender (str): Who requested folder items.
 
         Returns:
@@ -756,7 +766,7 @@ def get_folder_items(self, sender):
         pass
 
     @abstractmethod
-    def get_task_items(self, folder_id, sender):
+    def get_task_items(self, project_name, folder_id, sender):
         """Task items.
 
         This function may trigger events 'tasks.refresh.started' and
@@ -764,6 +774,7 @@ def get_task_items(self, folder_id, sender):
         That may help to avoid re-refresh of task items in UI elements.
 
         Args:
+            project_name (str): Project name for which are tasks requested.
             folder_id (str): Folder ID for which are tasks requested.
             sender (str): Who requested folder items.
 
@@ -892,22 +903,25 @@ def save_workfile_info(self, folder_id, task_id, filepath, note):
         At this moment the only information which can be saved about
             workfile is 'note'.
 
+        When 'note' is 'None' it is only validated if workfile info exists,
+            and if not then creates one with empty note.
+
         Args:
             folder_id (str): Folder id.
             task_id (str): Task id.
             filepath (str): Workfile path.
-            note (str): Note.
+            note (Union[str, None]): Note.
         """
 
         pass
 
     # General commands
     @abstractmethod
-    def refresh(self):
-        """Refresh everything, models, ui etc.
+    def reset(self):
+        """Reset everything, models, ui etc.
 
-        Triggers 'controller.refresh.started' event at the beginning and
-        'controller.refresh.finished' at the end.
+        Triggers 'controller.reset.started' event at the beginning and
+        'controller.reset.finished' at the end.
         """
 
         pass
diff --git a/openpype/tools/ayon_workfiles/control.py b/openpype/tools/ayon_workfiles/control.py
index 3784959cafb..fbe6df31551 100644
--- a/openpype/tools/ayon_workfiles/control.py
+++ b/openpype/tools/ayon_workfiles/control.py
@@ -16,93 +16,120 @@
 )
 from openpype.pipeline.workfile import create_workdir_extra_folders
 
+from openpype.tools.ayon_utils.models import (
+    HierarchyModel,
+    HierarchyExpectedSelection,
+    ProjectsModel,
+)
+
 from .abstract import (
     AbstractWorkfilesFrontend,
     AbstractWorkfilesBackend,
 )
-from .models import SelectionModel, EntitiesModel, WorkfilesModel
+from .models import SelectionModel, WorkfilesModel
+
 
+class WorkfilesToolExpectedSelection(HierarchyExpectedSelection):
+    def __init__(self, controller):
+        super(WorkfilesToolExpectedSelection, self).__init__(
+            controller,
+            handle_project=False,
+            handle_folder=True,
+            handle_task=True,
+        )
 
-class ExpectedSelection:
-    def __init__(self):
-        self._folder_id = None
-        self._task_name = None
         self._workfile_name = None
         self._representation_id = None
-        self._folder_selected = True
-        self._task_selected = True
-        self._workfile_name_selected = True
-        self._representation_id_selected = True
+
+        self._workfile_selected = True
+        self._representation_selected = True
 
     def set_expected_selection(
         self,
-        folder_id,
-        task_name,
+        project_name=None,
+        folder_id=None,
+        task_name=None,
         workfile_name=None,
-        representation_id=None
+        representation_id=None,
     ):
-        self._folder_id = folder_id
-        self._task_name = task_name
         self._workfile_name = workfile_name
         self._representation_id = representation_id
-        self._folder_selected = False
-        self._task_selected = False
-        self._workfile_name_selected = workfile_name is None
-        self._representation_id_selected = representation_id is None
+
+        self._workfile_selected = False
+        self._representation_selected = False
+
+        super(WorkfilesToolExpectedSelection, self).set_expected_selection(
+            project_name,
+            folder_id,
+            task_name,
+        )
 
     def get_expected_selection_data(self):
-        return {
-            "folder_id": self._folder_id,
-            "task_name": self._task_name,
-            "workfile_name": self._workfile_name,
-            "representation_id": self._representation_id,
-            "folder_selected": self._folder_selected,
-            "task_selected": self._task_selected,
-            "workfile_name_selected": self._workfile_name_selected,
-            "representation_id_selected": self._representation_id_selected,
+        data = super(
+            WorkfilesToolExpectedSelection, self
+        ).get_expected_selection_data()
+
+        _is_current = (
+            self._project_selected
+            and self._folder_selected
+            and self._task_selected
+        )
+        workfile_is_current = False
+        repre_is_current = False
+        if _is_current:
+            workfile_is_current = not self._workfile_selected
+            repre_is_current = not self._representation_selected
+
+        data["workfile"] = {
+            "name": self._workfile_name,
+            "current": workfile_is_current,
+            "selected": self._workfile_selected,
         }
+        data["representation"] = {
+            "id": self._representation_id,
+            "current": repre_is_current,
+            "selected": self._workfile_selected,
+        }
+        return data
 
-    def is_expected_folder_selected(self, folder_id):
-        return folder_id == self._folder_id and self._folder_selected
+    def is_expected_workfile_selected(self, workfile_name):
+        return (
+            workfile_name == self._workfile_name
+            and self._workfile_selected
+        )
 
-    def is_expected_task_selected(self, folder_id, task_name):
-        if not self.is_expected_folder_selected(folder_id):
-            return False
-        return task_name == self._task_name and self._task_selected
+    def is_expected_representation_selected(self, representation_id):
+        return (
+            representation_id == self._representation_id
+            and self._representation_selected
+        )
 
-    def expected_folder_selected(self, folder_id):
+    def expected_workfile_selected(self, folder_id, task_name, workfile_name):
         if folder_id != self._folder_id:
             return False
-        self._folder_selected = True
-        return True
-
-    def expected_task_selected(self, folder_id, task_name):
-        if not self.is_expected_folder_selected(folder_id):
-            return False
 
         if task_name != self._task_name:
             return False
 
-        self._task_selected = True
-        return True
-
-    def expected_workfile_selected(self, folder_id, task_name, workfile_name):
-        if not self.is_expected_task_selected(folder_id, task_name):
-            return False
-
         if workfile_name != self._workfile_name:
             return False
-        self._workfile_name_selected = True
+        self._workfile_selected = True
+        self._emit_change()
         return True
 
     def expected_representation_selected(
         self, folder_id, task_name, representation_id
     ):
-        if not self.is_expected_task_selected(folder_id, task_name):
+        if folder_id != self._folder_id:
+            return False
+
+        if task_name != self._task_name:
             return False
+
         if representation_id != self._representation_id:
             return False
-        self._representation_id_selected = True
+        self._representation_selected = True
+        self._emit_change()
         return True
 
 
@@ -136,9 +163,9 @@ def __init__(self, host=None):
 
         # Expected selected folder and task
         self._expected_selection = self._create_expected_selection_obj()
-
         self._selection_model = self._create_selection_model()
-        self._entities_model = self._create_entities_model()
+        self._projects_model = self._create_projects_model()
+        self._hierarchy_model = self._create_hierarchy_model()
         self._workfiles_model = self._create_workfiles_model()
 
     @property
@@ -151,13 +178,16 @@ def is_host_valid(self):
         return self._host_is_valid
 
     def _create_expected_selection_obj(self):
-        return ExpectedSelection()
+        return WorkfilesToolExpectedSelection(self)
+
+    def _create_projects_model(self):
+        return ProjectsModel(self)
 
     def _create_selection_model(self):
         return SelectionModel(self)
 
-    def _create_entities_model(self):
-        return EntitiesModel(self)
+    def _create_hierarchy_model(self):
+        return HierarchyModel(self)
 
     def _create_workfiles_model(self):
         return WorkfilesModel(self)
@@ -193,14 +223,17 @@ def project_anatomy(self):
             self._project_anatomy = Anatomy(self.get_current_project_name())
         return self._project_anatomy
 
-    def get_project_entity(self):
-        return self._entities_model.get_project_entity()
+    def get_project_entity(self, project_name):
+        return self._projects_model.get_project_entity(
+            project_name)
 
-    def get_folder_entity(self, folder_id):
-        return self._entities_model.get_folder_entity(folder_id)
+    def get_folder_entity(self, project_name, folder_id):
+        return self._hierarchy_model.get_folder_entity(
+            project_name, folder_id)
 
-    def get_task_entity(self, task_id):
-        return self._entities_model.get_task_entity(task_id)
+    def get_task_entity(self, project_name, task_id):
+        return self._hierarchy_model.get_task_entity(
+            project_name, task_id)
 
     # ---------------------------------
     # Implementation of abstract methods
@@ -293,9 +326,8 @@ def get_selected_task_id(self):
     def get_selected_task_name(self):
         return self._selection_model.get_selected_task_name()
 
-    def set_selected_task(self, folder_id, task_id, task_name):
-        return self._selection_model.set_selected_task(
-            folder_id, task_id, task_name)
+    def set_selected_task(self, task_id, task_name):
+        return self._selection_model.set_selected_task(task_id, task_name)
 
     def get_selected_workfile_path(self):
         return self._selection_model.get_selected_workfile_path()
@@ -318,7 +350,11 @@ def set_expected_selection(
         representation_id=None
     ):
         self._expected_selection.set_expected_selection(
-            folder_id, task_name, workfile_name, representation_id
+            self.get_current_project_name(),
+            folder_id,
+            task_name,
+            workfile_name,
+            representation_id
         )
         self._trigger_expected_selection_changed()
 
@@ -355,11 +391,13 @@ def go_to_current_context(self):
         )
 
     # Model functions
-    def get_folder_items(self, sender):
-        return self._entities_model.get_folder_items(sender)
+    def get_folder_items(self, project_name, sender=None):
+        return self._hierarchy_model.get_folder_items(project_name, sender)
 
-    def get_task_items(self, folder_id, sender):
-        return self._entities_model.get_tasks_items(folder_id, sender)
+    def get_task_items(self, project_name, folder_id, sender=None):
+        return self._hierarchy_model.get_task_items(
+            project_name, folder_id, sender
+        )
 
     def get_workarea_dir_by_context(self, folder_id, task_id):
         return self._workfiles_model.get_workarea_dir_by_context(
@@ -394,7 +432,9 @@ def fill_workarea_filepath(
     def get_published_file_items(self, folder_id, task_id):
         task_name = None
         if task_id:
-            task = self.get_task_entity(task_id)
+            task = self.get_task_entity(
+                self.get_current_project_name(), task_id
+            )
             task_name = task.get("name")
 
         return self._workfiles_model.get_published_file_items(
@@ -410,21 +450,27 @@ def save_workfile_info(self, folder_id, task_id, filepath, note):
             folder_id, task_id, filepath, note
         )
 
-    def refresh(self):
+    def reset(self):
         if not self._host_is_valid:
-            self._emit_event("controller.refresh.started")
-            self._emit_event("controller.refresh.finished")
+            self._emit_event("controller.reset.started")
+            self._emit_event("controller.reset.finished")
             return
         expected_folder_id = self.get_selected_folder_id()
         expected_task_name = self.get_selected_task_name()
+        expected_work_path = self.get_selected_workfile_path()
+        expected_repre_id = self.get_selected_representation_id()
+        expected_work_name = None
+        if expected_work_path:
+            expected_work_name = os.path.basename(expected_work_path)
 
-        self._emit_event("controller.refresh.started")
+        self._emit_event("controller.reset.started")
 
         context = self._get_host_current_context()
 
         project_name = context["project_name"]
         folder_name = context["asset_name"]
         task_name = context["task_name"]
+        current_file = self.get_current_workfile()
         folder_id = None
         if folder_name:
             folder = ayon_api.get_folder_by_name(project_name, folder_name)
@@ -439,18 +485,25 @@ def refresh(self):
         self._current_folder_id = folder_id
         self._current_task_name = task_name
 
+        self._projects_model.reset()
+        self._hierarchy_model.reset()
+
         if not expected_folder_id:
             expected_folder_id = folder_id
             expected_task_name = task_name
+            if current_file:
+                expected_work_name = os.path.basename(current_file)
+
+        self._emit_event("controller.reset.finished")
 
         self._expected_selection.set_expected_selection(
-            expected_folder_id, expected_task_name
+            project_name,
+            expected_folder_id,
+            expected_task_name,
+            expected_work_name,
+            expected_repre_id,
         )
 
-        self._entities_model.refresh()
-
-        self._emit_event("controller.refresh.finished")
-
     # Controller actions
     def open_workfile(self, folder_id, task_id, filepath):
         self._emit_event("open_workfile.started")
@@ -579,9 +632,9 @@ def _get_event_context_data(
         self, project_name, folder_id, task_id, folder=None, task=None
     ):
         if folder is None:
-            folder = self.get_folder_entity(folder_id)
+            folder = self.get_folder_entity(project_name, folder_id)
         if task is None:
-            task = self.get_task_entity(task_id)
+            task = self.get_task_entity(project_name, task_id)
         # NOTE keys should be OpenPype compatible
         return {
             "project_name": project_name,
@@ -633,8 +686,8 @@ def _save_as_workfile(
     ):
         # Trigger before save event
         project_name = self.get_current_project_name()
-        folder = self.get_folder_entity(folder_id)
-        task = self.get_task_entity(task_id)
+        folder = self.get_folder_entity(project_name, folder_id)
+        task = self.get_task_entity(project_name, task_id)
         task_name = task["name"]
 
         # QUESTION should the data be different for 'before' and 'after'?
@@ -674,6 +727,9 @@ def _save_as_workfile(
         else:
             self._host_save_workfile(dst_filepath)
 
+        # Make sure workfile info exists
+        self.save_workfile_info(folder_id, task_id, dst_filepath, None)
+
         # Create extra folders
         create_workdir_extra_folders(
             workdir,
@@ -685,4 +741,4 @@ def _save_as_workfile(
 
         # Trigger after save events
         emit_event("workfile.save.after", event_data, source="workfiles.tool")
-        self.refresh()
+        self.reset()
diff --git a/openpype/tools/ayon_workfiles/models/__init__.py b/openpype/tools/ayon_workfiles/models/__init__.py
index d906b9e7bdc..734cb08cb6c 100644
--- a/openpype/tools/ayon_workfiles/models/__init__.py
+++ b/openpype/tools/ayon_workfiles/models/__init__.py
@@ -1,10 +1,8 @@
-from .hierarchy import EntitiesModel
 from .selection import SelectionModel
 from .workfiles import WorkfilesModel
 
 
 __all__ = (
     "SelectionModel",
-    "EntitiesModel",
     "WorkfilesModel",
 )
diff --git a/openpype/tools/ayon_workfiles/models/hierarchy.py b/openpype/tools/ayon_workfiles/models/hierarchy.py
deleted file mode 100644
index a1d51525daf..00000000000
--- a/openpype/tools/ayon_workfiles/models/hierarchy.py
+++ /dev/null
@@ -1,236 +0,0 @@
-"""Hierarchy model that handles folders and tasks.
-
-The model can be extracted for common usage. In that case it will be required
-to add more handling of project name changes.
-"""
-
-import time
-import collections
-import contextlib
-
-import ayon_api
-
-from openpype.tools.ayon_workfiles.abstract import (
-    FolderItem,
-    TaskItem,
-)
-
-
-def _get_task_items_from_tasks(tasks):
-    """
-
-    Returns:
-        TaskItem: Task item.
-    """
-
-    output = []
-    for task in tasks:
-        folder_id = task["folderId"]
-        output.append(TaskItem(
-            task["id"],
-            task["name"],
-            task["type"],
-            folder_id,
-            None,
-            None
-        ))
-    return output
-
-
-def _get_folder_item_from_hierarchy_item(item):
-    return FolderItem(
-        item["id"],
-        item["parentId"],
-        item["name"],
-        item["label"],
-        None,
-        None,
-    )
-
-
-class CacheItem:
-    def __init__(self, lifetime=120):
-        self._lifetime = lifetime
-        self._last_update = None
-        self._data = None
-
-    @property
-    def is_valid(self):
-        if self._last_update is None:
-            return False
-
-        return (time.time() - self._last_update) < self._lifetime
-
-    def set_invalid(self, data=None):
-        self._last_update = None
-        self._data = data
-
-    def get_data(self):
-        return self._data
-
-    def update_data(self, data):
-        self._data = data
-        self._last_update = time.time()
-
-
-class EntitiesModel(object):
-    event_source = "entities.model"
-
-    def __init__(self, controller):
-        project_cache = CacheItem()
-        project_cache.set_invalid({})
-        folders_cache = CacheItem()
-        folders_cache.set_invalid({})
-        self._project_cache = project_cache
-        self._folders_cache = folders_cache
-        self._tasks_cache = {}
-
-        self._folders_by_id = {}
-        self._tasks_by_id = {}
-
-        self._folders_refreshing = False
-        self._tasks_refreshing = set()
-        self._controller = controller
-
-    def reset(self):
-        self._project_cache.set_invalid({})
-        self._folders_cache.set_invalid({})
-        self._tasks_cache = {}
-
-        self._folders_by_id = {}
-        self._tasks_by_id = {}
-
-    def refresh(self):
-        self._refresh_folders_cache()
-
-    def get_project_entity(self):
-        if not self._project_cache.is_valid:
-            project_name = self._controller.get_current_project_name()
-            project_entity = ayon_api.get_project(project_name)
-            self._project_cache.update_data(project_entity)
-        return self._project_cache.get_data()
-
-    def get_folder_items(self, sender):
-        if not self._folders_cache.is_valid:
-            self._refresh_folders_cache(sender)
-        return self._folders_cache.get_data()
-
-    def get_tasks_items(self, folder_id, sender):
-        if not folder_id:
-            return []
-
-        task_cache = self._tasks_cache.get(folder_id)
-        if task_cache is None or not task_cache.is_valid:
-            self._refresh_tasks_cache(folder_id, sender)
-            task_cache = self._tasks_cache.get(folder_id)
-        return task_cache.get_data()
-
-    def get_folder_entity(self, folder_id):
-        if folder_id not in self._folders_by_id:
-            entity = None
-            if folder_id:
-                project_name = self._controller.get_current_project_name()
-                entity = ayon_api.get_folder_by_id(project_name, folder_id)
-            self._folders_by_id[folder_id] = entity
-        return self._folders_by_id[folder_id]
-
-    def get_task_entity(self, task_id):
-        if task_id not in self._tasks_by_id:
-            entity = None
-            if task_id:
-                project_name = self._controller.get_current_project_name()
-                entity = ayon_api.get_task_by_id(project_name, task_id)
-            self._tasks_by_id[task_id] = entity
-        return self._tasks_by_id[task_id]
-
-    @contextlib.contextmanager
-    def _folder_refresh_event_manager(self, project_name, sender):
-        self._folders_refreshing = True
-        self._controller.emit_event(
-            "folders.refresh.started",
-            {"project_name": project_name, "sender": sender},
-            self.event_source
-        )
-        try:
-            yield
-
-        finally:
-            self._controller.emit_event(
-                "folders.refresh.finished",
-                {"project_name": project_name, "sender": sender},
-                self.event_source
-            )
-            self._folders_refreshing = False
-
-    @contextlib.contextmanager
-    def _task_refresh_event_manager(
-        self, project_name, folder_id, sender
-    ):
-        self._tasks_refreshing.add(folder_id)
-        self._controller.emit_event(
-            "tasks.refresh.started",
-            {
-                "project_name": project_name,
-                "folder_id": folder_id,
-                "sender": sender,
-            },
-            self.event_source
-        )
-        try:
-            yield
-
-        finally:
-            self._controller.emit_event(
-                "tasks.refresh.finished",
-                {
-                    "project_name": project_name,
-                    "folder_id": folder_id,
-                    "sender": sender,
-                },
-                self.event_source
-            )
-            self._tasks_refreshing.discard(folder_id)
-
-    def _refresh_folders_cache(self, sender=None):
-        if self._folders_refreshing:
-            return
-        project_name = self._controller.get_current_project_name()
-        with self._folder_refresh_event_manager(project_name, sender):
-            folder_items = self._query_folders(project_name)
-            self._folders_cache.update_data(folder_items)
-
-    def _query_folders(self, project_name):
-        hierarchy = ayon_api.get_folders_hierarchy(project_name)
-
-        folder_items = {}
-        hierachy_queue = collections.deque(hierarchy["hierarchy"])
-        while hierachy_queue:
-            item = hierachy_queue.popleft()
-            folder_item = _get_folder_item_from_hierarchy_item(item)
-            folder_items[folder_item.entity_id] = folder_item
-            hierachy_queue.extend(item["children"] or [])
-        return folder_items
-
-    def _refresh_tasks_cache(self, folder_id, sender=None):
-        if folder_id in self._tasks_refreshing:
-            return
-
-        project_name = self._controller.get_current_project_name()
-        with self._task_refresh_event_manager(
-            project_name, folder_id, sender
-        ):
-            cache_item = self._tasks_cache.get(folder_id)
-            if cache_item is None:
-                cache_item = CacheItem()
-                self._tasks_cache[folder_id] = cache_item
-
-            task_items = self._query_tasks(project_name, folder_id)
-            cache_item.update_data(task_items)
-
-    def _query_tasks(self, project_name, folder_id):
-        tasks = list(ayon_api.get_tasks(
-            project_name,
-            folder_ids=[folder_id],
-            fields={"id", "name", "label", "folderId", "type"}
-        ))
-        return _get_task_items_from_tasks(tasks)
diff --git a/openpype/tools/ayon_workfiles/models/selection.py b/openpype/tools/ayon_workfiles/models/selection.py
index ad034794d84..2f0896842d0 100644
--- a/openpype/tools/ayon_workfiles/models/selection.py
+++ b/openpype/tools/ayon_workfiles/models/selection.py
@@ -4,7 +4,7 @@ class SelectionModel(object):
     Triggering events:
     - "selection.folder.changed"
     - "selection.task.changed"
-    - "workarea.selection.changed"
+    - "selection.workarea.changed"
     - "selection.representation.changed"
     """
 
@@ -29,7 +29,10 @@ def set_selected_folder(self, folder_id):
         self._folder_id = folder_id
         self._controller.emit_event(
             "selection.folder.changed",
-            {"folder_id": folder_id},
+            {
+                "project_name": self._controller.get_current_project_name(),
+                "folder_id": folder_id
+            },
             self.event_source
         )
 
@@ -39,10 +42,7 @@ def get_selected_task_name(self):
     def get_selected_task_id(self):
         return self._task_id
 
-    def set_selected_task(self, folder_id, task_id, task_name):
-        if folder_id != self._folder_id:
-            self.set_selected_folder(folder_id)
-
+    def set_selected_task(self, task_id, task_name):
         if task_id == self._task_id:
             return
 
@@ -51,7 +51,8 @@ def set_selected_task(self, folder_id, task_id, task_name):
         self._controller.emit_event(
             "selection.task.changed",
             {
-                "folder_id": folder_id,
+                "project_name": self._controller.get_current_project_name(),
+                "folder_id": self._folder_id,
                 "task_name": task_name,
                 "task_id": task_id
             },
@@ -67,8 +68,9 @@ def set_selected_workfile_path(self, path):
 
         self._workfile_path = path
         self._controller.emit_event(
-            "workarea.selection.changed",
+            "selection.workarea.changed",
             {
+                "project_name": self._controller.get_current_project_name(),
                 "path": path,
                 "folder_id": self._folder_id,
                 "task_name": self._task_name,
@@ -86,6 +88,9 @@ def set_selected_representation_id(self, representation_id):
         self._representation_id = representation_id
         self._controller.emit_event(
             "selection.representation.changed",
-            {"representation_id": representation_id},
+            {
+                "project_name": self._controller.get_current_project_name(),
+                "representation_id": representation_id,
+            },
             self.event_source
         )
diff --git a/openpype/tools/ayon_workfiles/models/workfiles.py b/openpype/tools/ayon_workfiles/models/workfiles.py
index 4d989ed22c3..907b9b53836 100644
--- a/openpype/tools/ayon_workfiles/models/workfiles.py
+++ b/openpype/tools/ayon_workfiles/models/workfiles.py
@@ -148,7 +148,9 @@ def _get_base_data(self):
     def _get_folder_data(self, folder_id):
         fill_data = self._fill_data_by_folder_id.get(folder_id)
         if fill_data is None:
-            folder = self._controller.get_folder_entity(folder_id)
+            folder = self._controller.get_folder_entity(
+                self.project_name, folder_id
+            )
             fill_data = get_folder_template_data(folder)
             self._fill_data_by_folder_id[folder_id] = fill_data
         return copy.deepcopy(fill_data)
@@ -156,7 +158,9 @@ def _get_folder_data(self, folder_id):
     def _get_task_data(self, project_entity, folder_id, task_id):
         task_data = self._task_data_by_folder_id.setdefault(folder_id, {})
         if task_id not in task_data:
-            task = self._controller.get_task_entity(task_id)
+            task = self._controller.get_task_entity(
+                self.project_name, task_id
+            )
             if task:
                 task_data[task_id] = get_task_template_data(
                     project_entity, task)
@@ -167,8 +171,9 @@ def _prepare_fill_data(self, folder_id, task_id):
             return {}
 
         base_data = self._get_base_data()
+        project_name = base_data["project"]["name"]
         folder_data = self._get_folder_data(folder_id)
-        project_entity = self._controller.get_project_entity()
+        project_entity = self._controller.get_project_entity(project_name)
         task_data = self._get_task_data(project_entity, folder_id, task_id)
 
         base_data.update(folder_data)
@@ -292,9 +297,13 @@ def get_workarea_save_as_data(self, folder_id, task_id):
         folder = None
         task = None
         if folder_id:
-            folder = self._controller.get_folder_entity(folder_id)
+            folder = self._controller.get_folder_entity(
+                self.project_name, folder_id
+            )
         if task_id:
-            task = self._controller.get_task_entity(task_id)
+            task = self._controller.get_task_entity(
+                self.project_name, task_id
+            )
 
         if not folder or not task:
             return {
@@ -491,10 +500,13 @@ def save_workfile_info(self, folder_id, task_id, filepath, note):
         )
         if not workfile_info:
             self._cache[identifier] = self._create_workfile_info_entity(
-                task_id, rootless_path, note)
+                task_id, rootless_path, note or "")
             self._items.pop(identifier, None)
             return
 
+        if note is None:
+            return
+
         new_workfile_info = copy.deepcopy(workfile_info)
         attrib = new_workfile_info.setdefault("attrib", {})
         attrib["description"] = note
diff --git a/openpype/tools/ayon_workfiles/widgets/files_widget.py b/openpype/tools/ayon_workfiles/widgets/files_widget.py
index 656ddf1dd82..16f0b6fce39 100644
--- a/openpype/tools/ayon_workfiles/widgets/files_widget.py
+++ b/openpype/tools/ayon_workfiles/widgets/files_widget.py
@@ -69,7 +69,7 @@ def __init__(self, controller, parent):
         main_layout.addWidget(btns_widget, 0)
 
         controller.register_event_callback(
-            "workarea.selection.changed",
+            "selection.workarea.changed",
             self._on_workarea_path_changed
         )
         controller.register_event_callback(
diff --git a/openpype/tools/ayon_workfiles/widgets/files_widget_published.py b/openpype/tools/ayon_workfiles/widgets/files_widget_published.py
index 576cf18d730..704f7b2f39b 100644
--- a/openpype/tools/ayon_workfiles/widgets/files_widget_published.py
+++ b/openpype/tools/ayon_workfiles/widgets/files_widget_published.py
@@ -59,14 +59,6 @@ def __init__(self, controller):
 
         self._add_empty_item()
 
-    def _clear_items(self):
-        self._remove_missing_context_item()
-        self._remove_empty_item()
-        if self._items_by_id:
-            root = self.invisibleRootItem()
-            root.removeRows(0, root.rowCount())
-            self._items_by_id = {}
-
     def set_published_mode(self, published_mode):
         if self._published_mode == published_mode:
             return
@@ -89,6 +81,18 @@ def get_index_by_representation_id(self, representation_id):
             return QtCore.QModelIndex()
         return self.indexFromItem(item)
 
+    def refresh(self):
+        if self._published_mode:
+            self._fill_items()
+
+    def _clear_items(self):
+        self._remove_missing_context_item()
+        self._remove_empty_item()
+        if self._items_by_id:
+            root = self.invisibleRootItem()
+            root.removeRows(0, root.rowCount())
+            self._items_by_id = {}
+
     def _get_missing_context_item(self):
         if self._missing_context_item is None:
             message = "Select folder"
@@ -149,7 +153,6 @@ def _remove_empty_item(self):
 
     def _on_folder_changed(self, event):
         self._last_folder_id = event["folder_id"]
-        self._last_task_id = None
         if self._context_select_mode:
             return
 
@@ -356,14 +359,13 @@ def _on_mouse_double_click(self, event):
             self.save_as_requested.emit()
 
     def _on_expected_selection_change(self, event):
-        if (
-            event["representation_id_selected"]
-            or not event["folder_selected"]
-            or (event["task_name"] and not event["task_selected"])
-        ):
+        repre_info = event["representation"]
+        if not repre_info["current"]:
             return
 
-        representation_id = event["representation_id"]
+        self._model.refresh()
+
+        representation_id = repre_info["id"]
         selected_repre_id = self.get_selected_repre_id()
         if (
             representation_id is not None
@@ -376,5 +378,5 @@ def _on_expected_selection_change(self, event):
                 self._view.setCurrentIndex(proxy_index)
 
         self._controller.expected_representation_selected(
-            event["folder_id"], event["task_name"], representation_id
+            event["folder"]["id"], event["task"]["name"], representation_id
         )
diff --git a/openpype/tools/ayon_workfiles/widgets/files_widget_workarea.py b/openpype/tools/ayon_workfiles/widgets/files_widget_workarea.py
index 3a8e90f9333..8eefd3cf812 100644
--- a/openpype/tools/ayon_workfiles/widgets/files_widget_workarea.py
+++ b/openpype/tools/ayon_workfiles/widgets/files_widget_workarea.py
@@ -28,6 +28,10 @@ def __init__(self, controller):
         self.setHeaderData(0, QtCore.Qt.Horizontal, "Name")
         self.setHeaderData(1, QtCore.Qt.Horizontal, "Date Modified")
 
+        controller.register_event_callback(
+            "selection.folder.changed",
+            self._on_folder_changed
+        )
         controller.register_event_callback(
             "selection.task.changed",
             self._on_task_changed
@@ -63,6 +67,10 @@ def get_index_by_filename(self, filename):
             return QtCore.QModelIndex()
         return self.indexFromItem(item)
 
+    def refresh(self):
+        if not self._published_mode:
+            self._fill_items()
+
     def _get_missing_context_item(self):
         if self._missing_context_item is None:
             message = "Select folder and task"
@@ -129,6 +137,11 @@ def _remove_empty_item(self):
         root_item.takeRow(self._empty_root_item.row())
         self._empty_item_used = False
 
+    def _on_folder_changed(self, event):
+        self._selected_folder_id = event["folder_id"]
+        if not self._published_mode:
+            self._fill_items()
+
     def _on_task_changed(self, event):
         self._selected_folder_id = event["folder_id"]
         self._selected_task_id = event["task_id"]
@@ -362,10 +375,13 @@ def _on_duplicate_pressed(self):
         self.duplicate_requested.emit()
 
     def _on_expected_selection_change(self, event):
-        if event["workfile_name_selected"]:
+        workfile_info = event["workfile"]
+        if not workfile_info["current"]:
             return
 
-        workfile_name = event["workfile_name"]
+        self._model.refresh()
+
+        workfile_name = workfile_info["name"]
         if (
             workfile_name is not None
             and workfile_name != self._get_selected_info()["filename"]
@@ -376,5 +392,5 @@ def _on_expected_selection_change(self, event):
                 self._view.setCurrentIndex(proxy_index)
 
         self._controller.expected_workfile_selected(
-            event["folder_id"], event["task_name"], workfile_name
+            event["folder"]["id"], event["task"]["name"], workfile_name
         )
diff --git a/openpype/tools/ayon_workfiles/widgets/folders_widget.py b/openpype/tools/ayon_workfiles/widgets/folders_widget.py
deleted file mode 100644
index b04f8e4098d..00000000000
--- a/openpype/tools/ayon_workfiles/widgets/folders_widget.py
+++ /dev/null
@@ -1,324 +0,0 @@
-import uuid
-import collections
-
-import qtawesome
-from qtpy import QtWidgets, QtGui, QtCore
-
-from openpype.tools.utils import (
-    RecursiveSortFilterProxyModel,
-    DeselectableTreeView,
-)
-
-from .constants import ITEM_ID_ROLE, ITEM_NAME_ROLE
-
-SENDER_NAME = "qt_folders_model"
-
-
-class FoldersRefreshThread(QtCore.QThread):
-    """Thread for refreshing folders.
-
-    Call controller to get folders and emit signal when finished.
-
-    Args:
-        controller (AbstractWorkfilesFrontend): The control object.
-    """
-
-    refresh_finished = QtCore.Signal(str)
-
-    def __init__(self, controller):
-        super(FoldersRefreshThread, self).__init__()
-        self._id = uuid.uuid4().hex
-        self._controller = controller
-        self._result = None
-
-    @property
-    def id(self):
-        """Thread id.
-
-        Returns:
-            str: Unique id of the thread.
-        """
-
-        return self._id
-
-    def run(self):
-        self._result = self._controller.get_folder_items(SENDER_NAME)
-        self.refresh_finished.emit(self.id)
-
-    def get_result(self):
-        return self._result
-
-
-class FoldersModel(QtGui.QStandardItemModel):
-    """Folders model which cares about refresh of folders.
-
-    Args:
-        controller (AbstractWorkfilesFrontend): The control object.
-    """
-
-    refreshed = QtCore.Signal()
-
-    def __init__(self, controller):
-        super(FoldersModel, self).__init__()
-
-        self._controller = controller
-        self._items_by_id = {}
-        self._parent_id_by_id = {}
-
-        self._refresh_threads = {}
-        self._current_refresh_thread = None
-
-        self._has_content = False
-        self._is_refreshing = False
-
-    @property
-    def is_refreshing(self):
-        """Model is refreshing.
-
-        Returns:
-            bool: True if model is refreshing.
-        """
-        return self._is_refreshing
-
-    @property
-    def has_content(self):
-        """Has at least one folder.
-
-        Returns:
-            bool: True if model has at least one folder.
-        """
-
-        return self._has_content
-
-    def clear(self):
-        self._items_by_id = {}
-        self._parent_id_by_id = {}
-        self._has_content = False
-        super(FoldersModel, self).clear()
-
-    def get_index_by_id(self, item_id):
-        """Get index by folder id.
-
-        Returns:
-            QtCore.QModelIndex: Index of the folder. Can be invalid if folder
-                is not available.
-        """
-        item = self._items_by_id.get(item_id)
-        if item is None:
-            return QtCore.QModelIndex()
-        return self.indexFromItem(item)
-
-    def refresh(self):
-        """Refresh folders items.
-
-        Refresh start thread because it can cause that controller can
-        start query from database if folders are not cached.
-        """
-
-        self._is_refreshing = True
-
-        thread = FoldersRefreshThread(self._controller)
-        self._current_refresh_thread = thread.id
-        self._refresh_threads[thread.id] = thread
-        thread.refresh_finished.connect(self._on_refresh_thread)
-        thread.start()
-
-    def _on_refresh_thread(self, thread_id):
-        """Callback when refresh thread is finished.
-
-        Technically can be running multiple refresh threads at the same time,
-        to avoid using values from wrong thread, we check if thread id is
-        current refresh thread id.
-
-        Folders are stored by id.
-
-        Args:
-            thread_id (str): Thread id.
-        """
-
-        thread = self._refresh_threads.pop(thread_id)
-        if thread_id != self._current_refresh_thread:
-            return
-
-        folder_items_by_id = thread.get_result()
-        if not folder_items_by_id:
-            if folder_items_by_id is not None:
-                self.clear()
-            self._is_refreshing = False
-            return
-
-        self._has_content = True
-
-        folder_ids = set(folder_items_by_id)
-        ids_to_remove = set(self._items_by_id) - folder_ids
-
-        folder_items_by_parent = collections.defaultdict(list)
-        for folder_item in folder_items_by_id.values():
-            folder_items_by_parent[folder_item.parent_id].append(folder_item)
-
-        hierarchy_queue = collections.deque()
-        hierarchy_queue.append(None)
-
-        while hierarchy_queue:
-            parent_id = hierarchy_queue.popleft()
-            folder_items = folder_items_by_parent[parent_id]
-            if parent_id is None:
-                parent_item = self.invisibleRootItem()
-            else:
-                parent_item = self._items_by_id[parent_id]
-
-            new_items = []
-            for folder_item in folder_items:
-                item_id = folder_item.entity_id
-                item = self._items_by_id.get(item_id)
-                if item is None:
-                    is_new = True
-                    item = QtGui.QStandardItem()
-                    item.setEditable(False)
-                else:
-                    is_new = self._parent_id_by_id[item_id] != parent_id
-
-                icon = qtawesome.icon(
-                    folder_item.icon_name,
-                    color=folder_item.icon_color,
-                )
-                item.setData(item_id, ITEM_ID_ROLE)
-                item.setData(folder_item.name, ITEM_NAME_ROLE)
-                item.setData(folder_item.label, QtCore.Qt.DisplayRole)
-                item.setData(icon, QtCore.Qt.DecorationRole)
-                if is_new:
-                    new_items.append(item)
-                self._items_by_id[item_id] = item
-                self._parent_id_by_id[item_id] = parent_id
-
-                hierarchy_queue.append(item_id)
-
-            if new_items:
-                parent_item.appendRows(new_items)
-
-        for item_id in ids_to_remove:
-            item = self._items_by_id[item_id]
-            parent_id = self._parent_id_by_id[item_id]
-            if parent_id is None:
-                parent_item = self.invisibleRootItem()
-            else:
-                parent_item = self._items_by_id[parent_id]
-            parent_item.takeChild(item.row())
-
-        for item_id in ids_to_remove:
-            self._items_by_id.pop(item_id)
-            self._parent_id_by_id.pop(item_id)
-
-        self._is_refreshing = False
-        self.refreshed.emit()
-
-
-class FoldersWidget(QtWidgets.QWidget):
-    """Folders widget.
-
-    Widget that handles folders view, model and selection.
-
-    Args:
-        controller (AbstractWorkfilesFrontend): The control object.
-        parent (QtWidgets.QWidget): The parent widget.
-    """
-
-    def __init__(self, controller, parent):
-        super(FoldersWidget, self).__init__(parent)
-
-        folders_view = DeselectableTreeView(self)
-        folders_view.setHeaderHidden(True)
-
-        folders_model = FoldersModel(controller)
-        folders_proxy_model = RecursiveSortFilterProxyModel()
-        folders_proxy_model.setSourceModel(folders_model)
-
-        folders_view.setModel(folders_proxy_model)
-
-        main_layout = QtWidgets.QHBoxLayout(self)
-        main_layout.setContentsMargins(0, 0, 0, 0)
-        main_layout.addWidget(folders_view, 1)
-
-        controller.register_event_callback(
-            "folders.refresh.finished",
-            self._on_folders_refresh_finished
-        )
-        controller.register_event_callback(
-            "controller.refresh.finished",
-            self._on_controller_refresh
-        )
-        controller.register_event_callback(
-            "expected_selection_changed",
-            self._on_expected_selection_change
-        )
-
-        selection_model = folders_view.selectionModel()
-        selection_model.selectionChanged.connect(self._on_selection_change)
-
-        folders_model.refreshed.connect(self._on_model_refresh)
-
-        self._controller = controller
-        self._folders_view = folders_view
-        self._folders_model = folders_model
-        self._folders_proxy_model = folders_proxy_model
-
-        self._expected_selection = None
-
-    def set_name_filter(self, name):
-        self._folders_proxy_model.setFilterFixedString(name)
-
-    def _clear(self):
-        self._folders_model.clear()
-
-    def _on_folders_refresh_finished(self, event):
-        if event["sender"] != SENDER_NAME:
-            self._folders_model.refresh()
-
-    def _on_controller_refresh(self):
-        self._update_expected_selection()
-
-    def _update_expected_selection(self, expected_data=None):
-        if expected_data is None:
-            expected_data = self._controller.get_expected_selection_data()
-
-        # We're done
-        if expected_data["folder_selected"]:
-            return
-
-        folder_id = expected_data["folder_id"]
-        self._expected_selection = folder_id
-        if not self._folders_model.is_refreshing:
-            self._set_expected_selection()
-
-    def _set_expected_selection(self):
-        folder_id = self._expected_selection
-        self._expected_selection = None
-        if (
-            folder_id is not None
-            and folder_id != self._get_selected_item_id()
-        ):
-            index = self._folders_model.get_index_by_id(folder_id)
-            if index.isValid():
-                proxy_index = self._folders_proxy_model.mapFromSource(index)
-                self._folders_view.setCurrentIndex(proxy_index)
-        self._controller.expected_folder_selected(folder_id)
-
-    def _on_model_refresh(self):
-        if self._expected_selection:
-            self._set_expected_selection()
-        self._folders_proxy_model.sort(0)
-
-    def _on_expected_selection_change(self, event):
-        self._update_expected_selection(event.data)
-
-    def _get_selected_item_id(self):
-        selection_model = self._folders_view.selectionModel()
-        for index in selection_model.selectedIndexes():
-            item_id = index.data(ITEM_ID_ROLE)
-            if item_id is not None:
-                return item_id
-        return None
-
-    def _on_selection_change(self):
-        item_id = self._get_selected_item_id()
-        self._controller.set_selected_folder(item_id)
diff --git a/openpype/tools/ayon_workfiles/widgets/side_panel.py b/openpype/tools/ayon_workfiles/widgets/side_panel.py
index 7f06576a000..5085f4701ec 100644
--- a/openpype/tools/ayon_workfiles/widgets/side_panel.py
+++ b/openpype/tools/ayon_workfiles/widgets/side_panel.py
@@ -66,7 +66,7 @@ def __init__(self, controller, parent):
         btn_note_save.clicked.connect(self._on_save_click)
 
         controller.register_event_callback(
-            "workarea.selection.changed", self._on_selection_change
+            "selection.workarea.changed", self._on_selection_change
         )
 
         self._details_input = details_input
diff --git a/openpype/tools/ayon_workfiles/widgets/tasks_widget.py b/openpype/tools/ayon_workfiles/widgets/tasks_widget.py
deleted file mode 100644
index 04f5b286b19..00000000000
--- a/openpype/tools/ayon_workfiles/widgets/tasks_widget.py
+++ /dev/null
@@ -1,420 +0,0 @@
-import uuid
-import qtawesome
-from qtpy import QtWidgets, QtGui, QtCore
-
-from openpype.style import get_disabled_entity_icon_color
-from openpype.tools.utils import DeselectableTreeView
-
-from .constants import (
-    ITEM_NAME_ROLE,
-    ITEM_ID_ROLE,
-    PARENT_ID_ROLE,
-)
-
-SENDER_NAME = "qt_tasks_model"
-
-
-class RefreshThread(QtCore.QThread):
-    """Thread for refreshing tasks.
-
-    Call controller to get tasks and emit signal when finished.
-
-    Args:
-        controller (AbstractWorkfilesFrontend): The control object.
-        folder_id (str): Folder id.
-    """
-
-    refresh_finished = QtCore.Signal(str)
-
-    def __init__(self, controller, folder_id):
-        super(RefreshThread, self).__init__()
-        self._id = uuid.uuid4().hex
-        self._controller = controller
-        self._folder_id = folder_id
-        self._result = None
-
-    @property
-    def id(self):
-        return self._id
-
-    def run(self):
-        self._result = self._controller.get_task_items(
-            self._folder_id, SENDER_NAME)
-        self.refresh_finished.emit(self.id)
-
-    def get_result(self):
-        return self._result
-
-
-class TasksModel(QtGui.QStandardItemModel):
-    """Tasks model which cares about refresh of tasks by folder id.
-
-    Args:
-        controller (AbstractWorkfilesFrontend): The control object.
-    """
-
-    refreshed = QtCore.Signal()
-
-    def __init__(self, controller):
-        super(TasksModel, self).__init__()
-
-        self._controller = controller
-
-        self._items_by_name = {}
-        self._has_content = False
-        self._is_refreshing = False
-
-        self._invalid_selection_item_used = False
-        self._invalid_selection_item = None
-        self._empty_tasks_item_used = False
-        self._empty_tasks_item = None
-
-        self._last_folder_id = None
-
-        self._refresh_threads = {}
-        self._current_refresh_thread = None
-
-        # Initial state
-        self._add_invalid_selection_item()
-
-    def clear(self):
-        self._items_by_name = {}
-        self._has_content = False
-        self._remove_invalid_items()
-        super(TasksModel, self).clear()
-
-    def refresh(self, folder_id):
-        """Refresh tasks for folder.
-
-        Args:
-            folder_id (Union[str, None]): Folder id.
-        """
-
-        self._refresh(folder_id)
-
-    def get_index_by_name(self, task_name):
-        """Find item by name and return its index.
-
-        Returns:
-            QtCore.QModelIndex: Index of item. Is invalid if task is not
-                found by name.
-        """
-
-        item = self._items_by_name.get(task_name)
-        if item is None:
-            return QtCore.QModelIndex()
-        return self.indexFromItem(item)
-
-    def get_last_folder_id(self):
-        """Get last refreshed folder id.
-
-        Returns:
-            Union[str, None]: Folder id.
-        """
-
-        return self._last_folder_id
-
-    def _get_invalid_selection_item(self):
-        if self._invalid_selection_item is None:
-            item = QtGui.QStandardItem("Select a folder")
-            item.setFlags(QtCore.Qt.NoItemFlags)
-            icon = qtawesome.icon(
-                "fa.times",
-                color=get_disabled_entity_icon_color()
-            )
-            item.setData(icon, QtCore.Qt.DecorationRole)
-            self._invalid_selection_item = item
-        return self._invalid_selection_item
-
-    def _get_empty_task_item(self):
-        if self._empty_tasks_item is None:
-            item = QtGui.QStandardItem("No task")
-            icon = qtawesome.icon(
-                "fa.exclamation-circle",
-                color=get_disabled_entity_icon_color()
-            )
-            item.setData(icon, QtCore.Qt.DecorationRole)
-            item.setFlags(QtCore.Qt.NoItemFlags)
-            self._empty_tasks_item = item
-        return self._empty_tasks_item
-
-    def _add_invalid_item(self, item):
-        self.clear()
-        root_item = self.invisibleRootItem()
-        root_item.appendRow(item)
-
-    def _remove_invalid_item(self, item):
-        root_item = self.invisibleRootItem()
-        root_item.takeRow(item.row())
-
-    def _remove_invalid_items(self):
-        self._remove_invalid_selection_item()
-        self._remove_empty_task_item()
-
-    def _add_invalid_selection_item(self):
-        if not self._invalid_selection_item_used:
-            self._add_invalid_item(self._get_invalid_selection_item())
-            self._invalid_selection_item_used = True
-
-    def _remove_invalid_selection_item(self):
-        if self._invalid_selection_item:
-            self._remove_invalid_item(self._get_invalid_selection_item())
-            self._invalid_selection_item_used = False
-
-    def _add_empty_task_item(self):
-        if not self._empty_tasks_item_used:
-            self._add_invalid_item(self._get_empty_task_item())
-            self._empty_tasks_item_used = True
-
-    def _remove_empty_task_item(self):
-        if self._empty_tasks_item_used:
-            self._remove_invalid_item(self._get_empty_task_item())
-            self._empty_tasks_item_used = False
-
-    def _refresh(self, folder_id):
-        self._is_refreshing = True
-        self._last_folder_id = folder_id
-        if not folder_id:
-            self._add_invalid_selection_item()
-            self._current_refresh_thread = None
-            self._is_refreshing = False
-            self.refreshed.emit()
-            return
-
-        thread = RefreshThread(self._controller, folder_id)
-        self._current_refresh_thread = thread.id
-        self._refresh_threads[thread.id] = thread
-        thread.refresh_finished.connect(self._on_refresh_thread)
-        thread.start()
-
-    def _on_refresh_thread(self, thread_id):
-        """Callback when refresh thread is finished.
-
-        Technically can be running multiple refresh threads at the same time,
-        to avoid using values from wrong thread, we check if thread id is
-        current refresh thread id.
-
-        Tasks are stored by name, so if a folder has same task name as
-        previously selected folder it keeps the selection.
-
-        Args:
-            thread_id (str): Thread id.
-        """
-
-        thread = self._refresh_threads.pop(thread_id)
-        if thread_id != self._current_refresh_thread:
-            return
-
-        task_items = thread.get_result()
-        # Task items are refreshed
-        if task_items is None:
-            return
-
-        # No tasks are available on folder
-        if not task_items:
-            self._add_empty_task_item()
-            return
-        self._remove_invalid_items()
-
-        new_items = []
-        new_names = set()
-        for task_item in task_items:
-            name = task_item.name
-            new_names.add(name)
-            item = self._items_by_name.get(name)
-            if item is None:
-                item = QtGui.QStandardItem()
-                item.setEditable(False)
-                new_items.append(item)
-                self._items_by_name[name] = item
-
-            # TODO cache locally
-            icon = qtawesome.icon(
-                task_item.icon_name,
-                color=task_item.icon_color,
-            )
-            item.setData(task_item.label, QtCore.Qt.DisplayRole)
-            item.setData(name, ITEM_NAME_ROLE)
-            item.setData(task_item.id, ITEM_ID_ROLE)
-            item.setData(task_item.parent_id, PARENT_ID_ROLE)
-            item.setData(icon, QtCore.Qt.DecorationRole)
-
-        root_item = self.invisibleRootItem()
-
-        for name in set(self._items_by_name) - new_names:
-            item = self._items_by_name.pop(name)
-            root_item.removeRow(item.row())
-
-        if new_items:
-            root_item.appendRows(new_items)
-
-        self._has_content = root_item.rowCount() > 0
-        self._is_refreshing = False
-        self.refreshed.emit()
-
-    @property
-    def is_refreshing(self):
-        """Model is refreshing.
-
-        Returns:
-            bool: Model is refreshing
-        """
-
-        return self._is_refreshing
-
-    @property
-    def has_content(self):
-        """Model has content.
-
-        Returns:
-            bools: Have at least one task.
-        """
-
-        return self._has_content
-
-    def headerData(self, section, orientation, role):
-        # Show nice labels in the header
-        if (
-            role == QtCore.Qt.DisplayRole
-            and orientation == QtCore.Qt.Horizontal
-        ):
-            if section == 0:
-                return "Tasks"
-
-        return super(TasksModel, self).headerData(
-            section, orientation, role
-        )
-
-
-class TasksWidget(QtWidgets.QWidget):
-    """Tasks widget.
-
-    Widget that handles tasks view, model and selection.
-
-    Args:
-        controller (AbstractWorkfilesFrontend): Workfiles controller.
-    """
-
-    def __init__(self, controller, parent):
-        super(TasksWidget, self).__init__(parent)
-
-        tasks_view = DeselectableTreeView(self)
-        tasks_view.setIndentation(0)
-
-        tasks_model = TasksModel(controller)
-        tasks_proxy_model = QtCore.QSortFilterProxyModel()
-        tasks_proxy_model.setSourceModel(tasks_model)
-
-        tasks_view.setModel(tasks_proxy_model)
-
-        main_layout = QtWidgets.QHBoxLayout(self)
-        main_layout.setContentsMargins(0, 0, 0, 0)
-        main_layout.addWidget(tasks_view, 1)
-
-        controller.register_event_callback(
-            "tasks.refresh.finished",
-            self._on_tasks_refresh_finished
-        )
-        controller.register_event_callback(
-            "selection.folder.changed",
-            self._folder_selection_changed
-        )
-        controller.register_event_callback(
-            "expected_selection_changed",
-            self._on_expected_selection_change
-        )
-
-        selection_model = tasks_view.selectionModel()
-        selection_model.selectionChanged.connect(self._on_selection_change)
-
-        tasks_model.refreshed.connect(self._on_tasks_model_refresh)
-
-        self._controller = controller
-        self._tasks_view = tasks_view
-        self._tasks_model = tasks_model
-        self._tasks_proxy_model = tasks_proxy_model
-
-        self._selected_folder_id = None
-
-        self._expected_selection_data = None
-
-    def _clear(self):
-        self._tasks_model.clear()
-
-    def _on_tasks_refresh_finished(self, event):
-        """Tasks were refreshed in controller.
-
-        Ignore if refresh was triggered by tasks model, or refreshed folder is
-        not the same as currently selected folder.
-
-        Args:
-            event (Event): Event object.
-        """
-
-        # Refresh only if current folder id is the same
-        if (
-            event["sender"] == SENDER_NAME
-            or event["folder_id"] != self._selected_folder_id
-        ):
-            return
-        self._tasks_model.refresh(self._selected_folder_id)
-
-    def _folder_selection_changed(self, event):
-        self._selected_folder_id = event["folder_id"]
-        self._tasks_model.refresh(self._selected_folder_id)
-
-    def _on_tasks_model_refresh(self):
-        if not self._set_expected_selection():
-            self._on_selection_change()
-        self._tasks_proxy_model.sort(0)
-
-    def _set_expected_selection(self):
-        if self._expected_selection_data is None:
-            return False
-        folder_id = self._expected_selection_data["folder_id"]
-        task_name = self._expected_selection_data["task_name"]
-        self._expected_selection_data = None
-        model_folder_id = self._tasks_model.get_last_folder_id()
-        if folder_id != model_folder_id:
-            return False
-        if task_name is not None:
-            index = self._tasks_model.get_index_by_name(task_name)
-            if index.isValid():
-                proxy_index = self._tasks_proxy_model.mapFromSource(index)
-                self._tasks_view.setCurrentIndex(proxy_index)
-        self._controller.expected_task_selected(folder_id, task_name)
-        return True
-
-    def _on_expected_selection_change(self, event):
-        if event["task_selected"] or not event["folder_selected"]:
-            return
-
-        model_folder_id = self._tasks_model.get_last_folder_id()
-        folder_id = event["folder_id"]
-        self._expected_selection_data = {
-            "task_name": event["task_name"],
-            "folder_id": folder_id,
-        }
-
-        if folder_id != model_folder_id or self._tasks_model.is_refreshing:
-            return
-        self._set_expected_selection()
-
-    def _get_selected_item_ids(self):
-        selection_model = self._tasks_view.selectionModel()
-        for index in selection_model.selectedIndexes():
-            task_id = index.data(ITEM_ID_ROLE)
-            task_name = index.data(ITEM_NAME_ROLE)
-            parent_id = index.data(PARENT_ID_ROLE)
-            if task_name is not None:
-                return parent_id, task_id, task_name
-        return self._selected_folder_id, None, None
-
-    def _on_selection_change(self):
-        # Don't trigger task change during refresh
-        #   - a task was deselected if that happens
-        #   - can cause crash triggered during tasks refreshing
-        if self._tasks_model.is_refreshing:
-            return
-        parent_id, task_id, task_name = self._get_selected_item_ids()
-        self._controller.set_selected_task(parent_id, task_id, task_name)
diff --git a/openpype/tools/ayon_workfiles/widgets/window.py b/openpype/tools/ayon_workfiles/widgets/window.py
index 6218d2dd06e..eb2f2bc1c72 100644
--- a/openpype/tools/ayon_workfiles/widgets/window.py
+++ b/openpype/tools/ayon_workfiles/widgets/window.py
@@ -5,32 +5,16 @@
     PlaceholderLineEdit,
     MessageOverlayObject,
 )
-from openpype.tools.utils.lib import get_qta_icon_by_name_and_color
 
+from openpype.tools.ayon_utils.widgets import FoldersWidget, TasksWidget
 from openpype.tools.ayon_workfiles.control import BaseWorkfileController
+from openpype.tools.utils import GoToCurrentButton, RefreshButton
 
 from .side_panel import SidePanelWidget
-from .folders_widget import FoldersWidget
-from .tasks_widget import TasksWidget
 from .files_widget import FilesWidget
 from .utils import BaseOverlayFrame
 
 
-# TODO move to utils
-# from openpype.tools.utils.lib import (
-#     get_refresh_icon, get_go_to_current_icon)
-def get_refresh_icon():
-    return get_qta_icon_by_name_and_color(
-        "fa.refresh", style.get_default_tools_icon_color()
-    )
-
-
-def get_go_to_current_icon():
-    return get_qta_icon_by_name_and_color(
-        "fa.arrow-down", style.get_default_tools_icon_color()
-    )
-
-
 class InvalidHostOverlay(BaseOverlayFrame):
     def __init__(self, parent):
         super(InvalidHostOverlay, self).__init__(parent)
@@ -80,7 +64,7 @@ def __init__(self, controller=None, parent=None):
 
         self._default_window_flags = flags
 
-        self._folder_widget = None
+        self._folders_widget = None
         self._folder_filter_input = None
 
         self._files_widget = None
@@ -100,7 +84,9 @@ def __init__(self, controller=None, parent=None):
         home_body_widget = QtWidgets.QWidget(home_page_widget)
 
         col_1_widget = self._create_col_1_widget(controller, parent)
-        tasks_widget = TasksWidget(controller, home_body_widget)
+        tasks_widget = TasksWidget(
+            controller, home_body_widget, handle_expected_selection=True
+        )
         col_3_widget = self._create_col_3_widget(controller, home_body_widget)
         side_panel = SidePanelWidget(controller, home_body_widget)
 
@@ -151,11 +137,11 @@ def __init__(self, controller=None, parent=None):
             self._on_open_finished
         )
         controller.register_event_callback(
-            "controller.refresh.started",
+            "controller.reset.started",
             self._on_controller_refresh_started,
         )
         controller.register_event_callback(
-            "controller.refresh.finished",
+            "controller.reset.finished",
             self._on_controller_refresh_finished,
         )
 
@@ -188,19 +174,12 @@ def _create_col_1_widget(self, controller, parent):
         folder_filter_input = PlaceholderLineEdit(header_widget)
         folder_filter_input.setPlaceholderText("Filter folders..")
 
-        go_to_current_btn = QtWidgets.QPushButton(header_widget)
-        go_to_current_btn.setIcon(get_go_to_current_icon())
-        go_to_current_btn_sp = go_to_current_btn.sizePolicy()
-        go_to_current_btn_sp.setVerticalPolicy(QtWidgets.QSizePolicy.Minimum)
-        go_to_current_btn.setSizePolicy(go_to_current_btn_sp)
+        go_to_current_btn = GoToCurrentButton(header_widget)
+        refresh_btn = RefreshButton(header_widget)
 
-        refresh_btn = QtWidgets.QPushButton(header_widget)
-        refresh_btn.setIcon(get_refresh_icon())
-        refresh_btn_sp = refresh_btn.sizePolicy()
-        refresh_btn_sp.setVerticalPolicy(QtWidgets.QSizePolicy.Minimum)
-        refresh_btn.setSizePolicy(refresh_btn_sp)
-
-        folder_widget = FoldersWidget(controller, col_widget)
+        folder_widget = FoldersWidget(
+            controller, col_widget, handle_expected_selection=True
+        )
 
         header_layout = QtWidgets.QHBoxLayout(header_widget)
         header_layout.setContentsMargins(0, 0, 0, 0)
@@ -218,7 +197,7 @@ def _create_col_1_widget(self, controller, parent):
         refresh_btn.clicked.connect(self._on_refresh_clicked)
 
         self._folder_filter_input = folder_filter_input
-        self._folder_widget = folder_widget
+        self._folders_widget = folder_widget
 
         return col_widget
 
@@ -300,7 +279,7 @@ def ensure_visible(self, use_context=True, save=True, on_top=False):
     def refresh(self):
         """Trigger refresh of workfiles tool controller."""
 
-        self._controller.refresh()
+        self._controller.reset()
 
     def showEvent(self, event):
         super(WorkfilesToolWindow, self).showEvent(event)
@@ -338,7 +317,7 @@ def _on_published_checkbox_changed(self):
         self._side_panel.set_published_mode(published_mode)
 
     def _on_folder_filter_change(self, text):
-        self._folder_widget.set_name_filter(text)
+        self._folders_widget.set_name_filter(text)
 
     def _on_go_to_current_clicked(self):
         self._controller.go_to_current_context()
@@ -357,6 +336,10 @@ def _on_controller_refresh_finished(self):
         if not self._host_is_valid:
             return
 
+        self._folders_widget.set_project_name(
+            self._controller.get_current_project_name()
+        )
+
     def _on_save_as_finished(self, event):
         if event["failed"]:
             self._overlay_messages_widget.add_message(
diff --git a/openpype/version.py b/openpype/version.py
index 611fdc82cea..b7394c203d0 100644
--- a/openpype/version.py
+++ b/openpype/version.py
@@ -1,3 +1,3 @@
 # -*- coding: utf-8 -*-
 """Package declaring Pype version."""
-__version__ = "3.17.6-nightly.2"
+__version__ = "3.17.6-nightly.3"
diff --git a/server_addon/max/server/settings/create_review_settings.py b/server_addon/max/server/settings/create_review_settings.py
new file mode 100644
index 00000000000..43dac0730a1
--- /dev/null
+++ b/server_addon/max/server/settings/create_review_settings.py
@@ -0,0 +1,93 @@
+from pydantic import Field
+
+from ayon_server.settings import BaseSettingsModel
+
+
+def image_format_enum():
+    """Return enumerator for image output formats."""
+    return [
+        {"label": "exr", "value": "exr"},
+        {"label": "jpg", "value": "jpg"},
+        {"label": "png", "value": "png"},
+        {"label": "tga", "value": "tga"}
+    ]
+
+
+def visual_style_enum():
+    """Return enumerator for viewport visual style."""
+    return [
+        {"label": "Realistic", "value": "Realistic"},
+        {"label": "Shaded", "value": "Shaded"},
+        {"label": "Facets", "value": "Facets"},
+        {"label": "ConsistentColors",
+         "value": "ConsistentColors"},
+        {"label": "Wireframe", "value": "Wireframe"},
+        {"label": "BoundingBox", "value": "BoundingBox"},
+        {"label": "Ink", "value": "Ink"},
+        {"label": "ColorInk", "value": "ColorInk"},
+        {"label": "Acrylic", "value": "Acrylic"},
+        {"label": "Tech", "value": "Tech"},
+        {"label": "Graphite", "value": "Graphite"},
+        {"label": "ColorPencil", "value": "ColorPencil"},
+        {"label": "Pastel", "value": "Pastel"},
+        {"label": "Clay", "value": "Clay"},
+        {"label": "ModelAssist", "value": "ModelAssist"}
+    ]
+
+
+def preview_preset_enum():
+    """Return enumerator for viewport visual preset."""
+    return [
+        {"label": "Quality", "value": "Quality"},
+        {"label": "Standard", "value": "Standard"},
+        {"label": "Performance", "value": "Performance"},
+        {"label": "DXMode", "value": "DXMode"},
+        {"label": "Customize", "value": "Customize"},
+    ]
+
+
+def anti_aliasing_enum():
+    """Return enumerator for viewport anti-aliasing."""
+    return [
+        {"label": "None", "value": "None"},
+        {"label": "2X", "value": "2X"},
+        {"label": "4X", "value": "4X"},
+        {"label": "8X", "value": "8X"}
+    ]
+
+
+class CreateReviewModel(BaseSettingsModel):
+    review_width: int = Field(1920, title="Review Width")
+    review_height: int = Field(1080, title="Review Height")
+    percentSize: float = Field(100.0, title="Percent of Output")
+    keep_images: bool = Field(False, title="Keep Image Sequences")
+    image_format: str = Field(
+        enum_resolver=image_format_enum,
+        title="Image Format Options"
+    )
+    visual_style: str = Field(
+        enum_resolver=visual_style_enum,
+        title="Preference"
+    )
+    viewport_preset: str = Field(
+        enum_resolver=preview_preset_enum,
+        title="Preview Preset"
+    )
+    anti_aliasing: str = Field(
+        enum_resolver=anti_aliasing_enum,
+        title="Anti-aliasing Quality"
+    )
+    vp_texture: bool = Field(True, title="Viewport Texture")
+
+
+DEFAULT_CREATE_REVIEW_SETTINGS = {
+    "review_width": 1920,
+    "review_height": 1080,
+    "percentSize": 100.0,
+    "keep_images": False,
+    "image_format": "png",
+    "visual_style": "Realistic",
+    "viewport_preset": "Quality",
+    "anti_aliasing": "None",
+    "vp_texture": True
+}
diff --git a/server_addon/max/server/settings/main.py b/server_addon/max/server/settings/main.py
index 7f4561cbb1f..ea6a11915af 100644
--- a/server_addon/max/server/settings/main.py
+++ b/server_addon/max/server/settings/main.py
@@ -4,6 +4,9 @@
 from .render_settings import (
     RenderSettingsModel, DEFAULT_RENDER_SETTINGS
 )
+from .create_review_settings import (
+    CreateReviewModel, DEFAULT_CREATE_REVIEW_SETTINGS
+)
 from .publishers import (
     PublishersModel, DEFAULT_PUBLISH_SETTINGS
 )
@@ -29,6 +32,10 @@ class MaxSettings(BaseSettingsModel):
         default_factory=RenderSettingsModel,
         title="Render Settings"
     )
+    CreateReview: CreateReviewModel = Field(
+        default_factory=CreateReviewModel,
+        title="Create Review"
+    )
     PointCloud: PointCloudSettings = Field(
         default_factory=PointCloudSettings,
         title="Point Cloud"
@@ -40,6 +47,7 @@ class MaxSettings(BaseSettingsModel):
 
 DEFAULT_VALUES = {
     "RenderSettings": DEFAULT_RENDER_SETTINGS,
+    "CreateReview": DEFAULT_CREATE_REVIEW_SETTINGS,
     "PointCloud": {
         "attribute": [
             {"name": "Age", "value": "age"},
diff --git a/server_addon/max/server/version.py b/server_addon/max/server/version.py
index 485f44ac21b..b3f4756216d 100644
--- a/server_addon/max/server/version.py
+++ b/server_addon/max/server/version.py
@@ -1 +1 @@
-__version__ = "0.1.1"
+__version__ = "0.1.2"
diff --git a/server_addon/nuke/server/settings/imageio.py b/server_addon/nuke/server/settings/imageio.py
index 15ccd4e89ae..19ad5ff24aa 100644
--- a/server_addon/nuke/server/settings/imageio.py
+++ b/server_addon/nuke/server/settings/imageio.py
@@ -213,16 +213,16 @@ class ImageIOSettings(BaseSettingsModel):
 
 DEFAULT_IMAGEIO_SETTINGS = {
     "viewer": {
-        "viewerProcess": "sRGB"
+        "viewerProcess": "sRGB (default)"
     },
     "baking": {
-        "viewerProcess": "rec709"
+        "viewerProcess": "rec709 (default)"
     },
     "workfile": {
-        "color_management": "Nuke",
+        "color_management": "OCIO",
         "native_ocio_config": "nuke-default",
-        "working_space": "linear",
-        "thumbnail_space": "sRGB",
+        "working_space": "scene_linear",
+        "thumbnail_space": "sRGB (default)",
     },
     "nodes": {
         "required_nodes": [
@@ -269,7 +269,7 @@ class ImageIOSettings(BaseSettingsModel):
                     {
                         "type": "text",
                         "name": "colorspace",
-                        "text": "linear"
+                        "text": "scene_linear"
                     },
                     {
                         "type": "boolean",
@@ -321,7 +321,7 @@ class ImageIOSettings(BaseSettingsModel):
                     {
                         "type": "text",
                         "name": "colorspace",
-                        "text": "linear"
+                        "text": "scene_linear"
                     },
                     {
                         "type": "boolean",
@@ -368,7 +368,7 @@ class ImageIOSettings(BaseSettingsModel):
                     {
                         "type": "text",
                         "name": "colorspace",
-                        "text": "sRGB"
+                        "text": "texture_paint"
                     },
                     {
                         "type": "boolean",
diff --git a/server_addon/nuke/server/version.py b/server_addon/nuke/server/version.py
index bbab0242f6a..1276d0254ff 100644
--- a/server_addon/nuke/server/version.py
+++ b/server_addon/nuke/server/version.py
@@ -1 +1 @@
-__version__ = "0.1.4"
+__version__ = "0.1.5"