diff --git a/.readthedocs.yml b/.readthedocs.yml
index 8f1e3118d0..6b64320875 100644
--- a/.readthedocs.yml
+++ b/.readthedocs.yml
@@ -20,7 +20,7 @@ build:
     - asdf install uv 0.2.9
     - asdf global uv 0.2.9
     post_install:
-    - VIRTUAL_ENV=$READTHEDOCS_VIRTUALENV_PATH uv pip install .[docs,tests,rest,atomic_tools]
+    - VIRTUAL_ENV=$READTHEDOCS_VIRTUALENV_PATH uv pip install .[docs,tests,rest,atomic_tools] --preview
 
 # Let the build fail if there are any warnings
 sphinx:
diff --git a/docs/source/topics/transport.rst b/docs/source/topics/transport.rst
index 45706b94a7..d95cbeaac2 100644
--- a/docs/source/topics/transport.rst
+++ b/docs/source/topics/transport.rst
@@ -24,15 +24,15 @@ The generic transport class contains a set of minimal methods that an implementa
 If not, a ``NotImplementedError`` will be raised, interrupting the managing of the calculation or whatever is using the transport plugin.
 
 As for the general functioning of the plugin, the :py:meth:`~aiida.transports.transport.Transport.__init__` method is used only to initialize the class instance, without actually opening the transport channel.
-The connection must be opened only by the :py:meth:`~aiida.transports.transport.Transport.__enter__` method, (and closed by :py:meth:`~aiida.transports.transport.Transport.__exit__`).
-The :py:meth:`~aiida.transports.transport.Transport.__enter__` method lets you use the transport class using the ``with`` statement (see `python docs <https://docs.python.org/3/reference/compound_stmts.html#with>`_), in a way similar to the following:
+The connection must be opened only by the :py:meth:`~aiida.transports.transport._BaseTransport.__enter__` method, (and closed by :py:meth:`~aiida.transports.transport._BaseTransport.__exit__`).
+The :py:meth:`~aiida.transports.transport._BaseTransport.__enter__` method lets you use the transport class using the ``with`` statement (see `python docs <https://docs.python.org/3/reference/compound_stmts.html#with>`_), in a way similar to the following:
 
 .. code-block:: python
 
     with TransportPlugin() as transport:
         transport.some_method()
 
-To ensure this, for example, the local plugin uses a hidden boolean variable ``_is_open`` that is set when the :py:meth:`~aiida.transports.transport.Transport.__enter__` and :py:meth:`~aiida.transports.transport.Transport.__exit__` methods are called.
+To ensure this, for example, the local plugin uses a hidden boolean variable ``_is_open`` that is set when the :py:meth:`~aiida.transports.transport._BaseTransport.__enter__` and :py:meth:`~aiida.transports.transport._BaseTransport.__exit__` methods are called.
 The ``ssh`` logic is instead given by the property sftp.
 
 The other functions that require some care are the copying functions, called using the following terminology:
diff --git a/environment.yml b/environment.yml
index ad80dd3416..4c94f31457 100644
--- a/environment.yml
+++ b/environment.yml
@@ -8,6 +8,7 @@ dependencies:
 - python~=3.9
 - alembic~=1.2
 - archive-path~=0.4.2
+- asyncssh~=2.19.0
 - circus~=0.18.0
 - click-spinner~=0.1.8
 - click~=8.1
@@ -22,7 +23,7 @@ dependencies:
 - importlib-metadata~=6.0
 - numpy~=1.21
 - paramiko~=3.0
-- plumpy~=0.22.3
+- plumpy~=0.23.0
 - pgsu~=0.3.0
 - psutil~=5.6
 - psycopg[binary]~=3.0
diff --git a/pyproject.toml b/pyproject.toml
index 9461b7a46a..0932188a03 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -20,6 +20,7 @@ classifiers = [
 dependencies = [
   'alembic~=1.2',
   'archive-path~=0.4.2',
+  "asyncssh~=2.19.0",
   'circus~=0.18.0',
   'click-spinner~=0.1.8',
   'click~=8.1',
@@ -34,7 +35,7 @@ dependencies = [
   'importlib-metadata~=6.0',
   'numpy~=1.21',
   'paramiko~=3.0',
-  'plumpy~=0.22.3',
+  'plumpy~=0.23.0',
   'pgsu~=0.3.0',
   'psutil~=5.6',
   'psycopg[binary]~=3.0',
@@ -175,6 +176,7 @@ requires-python = '>=3.9'
 [project.entry-points.'aiida.transports']
 'core.local' = 'aiida.transports.plugins.local:LocalTransport'
 'core.ssh' = 'aiida.transports.plugins.ssh:SshTransport'
+'core.ssh_async' = 'aiida.transports.plugins.ssh_async:AsyncSshTransport'
 'core.ssh_auto' = 'aiida.transports.plugins.ssh_auto:SshAutoTransport'
 
 [project.entry-points.'aiida.workflows']
@@ -308,6 +310,7 @@ module = 'tests.*'
 ignore_missing_imports = true
 module = [
   'ase.*',
+  'asyncssh.*',
   'bpython.*',
   'bs4.*',
   'CifFile.*',
diff --git a/src/aiida/calculations/monitors/base.py b/src/aiida/calculations/monitors/base.py
index 459f4eba9d..87d5054915 100644
--- a/src/aiida/calculations/monitors/base.py
+++ b/src/aiida/calculations/monitors/base.py
@@ -4,12 +4,13 @@
 
 import tempfile
 from pathlib import Path
+from typing import Union
 
 from aiida.orm import CalcJobNode
-from aiida.transports import Transport
+from aiida.transports import AsyncTransport, Transport
 
 
-def always_kill(node: CalcJobNode, transport: Transport) -> str | None:
+def always_kill(node: CalcJobNode, transport: Union['Transport', 'AsyncTransport']) -> str | None:
     """Retrieve and inspect files in working directory of job to determine whether the job should be killed.
 
     This particular implementation is just for demonstration purposes and will kill the job as long as there is a
diff --git a/src/aiida/engine/daemon/execmanager.py b/src/aiida/engine/daemon/execmanager.py
index 73c30cab61..ece32173f9 100644
--- a/src/aiida/engine/daemon/execmanager.py
+++ b/src/aiida/engine/daemon/execmanager.py
@@ -35,7 +35,7 @@
 from aiida.schedulers.datastructures import JobState
 
 if TYPE_CHECKING:
-    from aiida.transports import Transport
+    from aiida.transports import AsyncTransport, Transport
 
 REMOTE_WORK_DIRECTORY_LOST_FOUND = 'lost+found'
 
@@ -62,9 +62,9 @@ def _find_data_node(inputs: MappingType[str, Any], uuid: str) -> Optional[Node]:
     return data_node
 
 
-def upload_calculation(
+async def upload_calculation(
     node: CalcJobNode,
-    transport: Transport,
+    transport: Union['Transport', 'AsyncTransport'],
     calc_info: CalcInfo,
     folder: Folder,
     inputs: Optional[MappingType[str, Any]] = None,
@@ -105,7 +105,7 @@ def upload_calculation(
     if dry_run:
         workdir = Path(folder.abspath)
     else:
-        remote_user = transport.whoami()
+        remote_user = await transport.whoami_async()
         remote_working_directory = computer.get_workdir().format(username=remote_user)
         if not remote_working_directory.strip():
             raise exceptions.ConfigurationError(
@@ -114,13 +114,13 @@ def upload_calculation(
             )
 
         # If it already exists, no exception is raised
-        if not transport.path_exists(remote_working_directory):
+        if not await transport.path_exists_async(remote_working_directory):
             logger.debug(
                 f'[submission of calculation {node.pk}] Path '
                 f'{remote_working_directory} does not exist, trying to create it'
             )
             try:
-                transport.makedirs(remote_working_directory)
+                await transport.makedirs_async(remote_working_directory)
             except EnvironmentError as exc:
                 raise exceptions.ConfigurationError(
                     f'[submission of calculation {node.pk}] '
@@ -133,14 +133,14 @@ def upload_calculation(
         # and I do not have to know the logic, but I just need to
         # read the absolute path from the calculation properties.
         workdir = Path(remote_working_directory).joinpath(calc_info.uuid[:2], calc_info.uuid[2:4])
-        transport.makedirs(str(workdir), ignore_existing=True)
+        await transport.makedirs_async(workdir, ignore_existing=True)
 
         try:
             # The final directory may already exist, most likely because this function was already executed once, but
             # failed and as a result was rescheduled by the engine. In this case it would be fine to delete the folder
             # and create it from scratch, except that we cannot be sure that this the actual case. Therefore, to err on
             # the safe side, we move the folder to the lost+found directory before recreating the folder from scratch
-            transport.mkdir(str(workdir.joinpath(calc_info.uuid[4:])))
+            await transport.mkdir_async(workdir.joinpath(calc_info.uuid[4:]))
         except OSError:
             # Move the existing directory to lost+found, log a warning and create a clean directory anyway
             path_existing = os.path.join(str(workdir), calc_info.uuid[4:])
@@ -151,12 +151,12 @@ def upload_calculation(
             )
 
             # Make sure the lost+found directory exists, then copy the existing folder there and delete the original
-            transport.mkdir(path_lost_found, ignore_existing=True)
-            transport.copytree(path_existing, path_target)
-            transport.rmtree(path_existing)
+            await transport.mkdir_async(path_lost_found, ignore_existing=True)
+            await transport.copytree_async(path_existing, path_target)
+            await transport.rmtree_async(path_existing)
 
             # Now we can create a clean folder for this calculation
-            transport.mkdir(str(workdir.joinpath(calc_info.uuid[4:])))
+            await transport.mkdir_async(workdir.joinpath(calc_info.uuid[4:]))
         finally:
             workdir = workdir.joinpath(calc_info.uuid[4:])
 
@@ -171,11 +171,11 @@ def upload_calculation(
             # Note: this will possibly overwrite files
             for root, dirnames, filenames in code.base.repository.walk():
                 # mkdir of root
-                transport.makedirs(str(workdir.joinpath(root)), ignore_existing=True)
+                await transport.makedirs_async(workdir.joinpath(root), ignore_existing=True)
 
                 # remotely mkdir first
                 for dirname in dirnames:
-                    transport.makedirs(str(workdir.joinpath(root, dirname)), ignore_existing=True)
+                    await transport.makedirs_async(workdir.joinpath(root, dirname), ignore_existing=True)
 
                 # Note, once #2579 is implemented, use the `node.open` method instead of the named temporary file in
                 # combination with the new `Transport.put_object_from_filelike`
@@ -185,11 +185,11 @@ def upload_calculation(
                         content = code.base.repository.get_object_content(Path(root) / filename, mode='rb')
                         handle.write(content)
                         handle.flush()
-                        transport.put(handle.name, str(workdir.joinpath(root, filename)))
+                        await transport.put_async(handle.name, workdir.joinpath(root, filename))
             if code.filepath_executable.is_absolute():
-                transport.chmod(str(code.filepath_executable), 0o755)  # rwxr-xr-x
+                await transport.chmod_async(code.filepath_executable, 0o755)  # rwxr-xr-x
             else:
-                transport.chmod(str(workdir.joinpath(code.filepath_executable)), 0o755)  # rwxr-xr-x
+                await transport.chmod_async(workdir.joinpath(code.filepath_executable), 0o755)  # rwxr-xr-x
 
     # local_copy_list is a list of tuples, each with (uuid, dest_path, rel_path)
     # NOTE: validation of these lists are done inside calculation.presubmit()
@@ -206,15 +206,15 @@ def upload_calculation(
 
     for file_copy_operation in file_copy_operation_order:
         if file_copy_operation is FileCopyOperation.LOCAL:
-            _copy_local_files(logger, node, transport, inputs, local_copy_list, workdir=workdir)
+            await _copy_local_files(logger, node, transport, inputs, local_copy_list, workdir=workdir)
         elif file_copy_operation is FileCopyOperation.REMOTE:
             if not dry_run:
-                _copy_remote_files(
+                await _copy_remote_files(
                     logger, node, computer, transport, remote_copy_list, remote_symlink_list, workdir=workdir
                 )
         elif file_copy_operation is FileCopyOperation.SANDBOX:
             if not dry_run:
-                _copy_sandbox_files(logger, node, transport, folder, workdir=workdir)
+                await _copy_sandbox_files(logger, node, transport, folder, workdir=workdir)
         else:
             raise RuntimeError(f'file copy operation {file_copy_operation} is not yet implemented.')
 
@@ -279,7 +279,7 @@ def upload_calculation(
     return None
 
 
-def _copy_remote_files(logger, node, computer, transport, remote_copy_list, remote_symlink_list, workdir: Path):
+async def _copy_remote_files(logger, node, computer, transport, remote_copy_list, remote_symlink_list, workdir: Path):
     """Perform the copy instructions of the ``remote_copy_list`` and ``remote_symlink_list``."""
     for remote_computer_uuid, remote_abs_path, dest_rel_path in remote_copy_list:
         if remote_computer_uuid == computer.uuid:
@@ -288,7 +288,7 @@ def _copy_remote_files(logger, node, computer, transport, remote_copy_list, remo
                 f'remotely, directly on the machine {computer.label}'
             )
             try:
-                transport.copy(remote_abs_path, str(workdir.joinpath(dest_rel_path)))
+                await transport.copy_async(remote_abs_path, workdir.joinpath(dest_rel_path))
             except FileNotFoundError:
                 logger.warning(
                     f'[submission of calculation {node.pk}] Unable to copy remote '
@@ -314,8 +314,8 @@ def _copy_remote_files(logger, node, computer, transport, remote_copy_list, remo
             )
             remote_dirname = Path(dest_rel_path).parent
             try:
-                transport.makedirs(str(workdir.joinpath(remote_dirname)), ignore_existing=True)
-                transport.symlink(remote_abs_path, str(workdir.joinpath(dest_rel_path)))
+                await transport.makedirs_async(workdir.joinpath(remote_dirname), ignore_existing=True)
+                await transport.symlink_async(remote_abs_path, workdir.joinpath(dest_rel_path))
             except OSError:
                 logger.warning(
                     f'[submission of calculation {node.pk}] Unable to create remote symlink '
@@ -328,7 +328,7 @@ def _copy_remote_files(logger, node, computer, transport, remote_copy_list, remo
             )
 
 
-def _copy_local_files(logger, node, transport, inputs, local_copy_list, workdir: Path):
+async def _copy_local_files(logger, node, transport, inputs, local_copy_list, workdir: Path):
     """Perform the copy instructions of the ``local_copy_list``."""
     for uuid, filename, target in local_copy_list:
         logger.debug(f'[submission of calculation {node.uuid}] copying local file/folder to {target}')
@@ -356,14 +356,14 @@ def _copy_local_files(logger, node, transport, inputs, local_copy_list, workdir:
             # The logic below takes care of an edge case where the source is a file but the target is a directory. In
             # this case, the v2.5.1 implementation would raise an `IsADirectoryError` exception, because it would try
             # to open the directory in the sandbox folder as a file when writing the contents.
-            if file_type_source == FileType.FILE and target and transport.isdir(str(workdir.joinpath(target))):
+            if file_type_source == FileType.FILE and target and await transport.isdir_async(workdir.joinpath(target)):
                 raise IsADirectoryError
 
             # In case the source filename is specified and it is a directory that already exists in the remote, we
             # want to avoid nested directories in the target path to replicate the behavior of v2.5.1. This is done by
             # setting the target filename to '.', which means the contents of the node will be copied in the top level
             # of the temporary directory, whose contents are then copied into the target directory.
-            if filename and transport.isdir(str(workdir.joinpath(filename))):
+            if filename and await transport.isdir_async(workdir.joinpath(filename)):
                 filename_target = '.'
 
             filepath_target = (dirpath / filename_target).resolve().absolute()
@@ -372,9 +372,9 @@ def _copy_local_files(logger, node, transport, inputs, local_copy_list, workdir:
             if file_type_source == FileType.DIRECTORY:
                 # If the source object is a directory, we copy its entire contents
                 data_node.base.repository.copy_tree(filepath_target, filename_source)
-                transport.put(
+                await transport.put_async(
                     f'{dirpath}/*',
-                    str(workdir.joinpath(target)) if target else str(workdir.joinpath('.')),
+                    workdir.joinpath(target) if target else workdir.joinpath('.'),
                     overwrite=True,
                 )
             else:
@@ -382,18 +382,18 @@ def _copy_local_files(logger, node, transport, inputs, local_copy_list, workdir:
                 with filepath_target.open('wb') as handle:
                     with data_node.base.repository.open(filename_source, 'rb') as source:
                         shutil.copyfileobj(source, handle)
-                transport.makedirs(str(workdir.joinpath(Path(target).parent)), ignore_existing=True)
-                transport.put(str(filepath_target), str(workdir.joinpath(target)))
+                await transport.makedirs_async(workdir.joinpath(Path(target).parent), ignore_existing=True)
+                await transport.put_async(filepath_target, workdir.joinpath(target))
 
 
-def _copy_sandbox_files(logger, node, transport, folder, workdir: Path):
+async def _copy_sandbox_files(logger, node, transport, folder, workdir: Path):
     """Copy the contents of the sandbox folder to the working directory."""
     for filename in folder.get_content_list():
         logger.debug(f'[submission of calculation {node.pk}] copying file/folder {filename}...')
-        transport.put(folder.get_abs_path(filename), str(workdir.joinpath(filename)))
+        await transport.put_async(folder.get_abs_path(filename), workdir.joinpath(filename))
 
 
-def submit_calculation(calculation: CalcJobNode, transport: Transport) -> str | ExitCode:
+def submit_calculation(calculation: CalcJobNode, transport: Union['Transport', 'AsyncTransport']) -> str | ExitCode:
     """Submit a previously uploaded `CalcJob` to the scheduler.
 
     :param calculation: the instance of CalcJobNode to submit.
@@ -423,7 +423,7 @@ def submit_calculation(calculation: CalcJobNode, transport: Transport) -> str |
     return result
 
 
-def stash_calculation(calculation: CalcJobNode, transport: Transport) -> None:
+async def stash_calculation(calculation: CalcJobNode, transport: Union['Transport', 'AsyncTransport']) -> None:
     """Stash files from the working directory of a completed calculation to a permanent remote folder.
 
     After a calculation has been completed, optionally stash files from the work directory to a storage location on the
@@ -461,7 +461,7 @@ def stash_calculation(calculation: CalcJobNode, transport: Transport) -> None:
     for source_filename in source_list:
         if transport.has_magic(source_filename):
             copy_instructions = []
-            for globbed_filename in transport.glob(str(source_basepath / source_filename)):
+            for globbed_filename in await transport.glob_async(source_basepath / source_filename):
                 target_filepath = target_basepath / Path(globbed_filename).relative_to(source_basepath)
                 copy_instructions.append((globbed_filename, target_filepath))
         else:
@@ -470,10 +470,10 @@ def stash_calculation(calculation: CalcJobNode, transport: Transport) -> None:
         for source_filepath, target_filepath in copy_instructions:
             # If the source file is in a (nested) directory, create those directories first in the target directory
             target_dirname = target_filepath.parent
-            transport.makedirs(str(target_dirname), ignore_existing=True)
+            await transport.makedirs_async(target_dirname, ignore_existing=True)
 
             try:
-                transport.copy(str(source_filepath), str(target_filepath))
+                await transport.copy_async(source_filepath, target_filepath)
             except (OSError, ValueError) as exception:
                 EXEC_LOGGER.warning(f'failed to stash {source_filepath} to {target_filepath}: {exception}')
             else:
@@ -488,8 +488,8 @@ def stash_calculation(calculation: CalcJobNode, transport: Transport) -> None:
     remote_stash.base.links.add_incoming(calculation, link_type=LinkType.CREATE, link_label='remote_stash')
 
 
-def retrieve_calculation(
-    calculation: CalcJobNode, transport: Transport, retrieved_temporary_folder: str
+async def retrieve_calculation(
+    calculation: CalcJobNode, transport: Union['Transport', 'AsyncTransport'], retrieved_temporary_folder: str
 ) -> FolderData | None:
     """Retrieve all the files of a completed job calculation using the given transport.
 
@@ -529,14 +529,14 @@ def retrieve_calculation(
         retrieve_temporary_list = calculation.get_retrieve_temporary_list()
 
         with SandboxFolder(filepath_sandbox) as folder:
-            retrieve_files_from_list(calculation, transport, folder.abspath, retrieve_list)
+            await retrieve_files_from_list(calculation, transport, folder.abspath, retrieve_list)
             # Here I retrieved everything; now I store them inside the calculation
             retrieved_files.base.repository.put_object_from_tree(folder.abspath)
 
         # Retrieve the temporary files in the retrieved_temporary_folder if any files were
         # specified in the 'retrieve_temporary_list' key
         if retrieve_temporary_list:
-            retrieve_files_from_list(calculation, transport, retrieved_temporary_folder, retrieve_temporary_list)
+            await retrieve_files_from_list(calculation, transport, retrieved_temporary_folder, retrieve_temporary_list)
 
             # Log the files that were retrieved in the temporary folder
             for filename in os.listdir(retrieved_temporary_folder):
@@ -554,7 +554,7 @@ def retrieve_calculation(
     return retrieved_files
 
 
-def kill_calculation(calculation: CalcJobNode, transport: Transport) -> None:
+def kill_calculation(calculation: CalcJobNode, transport: Union['Transport', 'AsyncTransport']) -> None:
     """Kill the calculation through the scheduler
 
     :param calculation: the instance of CalcJobNode to kill.
@@ -587,9 +587,9 @@ def kill_calculation(calculation: CalcJobNode, transport: Transport) -> None:
             )
 
 
-def retrieve_files_from_list(
+async def retrieve_files_from_list(
     calculation: CalcJobNode,
-    transport: Transport,
+    transport: Union['Transport', 'AsyncTransport'],
     folder: str,
     retrieve_list: List[Union[str, Tuple[str, str, int], list]],
 ) -> None:
@@ -612,7 +612,7 @@ def retrieve_files_from_list(
     upto what level of the original remotepath nesting the files will be copied.
 
     :param transport: the Transport instance.
-    :param folder: an absolute path to a folder that contains the files to copy.
+    :param folder: an absolute path to a folder that contains the files to retrieve.
     :param retrieve_list: the list of files to retrieve.
     """
     workdir = Path(calculation.get_remote_workdir())
@@ -621,7 +621,7 @@ def retrieve_files_from_list(
             tmp_rname, tmp_lname, depth = item
             # if there are more than one file I do something differently
             if transport.has_magic(tmp_rname):
-                remote_names = transport.glob(str(workdir.joinpath(tmp_rname)))
+                remote_names = await transport.glob_async(workdir.joinpath(tmp_rname))
                 local_names = []
                 for rem in remote_names:
                     # get the relative path so to make local_names relative
@@ -644,7 +644,7 @@ def retrieve_files_from_list(
             abs_item = item if item.startswith('/') else str(workdir.joinpath(item))
 
             if transport.has_magic(abs_item):
-                remote_names = transport.glob(abs_item)
+                remote_names = await transport.glob_async(abs_item)
                 local_names = [os.path.split(rem)[1] for rem in remote_names]
             else:
                 remote_names = [abs_item]
@@ -656,6 +656,6 @@ def retrieve_files_from_list(
             if rem.startswith('/'):
                 to_get = rem
             else:
-                to_get = str(workdir.joinpath(rem))
+                to_get = workdir.joinpath(rem)
 
-            transport.get(to_get, os.path.join(folder, loc), ignore_nonexisting=True)
+            await transport.get_async(to_get, os.path.join(folder, loc), ignore_nonexisting=True)
diff --git a/src/aiida/engine/processes/calcjobs/calcjob.py b/src/aiida/engine/processes/calcjobs/calcjob.py
index 8ced783a5f..8133ca1c8f 100644
--- a/src/aiida/engine/processes/calcjobs/calcjob.py
+++ b/src/aiida/engine/processes/calcjobs/calcjob.py
@@ -524,7 +524,7 @@ def on_terminated(self) -> None:
         super().on_terminated()
 
     @override
-    def run(self) -> Union[plumpy.process_states.Stop, int, plumpy.process_states.Wait]:
+    async def run(self) -> Union[plumpy.process_states.Stop, int, plumpy.process_states.Wait]:
         """Run the calculation job.
 
         This means invoking the `presubmit` and storing the temporary folder in the node's repository. Then we move the
@@ -535,11 +535,11 @@ def run(self) -> Union[plumpy.process_states.Stop, int, plumpy.process_states.Wa
 
         """
         if self.inputs.metadata.dry_run:
-            self._perform_dry_run()
+            await self._perform_dry_run()
             return plumpy.process_states.Stop(None, True)
 
         if 'remote_folder' in self.inputs:
-            exit_code = self._perform_import()
+            exit_code = await self._perform_import()
             return exit_code
 
         # The following conditional is required for the caching to properly work. Even if the source node has a process
@@ -627,7 +627,7 @@ def _setup_inputs(self) -> None:
         if not self.node.computer:
             self.node.computer = self.inputs.code.computer
 
-    def _perform_dry_run(self):
+    async def _perform_dry_run(self):
         """Perform a dry run.
 
         Instead of performing the normal sequence of steps, just the `presubmit` is called, which will call the method
@@ -643,13 +643,13 @@ def _perform_dry_run(self):
         with LocalTransport() as transport:
             with SubmitTestFolder() as folder:
                 calc_info = self.presubmit(folder)
-                upload_calculation(self.node, transport, calc_info, folder, inputs=self.inputs, dry_run=True)
+                await upload_calculation(self.node, transport, calc_info, folder, inputs=self.inputs, dry_run=True)
                 self.node.dry_run_info = {  # type: ignore[attr-defined]
                     'folder': folder.abspath,
                     'script_filename': self.node.get_option('submit_script_filename'),
                 }
 
-    def _perform_import(self):
+    async def _perform_import(self):
         """Perform the import of an already completed calculation.
 
         The inputs contained a `RemoteData` under the key `remote_folder` signalling that this is not supposed to be run
@@ -669,7 +669,7 @@ def _perform_import(self):
                 with SandboxFolder(filepath_sandbox) as retrieved_temporary_folder:
                     self.presubmit(folder)
                     self.node.set_remote_workdir(self.inputs.remote_folder.get_remote_path())
-                    retrieved = retrieve_calculation(self.node, transport, retrieved_temporary_folder.abspath)
+                    retrieved = await retrieve_calculation(self.node, transport, retrieved_temporary_folder.abspath)
                     if retrieved is not None:
                         self.out(self.node.link_label_retrieved, retrieved)
                         self.update_outputs()
diff --git a/src/aiida/engine/processes/calcjobs/monitors.py b/src/aiida/engine/processes/calcjobs/monitors.py
index 507122ff1e..e13f01a5f3 100644
--- a/src/aiida/engine/processes/calcjobs/monitors.py
+++ b/src/aiida/engine/processes/calcjobs/monitors.py
@@ -8,6 +8,7 @@
 import inspect
 import typing as t
 from datetime import datetime, timedelta
+from typing import Union
 
 from aiida.common.lang import type_check
 from aiida.common.log import AIIDA_LOGGER
@@ -15,7 +16,7 @@
 from aiida.plugins import BaseFactory
 
 if t.TYPE_CHECKING:
-    from aiida.transports import Transport
+    from aiida.transports import AsyncTransport, Transport
 
 LOGGER = AIIDA_LOGGER.getChild(__name__)
 
@@ -122,7 +123,9 @@ def validate(self):
         parameters = list(signature.parameters.keys())
 
         if any(required_parameter not in parameters for required_parameter in ('node', 'transport')):
-            correct_signature = '(node: CalcJobNode, transport: Transport, **kwargs) str | None:'
+            correct_signature = (
+                "(node: CalcJobNode, transport: Union['Transport', 'AsyncTransport'], **kwargs) str | None:"
+            )
             raise ValueError(
                 f'The monitor `{self.entry_point}` has an invalid function signature, it should be: {correct_signature}'
             )
@@ -176,7 +179,7 @@ def monitors(self) -> collections.OrderedDict:
     def process(
         self,
         node: CalcJobNode,
-        transport: Transport,
+        transport: Union['Transport', 'AsyncTransport'],
     ) -> CalcJobMonitorResult | None:
         """Call all monitors in order and return the result as one returns anything other than ``None``.
 
diff --git a/src/aiida/engine/processes/calcjobs/tasks.py b/src/aiida/engine/processes/calcjobs/tasks.py
index 1059d277ba..80617e3bfd 100644
--- a/src/aiida/engine/processes/calcjobs/tasks.py
+++ b/src/aiida/engine/processes/calcjobs/tasks.py
@@ -92,7 +92,7 @@ async def do_upload():
                 except Exception as exception:
                     raise PreSubmitException('exception occurred in presubmit call') from exception
                 else:
-                    remote_folder = execmanager.upload_calculation(node, transport, calc_info, folder)
+                    remote_folder = await execmanager.upload_calculation(node, transport, calc_info, folder)
                     if remote_folder is not None:
                         process.out('remote_folder', remote_folder)
                     skip_submit = calc_info.skip_submit or False
@@ -314,7 +314,7 @@ async def do_retrieve():
 
             if node.get_job_id() is None:
                 logger.warning(f'there is no job id for CalcJobNoe<{node.pk}>: skipping `get_detailed_job_info`')
-                retrieved = execmanager.retrieve_calculation(node, transport, retrieved_temporary_folder)
+                retrieved = await execmanager.retrieve_calculation(node, transport, retrieved_temporary_folder)
             else:
                 try:
                     detailed_job_info = scheduler.get_detailed_job_info(node.get_job_id())
@@ -324,7 +324,7 @@ async def do_retrieve():
                 else:
                     node.set_detailed_job_info(detailed_job_info)
 
-                retrieved = execmanager.retrieve_calculation(node, transport, retrieved_temporary_folder)
+                retrieved = await execmanager.retrieve_calculation(node, transport, retrieved_temporary_folder)
 
             if retrieved is not None:
                 process.out(node.link_label_retrieved, retrieved)
@@ -376,7 +376,7 @@ async def do_stash():
             transport = await cancellable.with_interrupt(request)
 
             logger.info(f'stashing calculation<{node.pk}>')
-            return execmanager.stash_calculation(node, transport)
+            return await execmanager.stash_calculation(node, transport)
 
     try:
         await exponential_backoff_retry(
diff --git a/src/aiida/engine/processes/functions.py b/src/aiida/engine/processes/functions.py
index 8bca68f55c..2f8c363e1a 100644
--- a/src/aiida/engine/processes/functions.py
+++ b/src/aiida/engine/processes/functions.py
@@ -567,7 +567,7 @@ def _setup_db_record(self) -> None:
         self.node.store_source_info(self._func)
 
     @override
-    def run(self) -> 'ExitCode' | None:
+    async def run(self) -> 'ExitCode' | None:
         """Run the process."""
         from .exit_code import ExitCode
 
diff --git a/src/aiida/engine/processes/workchains/workchain.py b/src/aiida/engine/processes/workchains/workchain.py
index 8818db5eb8..4b847722a0 100644
--- a/src/aiida/engine/processes/workchains/workchain.py
+++ b/src/aiida/engine/processes/workchains/workchain.py
@@ -297,7 +297,7 @@ def _update_process_status(self) -> None:
 
     @override
     @Protect.final
-    def run(self) -> t.Any:
+    async def run(self) -> t.Any:
         self._stepper = self.spec().get_outline().create_stepper(self)  # type: ignore[arg-type]
         return self._do_step()
 
diff --git a/src/aiida/engine/transports.py b/src/aiida/engine/transports.py
index fe32df7884..cade4c04ca 100644
--- a/src/aiida/engine/transports.py
+++ b/src/aiida/engine/transports.py
@@ -13,12 +13,12 @@
 import contextvars
 import logging
 import traceback
-from typing import TYPE_CHECKING, Awaitable, Dict, Hashable, Iterator, Optional
+from typing import TYPE_CHECKING, Awaitable, Dict, Hashable, Iterator, Optional, Union
 
 from aiida.orm import AuthInfo
 
 if TYPE_CHECKING:
-    from aiida.transports import Transport
+    from aiida.transports import AsyncTransport, Transport
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -54,7 +54,7 @@ def loop(self) -> asyncio.AbstractEventLoop:
         return self._loop
 
     @contextlib.contextmanager
-    def request_transport(self, authinfo: AuthInfo) -> Iterator[Awaitable['Transport']]:
+    def request_transport(self, authinfo: AuthInfo) -> Iterator[Awaitable[Union['Transport', 'AsyncTransport']]]:
         """Request a transport from an authinfo.  Because the client is not allowed to
         request a transport immediately they will instead be given back a future
         that can be awaited to get the transport::
diff --git a/src/aiida/orm/authinfos.py b/src/aiida/orm/authinfos.py
index e87be97367..bff6ef849d 100644
--- a/src/aiida/orm/authinfos.py
+++ b/src/aiida/orm/authinfos.py
@@ -8,7 +8,7 @@
 ###########################################################################
 """Module for the `AuthInfo` ORM class."""
 
-from typing import TYPE_CHECKING, Any, Dict, Optional, Type
+from typing import TYPE_CHECKING, Any, Dict, Optional, Type, Union
 
 from aiida.common import exceptions
 from aiida.manage import get_manager
@@ -21,7 +21,7 @@
     from aiida.orm import Computer, User
     from aiida.orm.implementation import StorageBackend
     from aiida.orm.implementation.authinfos import BackendAuthInfo  # noqa: F401
-    from aiida.transports import Transport
+    from aiida.transports import AsyncTransport, Transport
 
 __all__ = ('AuthInfo',)
 
@@ -166,7 +166,7 @@ def get_workdir(self) -> str:
         except KeyError:
             return self.computer.get_workdir()
 
-    def get_transport(self) -> 'Transport':
+    def get_transport(self) -> Union['Transport', 'AsyncTransport']:
         """Return a fully configured transport that can be used to connect to the computer set for this instance."""
         computer = self.computer
         transport_type = computer.transport_type
diff --git a/src/aiida/orm/computers.py b/src/aiida/orm/computers.py
index bae925b25c..9bf12fbb2e 100644
--- a/src/aiida/orm/computers.py
+++ b/src/aiida/orm/computers.py
@@ -23,7 +23,7 @@
     from aiida.orm import AuthInfo, User
     from aiida.orm.implementation import StorageBackend
     from aiida.schedulers import Scheduler
-    from aiida.transports import Transport
+    from aiida.transports import AsyncTransport, Transport
 
 __all__ = ('Computer',)
 
@@ -622,16 +622,16 @@ def is_user_enabled(self, user: 'User') -> bool:
             # Return False if the user is not configured (in a sense, it is disabled for that user)
             return False
 
-    def get_transport(self, user: Optional['User'] = None) -> 'Transport':
+    def get_transport(self, user: Optional['User'] = None) -> Union['Transport', 'AsyncTransport']:
         """Return a Transport class, configured with all correct parameters.
         The Transport is closed (meaning that if you want to run any operation with
         it, you have to open it first (i.e., e.g. for a SSH transport, you have
-        to open a connection). To do this you can call ``transports.open()``, or simply
+        to open a connection). To do this you can call ``transport.open()``, or simply
         run within a ``with`` statement::
 
            transport = Computer.get_transport()
            with transport:
-               print(transports.whoami())
+               print(transport.whoami())
 
         :param user: if None, try to obtain a transport for the default user.
             Otherwise, pass a valid User.
@@ -646,7 +646,7 @@ def get_transport(self, user: Optional['User'] = None) -> 'Transport':
         authinfo = authinfos.AuthInfo.get_collection(self.backend).get(dbcomputer=self, aiidauser=user)
         return authinfo.get_transport()
 
-    def get_transport_class(self) -> Type['Transport']:
+    def get_transport_class(self) -> Union[Type['Transport'], Type['AsyncTransport']]:
         """Get the transport class for this computer.  Can be used to instantiate a transport instance."""
         try:
             return TransportFactory(self.transport_type)
diff --git a/src/aiida/orm/nodes/data/remote/base.py b/src/aiida/orm/nodes/data/remote/base.py
index 5b7fec86c2..f25d911b81 100644
--- a/src/aiida/orm/nodes/data/remote/base.py
+++ b/src/aiida/orm/nodes/data/remote/base.py
@@ -125,7 +125,8 @@ def listdir_withattributes(self, path='.'):
         """Connects to the remote folder and lists the directory content.
 
         :param relpath: If 'relpath' is specified, lists the content of the given subfolder.
-        :return: a list of dictionaries, where the documentation is in :py:class:Transport.listdir_withattributes.
+        :return: a list of dictionaries, where the documentation
+            is in :py:class:Transport.listdir_withattributes.
         """
         authinfo = self.get_authinfo()
 
diff --git a/src/aiida/orm/nodes/process/calculation/calcjob.py b/src/aiida/orm/nodes/process/calculation/calcjob.py
index a7cd20c88e..3d448d957b 100644
--- a/src/aiida/orm/nodes/process/calculation/calcjob.py
+++ b/src/aiida/orm/nodes/process/calculation/calcjob.py
@@ -26,7 +26,7 @@
     from aiida.parsers import Parser
     from aiida.schedulers.datastructures import JobInfo, JobState
     from aiida.tools.calculations import CalculationTools
-    from aiida.transports import Transport
+    from aiida.transports import AsyncTransport, Transport
 
 __all__ = ('CalcJobNode',)
 
@@ -450,10 +450,11 @@ def get_authinfo(self) -> 'AuthInfo':
 
         return computer.get_authinfo(self.user)
 
-    def get_transport(self) -> 'Transport':
+    def get_transport(self) -> Union['Transport', 'AsyncTransport']:
         """Return the transport for this calculation.
 
-        :return: `Transport` configured with the `AuthInfo` associated to the computer of this node
+        :return: Union['Transport', 'AsyncTransport'] configured
+            with the `AuthInfo` associated to the computer of this node
         """
         return self.get_authinfo().get_transport()
 
diff --git a/src/aiida/orm/utils/remote.py b/src/aiida/orm/utils/remote.py
index f55cedc35a..2a9846af7c 100644
--- a/src/aiida/orm/utils/remote.py
+++ b/src/aiida/orm/utils/remote.py
@@ -12,6 +12,7 @@
 
 import os
 import typing as t
+from typing import Union
 
 from aiida.orm.nodes.data.remote.base import RemoteData
 
@@ -20,14 +21,14 @@
 
     from aiida import orm
     from aiida.orm.implementation import StorageBackend
-    from aiida.transports import Transport
+    from aiida.transports import AsyncTransport, Transport
 
 
-def clean_remote(transport: Transport, path: str) -> None:
+def clean_remote(transport: Union['Transport', 'AsyncTransport'], path: str) -> None:
     """Recursively remove a remote folder, with the given absolute path, and all its contents. The path should be
     made accessible through the transport channel, which should already be open
 
-    :param transport: an open Transport channel
+    :param transport: an open Union['Transport', 'AsyncTransport'] channel
     :param path: an absolute path on the remote made available through the transport
     """
     if not isinstance(path, str):
diff --git a/src/aiida/plugins/factories.py b/src/aiida/plugins/factories.py
index d007ef0dd3..175abc9eb7 100644
--- a/src/aiida/plugins/factories.py
+++ b/src/aiida/plugins/factories.py
@@ -42,7 +42,7 @@
     from aiida.schedulers import Scheduler
     from aiida.tools.data.orbital import Orbital
     from aiida.tools.dbimporters import DbImporter
-    from aiida.transports import Transport
+    from aiida.transports import AsyncTransport, Transport
 
 
 def raise_invalid_type_error(entry_point_name: str, entry_point_group: str, valid_classes: Tuple[Any, ...]) -> NoReturn:
@@ -410,15 +410,19 @@ def StorageFactory(entry_point_name: str, load: bool = True) -> Union[EntryPoint
 
 
 @overload
-def TransportFactory(entry_point_name: str, load: Literal[True] = True) -> Type['Transport']: ...
+def TransportFactory(
+    entry_point_name: str, load: Literal[True] = True
+) -> Union[Type['Transport'], Type['AsyncTransport']]: ...
 
 
 @overload
 def TransportFactory(entry_point_name: str, load: Literal[False]) -> EntryPoint: ...
 
 
-def TransportFactory(entry_point_name: str, load: bool = True) -> Union[EntryPoint, Type['Transport']]:
-    """Return the `Transport` sub class registered under the given entry point.
+def TransportFactory(
+    entry_point_name: str, load: bool = True
+) -> Union[EntryPoint, Type['Transport'], Type['AsyncTransport']]:
+    """Return the Union['Transport', 'AsyncTransport'] sub class registered under the given entry point.
 
     :param entry_point_name: the entry point name.
     :param load: if True, load the matched entry point and return the loaded resource instead of the entry point itself.
@@ -426,16 +430,16 @@ def TransportFactory(entry_point_name: str, load: bool = True) -> Union[EntryPoi
     """
     from inspect import isclass
 
-    from aiida.transports import Transport
+    from aiida.transports import AsyncTransport, Transport
 
     entry_point_group = 'aiida.transports'
     entry_point = BaseFactory(entry_point_group, entry_point_name, load=load)
-    valid_classes = (Transport,)
+    valid_classes = (Transport, AsyncTransport)
 
     if not load:
         return entry_point
 
-    if isclass(entry_point) and issubclass(entry_point, Transport):
+    if isclass(entry_point) and (issubclass(entry_point, Transport) or issubclass(entry_point, AsyncTransport)):
         return entry_point
 
     raise_invalid_type_error(entry_point_name, entry_point_group, valid_classes)
diff --git a/src/aiida/schedulers/plugins/direct.py b/src/aiida/schedulers/plugins/direct.py
index 694ff93863..0bed55bda4 100644
--- a/src/aiida/schedulers/plugins/direct.py
+++ b/src/aiida/schedulers/plugins/direct.py
@@ -192,7 +192,7 @@ def _get_submit_command(self, submit_script):
             directory.
             IMPORTANT: submit_script should be already escaped.
         """
-        submit_command = f'bash {submit_script} > /dev/null 2>&1 & echo $!'
+        submit_command = f'(bash {submit_script} > /dev/null 2>&1 & echo $!) &'
 
         self.logger.info(f'submitting with: {submit_command}')
 
diff --git a/src/aiida/schedulers/scheduler.py b/src/aiida/schedulers/scheduler.py
index 3cd4136984..3bb540c84a 100644
--- a/src/aiida/schedulers/scheduler.py
+++ b/src/aiida/schedulers/scheduler.py
@@ -12,6 +12,7 @@
 
 import abc
 import typing as t
+from typing import Union
 
 from aiida.common import exceptions, log, warnings
 from aiida.common.datastructures import CodeRunMode
@@ -21,7 +22,7 @@
 from aiida.schedulers.datastructures import JobInfo, JobResource, JobTemplate, JobTemplateCodeInfo
 
 if t.TYPE_CHECKING:
-    from aiida.transports import Transport
+    from aiida.transports import AsyncTransport, Transport
 
 __all__ = ('Scheduler', 'SchedulerError', 'SchedulerParsingError')
 
@@ -365,7 +366,7 @@ def transport(self):
 
         return self._transport
 
-    def set_transport(self, transport: Transport):
+    def set_transport(self, transport: Union['Transport', 'AsyncTransport']):
         """Set the transport to be used to query the machine or to submit scripts.
 
         This class assumes that the transport is open and active.
diff --git a/src/aiida/tools/pytest_fixtures/__init__.py b/src/aiida/tools/pytest_fixtures/__init__.py
index c2729d16c5..e19d4c455e 100644
--- a/src/aiida/tools/pytest_fixtures/__init__.py
+++ b/src/aiida/tools/pytest_fixtures/__init__.py
@@ -22,6 +22,7 @@
     aiida_computer,
     aiida_computer_local,
     aiida_computer_ssh,
+    aiida_computer_ssh_async,
     aiida_localhost,
     ssh_key,
 )
@@ -33,6 +34,7 @@
     'aiida_computer',
     'aiida_computer_local',
     'aiida_computer_ssh',
+    'aiida_computer_ssh_async',
     'aiida_config',
     'aiida_config_factory',
     'aiida_config_tmp',
diff --git a/src/aiida/tools/pytest_fixtures/orm.py b/src/aiida/tools/pytest_fixtures/orm.py
index 0ed7ea18d7..076eac2ddb 100644
--- a/src/aiida/tools/pytest_fixtures/orm.py
+++ b/src/aiida/tools/pytest_fixtures/orm.py
@@ -190,6 +190,38 @@ def factory(label: str | None = None, configure: bool = True) -> 'Computer':
     return factory
 
 
+@pytest.fixture
+def aiida_computer_ssh_async(aiida_computer) -> t.Callable[[], 'Computer']:
+    """Factory to return a :class:`aiida.orm.computers.Computer` instance with ``core.ssh_async`` transport.
+
+    Usage::
+
+        def test(aiida_computer_ssh):
+            computer = aiida_computer_ssh(label='some-label', configure=True)
+            assert computer.transport_type == 'core.ssh_async'
+            assert computer.is_configured
+
+    The factory has the following signature:
+
+    :param label: The computer label. If not specified, a random UUID4 is used.
+    :param configure: Boolean, if ``True``, ensures the computer is configured, otherwise the computer is returned
+        as is. Note that if a computer with the given label already exists and it was configured before, the
+        computer will not be "un-"configured. If an unconfigured computer is absolutely required, make sure to first
+        delete the existing computer or specify another label.
+    :return: A stored computer instance.
+    """
+
+    def factory(label: str | None = None, configure: bool = True) -> 'Computer':
+        computer = aiida_computer(label=label, hostname='localhost', transport_type='core.ssh_async')
+
+        if configure:
+            computer.configure()
+
+        return computer
+
+    return factory
+
+
 @pytest.fixture
 def aiida_localhost(aiida_computer_local) -> 'Computer':
     """Return a :class:`aiida.orm.computers.Computer` instance representing localhost with ``core.local`` transport.
diff --git a/src/aiida/transports/__init__.py b/src/aiida/transports/__init__.py
index eecd07c04f..0d36fe3980 100644
--- a/src/aiida/transports/__init__.py
+++ b/src/aiida/transports/__init__.py
@@ -16,8 +16,10 @@
 from .transport import *
 
 __all__ = (
+    'AsyncTransport',
     'SshTransport',
     'Transport',
+    'TransportPath',
     'convert_to_bool',
     'parse_sshconfig',
 )
diff --git a/src/aiida/transports/cli.py b/src/aiida/transports/cli.py
index 6088eb08f6..5faa2d6f80 100644
--- a/src/aiida/transports/cli.py
+++ b/src/aiida/transports/cli.py
@@ -140,7 +140,7 @@ def transport_options(transport_type):
     """Decorate a command with all options for a computer configure subcommand for transport_type."""
 
     def apply_options(func):
-        """Decorate the command functionn with the appropriate options for the transport type."""
+        """Decorate the command function with the appropriate options for the transport type."""
         options_list = list_transport_options(transport_type)
         options_list.reverse()
         func = arguments.COMPUTER(callback=partial(match_comp_transport, transport_type=transport_type))(func)
diff --git a/src/aiida/transports/plugins/local.py b/src/aiida/transports/plugins/local.py
index 8de49838e3..56fa042734 100644
--- a/src/aiida/transports/plugins/local.py
+++ b/src/aiida/transports/plugins/local.py
@@ -15,9 +15,11 @@
 import os
 import shutil
 import subprocess
+from typing import Optional
 
+from aiida.common.warnings import warn_deprecation
 from aiida.transports import cli as transport_cli
-from aiida.transports.transport import Transport, TransportInternalError
+from aiida.transports.transport import Transport, TransportInternalError, TransportPath, path_to_str
 
 
 # refactor or raise the limit: issue #1784
@@ -92,7 +94,7 @@ def curdir(self):
 
         raise TransportInternalError('Error, local method called for LocalTransport without opening the channel first')
 
-    def chdir(self, path):
+    def chdir(self, path: TransportPath):
         """
         PLEASE DON'T USE `chdir()` IN NEW DEVELOPMENTS, INSTEAD DIRECTLY PASS ABSOLUTE PATHS TO INTERFACE.
         `chdir()` is DEPRECATED and will be removed in the next major version.
@@ -101,6 +103,11 @@ def chdir(self, path):
         :param path: path to cd into
         :raise OSError: if the directory does not have read attributes.
         """
+        warn_deprecation(
+            '`chdir()` is deprecated and will be removed in the next major version.',
+            version=3,
+        )
+        path = path_to_str(path)
         new_path = os.path.join(self.curdir, path)
         if not os.path.isdir(new_path):
             raise OSError(f"'{new_path}' is not a valid directory")
@@ -109,13 +116,15 @@ def chdir(self, path):
 
         self._internal_dir = os.path.normpath(new_path)
 
-    def chown(self, path, uid, gid):
+    def chown(self, path: TransportPath, uid, gid):
+        path = path_to_str(path)
         os.chown(path, uid, gid)
 
-    def normalize(self, path='.'):
+    def normalize(self, path: TransportPath = '.'):
         """Normalizes path, eliminating double slashes, etc..
         :param path: path to normalize
         """
+        path = path_to_str(path)
         return os.path.realpath(os.path.join(self.curdir, path))
 
     def getcwd(self):
@@ -127,8 +136,9 @@ def getcwd(self):
         return self.curdir
 
     @staticmethod
-    def _os_path_split_asunder(path):
+    def _os_path_split_asunder(path: TransportPath):
         """Used by makedirs, Takes path (a str) and returns a list deconcatenating the path."""
+        path = path_to_str(path)
         parts = []
         while True:
             newpath, tail = os.path.split(path)
@@ -142,7 +152,7 @@ def _os_path_split_asunder(path):
         parts.reverse()
         return parts
 
-    def makedirs(self, path, ignore_existing=False):
+    def makedirs(self, path: TransportPath, ignore_existing=False):
         """Super-mkdir; create a leaf directory and all intermediate ones.
         Works like mkdir, except that any intermediate path segment (not
         just the rightmost) will be created if it does not exist.
@@ -153,6 +163,7 @@ def makedirs(self, path, ignore_existing=False):
 
         :raise OSError: If the directory already exists and is not ignore_existing
         """
+        path = path_to_str(path)
         # check to avoid creation of empty dirs
         path = os.path.normpath(path)
 
@@ -168,7 +179,7 @@ def makedirs(self, path, ignore_existing=False):
             if not os.path.exists(this_dir):
                 os.mkdir(this_dir)
 
-    def mkdir(self, path, ignore_existing=False):
+    def mkdir(self, path: TransportPath, ignore_existing=False):
         """Create a folder (directory) named path.
 
         :param path: name of the folder to create
@@ -177,33 +188,37 @@ def mkdir(self, path, ignore_existing=False):
 
         :raise OSError: If the directory already exists.
         """
+        path = path_to_str(path)
         if ignore_existing and self.isdir(path):
             return
 
         os.mkdir(os.path.join(self.curdir, path))
 
-    def rmdir(self, path):
+    def rmdir(self, path: TransportPath):
         """Removes a folder at location path.
         :param path: path to remove
         """
+        path = path_to_str(path)
         os.rmdir(os.path.join(self.curdir, path))
 
-    def isdir(self, path):
+    def isdir(self, path: TransportPath):
         """Checks if 'path' is a directory.
         :return: a boolean
         """
+        path = path_to_str(path)
         if not path:
             return False
 
         return os.path.isdir(os.path.join(self.curdir, path))
 
-    def chmod(self, path, mode):
+    def chmod(self, path: TransportPath, mode):
         """Changes permission bits of object at path
         :param path: path to modify
         :param mode: permission bits
 
         :raise OSError: if path does not exist.
         """
+        path = path_to_str(path)
         if not path:
             raise OSError('Directory not given in input')
         real_path = os.path.join(self.curdir, path)
@@ -214,7 +229,7 @@ def chmod(self, path, mode):
 
     # please refactor: issue #1782
 
-    def put(self, localpath, remotepath, *args, **kwargs):
+    def put(self, localpath: TransportPath, remotepath: TransportPath, *args, **kwargs):
         """Copies a file or a folder from localpath to remotepath.
         Automatically redirects to putfile or puttree.
 
@@ -228,6 +243,8 @@ def put(self, localpath, remotepath, *args, **kwargs):
         :raise OSError: if remotepath is not valid
         :raise ValueError: if localpath is not valid
         """
+        localpath = path_to_str(localpath)
+        remotepath = path_to_str(remotepath)
         from aiida.common.warnings import warn_deprecation
 
         if 'ignore_noexisting' in kwargs:
@@ -294,7 +311,7 @@ def put(self, localpath, remotepath, *args, **kwargs):
         else:
             raise OSError(f'The local path {localpath} does not exist')
 
-    def putfile(self, localpath, remotepath, *args, **kwargs):
+    def putfile(self, localpath: TransportPath, remotepath: TransportPath, *args, **kwargs):
         """Copies a file from localpath to remotepath.
         Automatically redirects to putfile or puttree.
 
@@ -307,6 +324,9 @@ def putfile(self, localpath, remotepath, *args, **kwargs):
         :raise ValueError: if localpath is not valid
         :raise OSError: if localpath does not exist
         """
+        localpath = path_to_str(localpath)
+        remotepath = path_to_str(remotepath)
+
         overwrite = kwargs.get('overwrite', args[0] if args else True)
         if not remotepath:
             raise OSError('Input remotepath to putfile must be a non empty string')
@@ -325,7 +345,7 @@ def putfile(self, localpath, remotepath, *args, **kwargs):
 
         shutil.copyfile(localpath, the_destination)
 
-    def puttree(self, localpath, remotepath, *args, **kwargs):
+    def puttree(self, localpath: TransportPath, remotepath: TransportPath, *args, **kwargs):
         """Copies a folder recursively from localpath to remotepath.
         Automatically redirects to putfile or puttree.
 
@@ -340,6 +360,8 @@ def puttree(self, localpath, remotepath, *args, **kwargs):
         :raise ValueError: if localpath is not valid
         :raise OSError: if localpath does not exist
         """
+        localpath = path_to_str(localpath)
+        remotepath = path_to_str(remotepath)
         dereference = kwargs.get('dereference', args[0] if args else True)
         overwrite = kwargs.get('overwrite', args[1] if len(args) > 1 else True)
         if not remotepath:
@@ -365,11 +387,12 @@ def puttree(self, localpath, remotepath, *args, **kwargs):
 
         shutil.copytree(localpath, the_destination, symlinks=not dereference, dirs_exist_ok=overwrite)
 
-    def rmtree(self, path):
+    def rmtree(self, path: TransportPath):
         """Remove tree as rm -r would do
 
         :param path: a string to path
         """
+        path = path_to_str(path)
         the_path = os.path.join(self.curdir, path)
         try:
             shutil.rmtree(the_path)
@@ -383,7 +406,7 @@ def rmtree(self, path):
 
     # please refactor: issue #1781
 
-    def get(self, remotepath, localpath, *args, **kwargs):
+    def get(self, remotepath: TransportPath, localpath: TransportPath, *args, **kwargs):
         """Copies a folder or a file recursively from 'remote' remotepath to
         'local' localpath.
         Automatically redirects to getfile or gettree.
@@ -398,6 +421,8 @@ def get(self, remotepath, localpath, *args, **kwargs):
         :raise OSError: if 'remote' remotepath is not valid
         :raise ValueError: if 'local' localpath is not valid
         """
+        remotepath = path_to_str(remotepath)
+        localpath = path_to_str(localpath)
         dereference = kwargs.get('dereference', args[0] if args else True)
         overwrite = kwargs.get('overwrite', args[1] if len(args) > 1 else True)
         ignore_nonexisting = kwargs.get('ignore_nonexisting', args[2] if len(args) > 2 else False)
@@ -449,7 +474,7 @@ def get(self, remotepath, localpath, *args, **kwargs):
         else:
             raise OSError(f'The remote path {remotepath} does not exist')
 
-    def getfile(self, remotepath, localpath, *args, **kwargs):
+    def getfile(self, remotepath: TransportPath, localpath: TransportPath, *args, **kwargs):
         """Copies a file recursively from 'remote' remotepath to
         'local' localpath.
 
@@ -462,6 +487,9 @@ def getfile(self, remotepath, localpath, *args, **kwargs):
         :raise ValueError: if 'local' localpath is not valid
         :raise OSError: if unintentionally overwriting
         """
+        remotepath = path_to_str(remotepath)
+        localpath = path_to_str(localpath)
+
         if not os.path.isabs(localpath):
             raise ValueError('localpath must be an absolute path')
 
@@ -480,7 +508,7 @@ def getfile(self, remotepath, localpath, *args, **kwargs):
 
         shutil.copyfile(the_source, localpath)
 
-    def gettree(self, remotepath, localpath, *args, **kwargs):
+    def gettree(self, remotepath: TransportPath, localpath: TransportPath, *args, **kwargs):
         """Copies a folder recursively from 'remote' remotepath to
         'local' localpath.
 
@@ -493,6 +521,8 @@ def gettree(self, remotepath, localpath, *args, **kwargs):
         :raise ValueError: if 'local' localpath is not valid
         :raise OSError: if unintentionally overwriting
         """
+        remotepath = path_to_str(remotepath)
+        localpath = path_to_str(localpath)
         dereference = kwargs.get('dereference', args[0] if args else True)
         overwrite = kwargs.get('overwrite', args[1] if len(args) > 1 else True)
         if not remotepath:
@@ -519,7 +549,7 @@ def gettree(self, remotepath, localpath, *args, **kwargs):
 
     # please refactor: issue #1780 on github
 
-    def copy(self, remotesource, remotedestination, dereference=False, recursive=True):
+    def copy(self, remotesource: TransportPath, remotedestination: TransportPath, dereference=False, recursive=True):
         """Copies a file or a folder from 'remote' remotesource to 'remote' remotedestination.
         Automatically redirects to copyfile or copytree.
 
@@ -532,6 +562,8 @@ def copy(self, remotesource, remotedestination, dereference=False, recursive=Tru
         :raise ValueError: if 'remote' remotesource or remotedestinationis not valid
         :raise OSError: if remotesource does not exist
         """
+        remotesource = path_to_str(remotesource)
+        remotedestination = path_to_str(remotedestination)
         if not remotesource:
             raise ValueError('Input remotesource to copy must be a non empty object')
         if not remotedestination:
@@ -579,7 +611,7 @@ def copy(self, remotesource, remotedestination, dereference=False, recursive=Tru
                 # With self.copytree, the (possible) relative path is OK
                 self.copytree(remotesource, remotedestination, dereference)
 
-    def copyfile(self, remotesource, remotedestination, dereference=False):
+    def copyfile(self, remotesource: TransportPath, remotedestination: TransportPath, dereference=False):
         """Copies a file from 'remote' remotesource to
         'remote' remotedestination.
 
@@ -590,6 +622,8 @@ def copyfile(self, remotesource, remotedestination, dereference=False):
         :raise ValueError: if 'remote' remotesource or remotedestination is not valid
         :raise OSError: if remotesource does not exist
         """
+        remotesource = path_to_str(remotesource)
+        remotedestination = path_to_str(remotedestination)
         if not remotesource:
             raise ValueError('Input remotesource to copyfile must be a non empty object')
         if not remotedestination:
@@ -605,7 +639,7 @@ def copyfile(self, remotesource, remotedestination, dereference=False):
         else:
             shutil.copyfile(the_source, the_destination)
 
-    def copytree(self, remotesource, remotedestination, dereference=False):
+    def copytree(self, remotesource: TransportPath, remotedestination: TransportPath, dereference=False):
         """Copies a folder from 'remote' remotesource to
         'remote' remotedestination.
 
@@ -616,6 +650,8 @@ def copytree(self, remotesource, remotedestination, dereference=False):
         :raise ValueError: if 'remote' remotesource or remotedestination is not valid
         :raise OSError: if remotesource does not exist
         """
+        remotesource = path_to_str(remotesource)
+        remotedestination = path_to_str(remotedestination)
         if not remotesource:
             raise ValueError('Input remotesource to copytree must be a non empty object')
         if not remotedestination:
@@ -631,11 +667,12 @@ def copytree(self, remotesource, remotedestination, dereference=False):
 
         shutil.copytree(the_source, the_destination, symlinks=not dereference)
 
-    def get_attribute(self, path):
+    def get_attribute(self, path: TransportPath):
         """Returns an object FileAttribute,
         as specified in aiida.transports.
         :param path: the path of the given file.
         """
+        path = path_to_str(path)
         from aiida.transports.util import FileAttribute
 
         os_attr = os.lstat(os.path.join(self.curdir, path))
@@ -646,10 +683,12 @@ def get_attribute(self, path):
             aiida_attr[key] = getattr(os_attr, key)
         return aiida_attr
 
-    def _local_listdir(self, path, pattern=None):
+    def _local_listdir(self, path: TransportPath, pattern=None):
         """Act on the local folder, for the rest, same as listdir."""
         import re
 
+        path = path_to_str(path)
+
         if not pattern:
             return os.listdir(path)
 
@@ -663,12 +702,13 @@ def _local_listdir(self, path, pattern=None):
             base_dir += os.sep
         return [re.sub(base_dir, '', i) for i in filtered_list]
 
-    def listdir(self, path='.', pattern=None):
+    def listdir(self, path: TransportPath = '.', pattern=None):
         """:return: a list containing the names of the entries in the directory.
         :param path: default ='.'
         :param pattern: if set, returns the list of files matching pattern.
                      Unix only. (Use to emulate ls * for example)
         """
+        path = path_to_str(path)
         the_path = os.path.join(self.curdir, path).strip()
         if not pattern:
             try:
@@ -685,20 +725,22 @@ def listdir(self, path='.', pattern=None):
                 the_path += '/'
             return [re.sub(the_path, '', i) for i in filtered_list]
 
-    def remove(self, path):
+    def remove(self, path: TransportPath):
         """Removes a file at position path."""
+        path = path_to_str(path)
         os.remove(os.path.join(self.curdir, path))
 
-    def isfile(self, path):
+    def isfile(self, path: TransportPath):
         """Checks if object at path is a file.
         Returns a boolean.
         """
+        path = path_to_str(path)
         if not path:
             return False
         return os.path.isfile(os.path.join(self.curdir, path))
 
     @contextlib.contextmanager
-    def _exec_command_internal(self, command, workdir=None, **kwargs):
+    def _exec_command_internal(self, command, workdir: Optional[TransportPath] = None, **kwargs):
         """Executes the specified command in bash login shell.
 
 
@@ -723,12 +765,13 @@ def _exec_command_internal(self, command, workdir=None, **kwargs):
         """
         from aiida.common.escaping import escape_for_bash
 
+        if workdir:
+            workdir = path_to_str(workdir)
         # Note: The outer shell will eat one level of escaping, while
         # 'bash -l -c ...' will eat another. Thus, we need to escape again.
         bash_commmand = f'{self._bash_command_str}-c '
 
         command = bash_commmand + escape_for_bash(command)
-
         if workdir:
             cwd = workdir
         else:
@@ -745,7 +788,7 @@ def _exec_command_internal(self, command, workdir=None, **kwargs):
         ) as process:
             yield process
 
-    def exec_command_wait_bytes(self, command, stdin=None, workdir=None, **kwargs):
+    def exec_command_wait_bytes(self, command, stdin=None, workdir: Optional[TransportPath] = None, **kwargs):
         """Executes the specified command and waits for it to finish.
 
         :param command: the command to execute
@@ -757,6 +800,8 @@ def exec_command_wait_bytes(self, command, stdin=None, workdir=None, **kwargs):
         :return: a tuple with (return_value, stdout, stderr) where stdout and stderr
             are both bytes and the return_value is an int.
         """
+        if workdir:
+            workdir = path_to_str(workdir)
         with self._exec_command_internal(command, workdir) as process:
             if stdin is not None:
                 # Implicitly assume that the desired encoding is 'utf-8' if I receive a string.
@@ -799,7 +844,7 @@ def line_encoder(iterator, encoding='utf-8'):
 
         return retval, output_text, stderr_text
 
-    def gotocomputer_command(self, remotedir):
+    def gotocomputer_command(self, remotedir: TransportPath):
         """Return a string to be run using os.system in order to connect
         via the transport to the remote directory.
 
@@ -810,11 +855,12 @@ def gotocomputer_command(self, remotedir):
 
         :param str remotedir: the full path of the remote directory
         """
+        remotedir = path_to_str(remotedir)
         connect_string = self._gotocomputer_string(remotedir)
         cmd = f'bash -c {connect_string}'
         return cmd
 
-    def rename(self, oldpath, newpath):
+    def rename(self, oldpath: TransportPath, newpath: TransportPath):
         """Rename a file or folder from oldpath to newpath.
 
         :param str oldpath: existing name of the file or folder
@@ -823,6 +869,8 @@ def rename(self, oldpath, newpath):
         :raises OSError: if src/dst is not found
         :raises ValueError: if src/dst is not a valid string
         """
+        oldpath = path_to_str(oldpath)
+        newpath = path_to_str(newpath)
         if not oldpath:
             raise ValueError(f'Source {oldpath} is not a valid string')
         if not newpath:
@@ -834,15 +882,15 @@ def rename(self, oldpath, newpath):
 
         shutil.move(oldpath, newpath)
 
-    def symlink(self, remotesource, remotedestination):
+    def symlink(self, remotesource: TransportPath, remotedestination: TransportPath):
         """Create a symbolic link between the remote source and the remote
         remotedestination
 
         :param remotesource: remote source. Can contain a pattern.
         :param remotedestination: remote destination
         """
-        remotesource = os.path.normpath(remotesource)
-        remotedestination = os.path.normpath(remotedestination)
+        remotesource = os.path.normpath(path_to_str(remotesource))
+        remotedestination = os.path.normpath(path_to_str(remotedestination))
 
         if self.has_magic(remotesource):
             if self.has_magic(remotedestination):
@@ -861,8 +909,9 @@ def symlink(self, remotesource, remotedestination):
             except OSError:
                 raise OSError(f'!!: {remotesource}, {self.curdir}, {remotedestination}')
 
-    def path_exists(self, path):
+    def path_exists(self, path: TransportPath):
         """Check if path exists"""
+        path = path_to_str(path)
         return os.path.exists(os.path.join(self.curdir, path))
 
 
diff --git a/src/aiida/transports/plugins/ssh.py b/src/aiida/transports/plugins/ssh.py
index 6858da5d2a..8cfe607a34 100644
--- a/src/aiida/transports/plugins/ssh.py
+++ b/src/aiida/transports/plugins/ssh.py
@@ -19,8 +19,9 @@
 from aiida.cmdline.params import options
 from aiida.cmdline.params.types.path import AbsolutePathOrEmptyParamType
 from aiida.common.escaping import escape_for_bash
+from aiida.common.warnings import warn_deprecation
 
-from ..transport import Transport, TransportInternalError
+from ..transport import Transport, TransportInternalError, TransportPath, path_to_str
 
 __all__ = ('SshTransport', 'convert_to_bool', 'parse_sshconfig')
 
@@ -230,6 +231,10 @@ class SshTransport(Transport):
     # if too large commands are sent, clogging the outputs or logs
     _MAX_EXEC_COMMAND_LOG_SIZE = None
 
+    # NOTE: all the methods that start with _get_ are class methods that
+    # return a suggestion for the specific field. They are being used in
+    # a function called transport_option_default in transports/cli.py,
+    # during an interactive `verdi computer configure` command.
     @classmethod
     def _get_username_suggestion_string(cls, computer):
         """Return a suggestion for the specific field."""
@@ -580,7 +585,7 @@ def __str__(self):
 
         return f"{'OPEN' if self._is_open else 'CLOSED'} [{conn_info}]"
 
-    def chdir(self, path):
+    def chdir(self, path: TransportPath):
         """
         PLEASE DON'T USE `chdir()` IN NEW DEVELOPMENTS, INSTEAD DIRECTLY PASS ABSOLUTE PATHS TO INTERFACE.
         `chdir()` is DEPRECATED and will be removed in the next major version.
@@ -590,8 +595,13 @@ def chdir(self, path):
         Differently from paramiko, if you pass None to chdir, nothing
         happens and the cwd is unchanged.
         """
+        warn_deprecation(
+            '`chdir()` is deprecated and will be removed in the next major version.',
+            version=3,
+        )
         from paramiko.sftp import SFTPError
 
+        path = path_to_str(path)
         old_path = self.sftp.getcwd()
         if path is not None:
             try:
@@ -618,11 +628,13 @@ def chdir(self, path):
                 self.chdir(old_path)
             raise OSError(str(exc))
 
-    def normalize(self, path='.'):
+    def normalize(self, path: TransportPath = '.'):
         """Returns the normalized path (removing double slashes, etc...)"""
+        path = path_to_str(path)
+
         return self.sftp.normalize(path)
 
-    def stat(self, path):
+    def stat(self, path: TransportPath):
         """Retrieve information about a file on the remote system.  The return
         value is an object whose attributes correspond to the attributes of
         Python's ``stat`` structure as returned by ``os.stat``, except that it
@@ -635,9 +647,11 @@ def stat(self, path):
         :return: a `paramiko.sftp_attr.SFTPAttributes` object containing
             attributes about the given file.
         """
+        path = path_to_str(path)
+
         return self.sftp.stat(path)
 
-    def lstat(self, path):
+    def lstat(self, path: TransportPath):
         """Retrieve information about a file on the remote system, without
         following symbolic links (shortcuts). This otherwise behaves exactly
         the same as `stat`.
@@ -647,6 +661,8 @@ def lstat(self, path):
         :return: a `paramiko.sftp_attr.SFTPAttributes` object containing
             attributes about the given file.
         """
+        path = path_to_str(path)
+
         return self.sftp.lstat(path)
 
     def getcwd(self):
@@ -659,9 +675,13 @@ def getcwd(self):
         this method will return None. But in __enter__ this is set explicitly,
         so this should never happen within this class.
         """
+        warn_deprecation(
+            '`chdir()` is deprecated and will be removed in the next major version.',
+            version=3,
+        )
         return self.sftp.getcwd()
 
-    def makedirs(self, path, ignore_existing=False):
+    def makedirs(self, path: TransportPath, ignore_existing: bool = False):
         """Super-mkdir; create a leaf directory and all intermediate ones.
         Works like mkdir, except that any intermediate path segment (not
         just the rightmost) will be created if it does not exist.
@@ -676,6 +696,8 @@ def makedirs(self, path, ignore_existing=False):
 
         :raise OSError: If the directory already exists.
         """
+        path = path_to_str(path)
+
         # check to avoid creation of empty dirs
         path = os.path.normpath(path)
 
@@ -697,7 +719,7 @@ def makedirs(self, path, ignore_existing=False):
             if not self.isdir(this_dir):
                 self.mkdir(this_dir)
 
-    def mkdir(self, path, ignore_existing=False):
+    def mkdir(self, path: TransportPath, ignore_existing: bool = False):
         """Create a folder (directory) named path.
 
         :param path: name of the folder to create
@@ -706,6 +728,8 @@ def mkdir(self, path, ignore_existing=False):
 
         :raise OSError: If the directory already exists.
         """
+        path = path_to_str(path)
+
         if ignore_existing and self.isdir(path):
             return
 
@@ -725,7 +749,7 @@ def mkdir(self, path, ignore_existing=False):
                     'or the directory already exists? ({})'.format(path, self.getcwd(), exc)
                 )
 
-    def rmtree(self, path):
+    def rmtree(self, path: TransportPath):
         """Remove a file or a directory at path, recursively
         Flags used: -r: recursive copy; -f: force, makes the command non interactive;
 
@@ -733,6 +757,7 @@ def rmtree(self, path):
 
         :raise OSError: if the rm execution failed.
         """
+        path = path_to_str(path)
         # Assuming linux rm command!
 
         rm_exe = 'rm'
@@ -752,25 +777,29 @@ def rmtree(self, path):
         self.logger.error(f"Problem executing rm. Exit code: {retval}, stdout: '{stdout}', stderr: '{stderr}'")
         raise OSError(f'Error while executing rm. Exit code: {retval}')
 
-    def rmdir(self, path):
+    def rmdir(self, path: TransportPath):
         """Remove the folder named 'path' if empty."""
+        path = path_to_str(path)
         self.sftp.rmdir(path)
 
-    def chown(self, path, uid, gid):
+    def chown(self, path: TransportPath, uid, gid):
         """Change owner permissions of a file.
 
         For now, this is not implemented for the SSH transport.
         """
         raise NotImplementedError
 
-    def isdir(self, path):
+    def isdir(self, path: TransportPath):
         """Return True if the given path is a directory, False otherwise.
         Return False also if the path does not exist.
         """
         # Return False on empty string (paramiko would map this to the local
         # folder instead)
+        path = path_to_str(path)
+
         if not path:
             return False
+        path = path_to_str(path)
         try:
             return S_ISDIR(self.stat(path).st_mode)
         except OSError as exc:
@@ -779,21 +808,24 @@ def isdir(self, path):
                 return False
             raise  # Typically if I don't have permissions (errno=13)
 
-    def chmod(self, path, mode):
+    def chmod(self, path: TransportPath, mode):
         """Change permissions to path
 
         :param path: path to file
         :param mode: new permission bits (integer)
         """
+        path = path_to_str(path)
+
         if not path:
             raise OSError('Input path is an empty argument.')
         return self.sftp.chmod(path, mode)
 
     @staticmethod
-    def _os_path_split_asunder(path):
-        """Used by makedirs. Takes path (a str)
+    def _os_path_split_asunder(path: TransportPath):
+        """Used by makedirs. Takes path
         and returns a list deconcatenating the path
         """
+        path = path_to_str(path)
         parts = []
         while True:
             newpath, tail = os.path.split(path)
@@ -807,7 +839,15 @@ def _os_path_split_asunder(path):
         parts.reverse()
         return parts
 
-    def put(self, localpath, remotepath, callback=None, dereference=True, overwrite=True, ignore_nonexisting=False):
+    def put(
+        self,
+        localpath: TransportPath,
+        remotepath: TransportPath,
+        callback=None,
+        dereference: bool = True,
+        overwrite: bool = True,
+        ignore_nonexisting: bool = False,
+    ):
         """Put a file or a folder from local to remote.
         Redirects to putfile or puttree.
 
@@ -821,6 +861,9 @@ def put(self, localpath, remotepath, callback=None, dereference=True, overwrite=
         :raise ValueError: if local path is invalid
         :raise OSError: if the localpath does not exist
         """
+        localpath = path_to_str(localpath)
+        remotepath = path_to_str(remotepath)
+
         if not dereference:
             raise NotImplementedError
 
@@ -871,7 +914,14 @@ def put(self, localpath, remotepath, callback=None, dereference=True, overwrite=
         elif not ignore_nonexisting:
             raise OSError(f'The local path {localpath} does not exist')
 
-    def putfile(self, localpath, remotepath, callback=None, dereference=True, overwrite=True):
+    def putfile(
+        self,
+        localpath: TransportPath,
+        remotepath: TransportPath,
+        callback=None,
+        dereference: bool = True,
+        overwrite: bool = True,
+    ):
         """Put a file from local to remote.
 
         :param localpath: an (absolute) local path
@@ -883,6 +933,9 @@ def putfile(self, localpath, remotepath, callback=None, dereference=True, overwr
         :raise OSError: if the localpath does not exist,
                     or unintentionally overwriting
         """
+        localpath = path_to_str(localpath)
+        remotepath = path_to_str(remotepath)
+
         if not dereference:
             raise NotImplementedError
 
@@ -894,7 +947,14 @@ def putfile(self, localpath, remotepath, callback=None, dereference=True, overwr
 
         return self.sftp.put(localpath, remotepath, callback=callback)
 
-    def puttree(self, localpath, remotepath, callback=None, dereference=True, overwrite=True):
+    def puttree(
+        self,
+        localpath: TransportPath,
+        remotepath: TransportPath,
+        callback=None,
+        dereference: bool = True,
+        overwrite: bool = True,
+    ):
         """Put a folder recursively from local to remote.
 
         By default, overwrite.
@@ -913,6 +973,9 @@ def puttree(self, localpath, remotepath, callback=None, dereference=True, overwr
         .. note:: setting dereference equal to True could cause infinite loops.
               see os.walk() documentation
         """
+        localpath = path_to_str(localpath)
+        remotepath = path_to_str(remotepath)
+
         if not dereference:
             raise NotImplementedError
 
@@ -958,7 +1021,15 @@ def puttree(self, localpath, remotepath, callback=None, dereference=True, overwr
                 this_remote_file = os.path.join(remotepath, this_basename, this_file)
                 self.putfile(this_local_file, this_remote_file)
 
-    def get(self, remotepath, localpath, callback=None, dereference=True, overwrite=True, ignore_nonexisting=False):
+    def get(
+        self,
+        remotepath: TransportPath,
+        localpath: TransportPath,
+        callback=None,
+        dereference: bool = True,
+        overwrite: bool = True,
+        ignore_nonexisting: bool = False,
+    ):
         """Get a file or folder from remote to local.
         Redirects to getfile or gettree.
 
@@ -973,6 +1044,9 @@ def get(self, remotepath, localpath, callback=None, dereference=True, overwrite=
         :raise ValueError: if local path is invalid
         :raise OSError: if the remotepath is not found
         """
+        remotepath = path_to_str(remotepath)
+        localpath = path_to_str(localpath)
+
         if not dereference:
             raise NotImplementedError
 
@@ -1020,7 +1094,14 @@ def get(self, remotepath, localpath, callback=None, dereference=True, overwrite=
         else:
             raise OSError(f'The remote path {remotepath} does not exist')
 
-    def getfile(self, remotepath, localpath, callback=None, dereference=True, overwrite=True):
+    def getfile(
+        self,
+        remotepath: TransportPath,
+        localpath: TransportPath,
+        callback=None,
+        dereference: bool = True,
+        overwrite: bool = True,
+    ):
         """Get a file from remote to local.
 
         :param remotepath: a remote path
@@ -1031,6 +1112,9 @@ def getfile(self, remotepath, localpath, callback=None, dereference=True, overwr
         :raise ValueError: if local path is invalid
         :raise OSError: if unintentionally overwriting
         """
+        remotepath = path_to_str(remotepath)
+        localpath = path_to_str(localpath)
+
         if not os.path.isabs(localpath):
             raise ValueError('localpath must be an absolute path')
 
@@ -1050,7 +1134,14 @@ def getfile(self, remotepath, localpath, callback=None, dereference=True, overwr
                 pass
             raise
 
-    def gettree(self, remotepath, localpath, callback=None, dereference=True, overwrite=True):
+    def gettree(
+        self,
+        remotepath: TransportPath,
+        localpath: TransportPath,
+        callback=None,
+        dereference: bool = True,
+        overwrite: bool = True,
+    ):
         """Get a folder recursively from remote to local.
 
         :param remotepath: a remote path
@@ -1059,12 +1150,14 @@ def gettree(self, remotepath, localpath, callback=None, dereference=True, overwr
             Default = True (default behaviour in paramiko).
             False is not implemented.
         :param  overwrite: if True overwrites files and folders.
-            Default = False
+            Default = True
 
         :raise ValueError: if local path is invalid
         :raise OSError: if the remotepath is not found
         :raise OSError: if unintentionally overwriting
         """
+        remotepath = path_to_str(remotepath)
+        localpath = path_to_str(localpath)
         if not dereference:
             raise NotImplementedError
 
@@ -1101,10 +1194,11 @@ def gettree(self, remotepath, localpath, callback=None, dereference=True, overwr
             else:
                 self.getfile(os.path.join(remotepath, item), os.path.join(dest, item))
 
-    def get_attribute(self, path):
+    def get_attribute(self, path: TransportPath):
         """Returns the object Fileattribute, specified in aiida.transports
         Receives in input the path of a given file.
         """
+        path = path_to_str(path)
         from aiida.transports.util import FileAttribute
 
         paramiko_attr = self.lstat(path)
@@ -1115,13 +1209,25 @@ def get_attribute(self, path):
             aiida_attr[key] = getattr(paramiko_attr, key)
         return aiida_attr
 
-    def copyfile(self, remotesource, remotedestination, dereference=False):
+    def copyfile(self, remotesource: TransportPath, remotedestination: TransportPath, dereference: bool = False):
+        remotesource = path_to_str(remotesource)
+        remotedestination = path_to_str(remotedestination)
+
         return self.copy(remotesource, remotedestination, dereference)
 
-    def copytree(self, remotesource, remotedestination, dereference=False):
+    def copytree(self, remotesource: TransportPath, remotedestination: TransportPath, dereference: bool = False):
+        remotesource = path_to_str(remotesource)
+        remotedestination = path_to_str(remotedestination)
+
         return self.copy(remotesource, remotedestination, dereference, recursive=True)
 
-    def copy(self, remotesource, remotedestination, dereference=False, recursive=True):
+    def copy(
+        self,
+        remotesource: TransportPath,
+        remotedestination: TransportPath,
+        dereference: bool = False,
+        recursive: bool = True,
+    ):
         """Copy a file or a directory from remote source to remote destination.
         Flags used: ``-r``: recursive copy; ``-f``: force, makes the command non interactive;
         ``-L`` follows symbolic links
@@ -1138,6 +1244,9 @@ def copy(self, remotesource, remotedestination, dereference=False, recursive=Tru
 
         .. note:: setting dereference equal to True could cause infinite loops.
         """
+        remotesource = path_to_str(remotesource)
+        remotedestination = path_to_str(remotedestination)
+
         # In the majority of cases, we should deal with linux cp commands
         cp_flags = '-f'
         if recursive:
@@ -1179,7 +1288,7 @@ def copy(self, remotesource, remotedestination, dereference=False, recursive=Tru
         else:
             self._exec_cp(cp_exe, cp_flags, remotesource, remotedestination)
 
-    def _exec_cp(self, cp_exe, cp_flags, src, dst):
+    def _exec_cp(self, cp_exe: str, cp_flags: str, src: str, dst: str):
         """Execute the ``cp`` command on the remote machine."""
         # to simplify writing the above copy function
         command = f'{cp_exe} {cp_flags} {escape_for_bash(src)} {escape_for_bash(dst)}'
@@ -1205,7 +1314,7 @@ def _exec_cp(self, cp_exe, cp_flags, src, dst):
             )
 
     @staticmethod
-    def _local_listdir(path, pattern=None):
+    def _local_listdir(path: str, pattern=None):
         """Acts on the local folder, for the rest, same as listdir"""
         if not pattern:
             return os.listdir(path)
@@ -1219,13 +1328,15 @@ def _local_listdir(path, pattern=None):
             base_dir += os.sep
         return [re.sub(base_dir, '', i) for i in filtered_list]
 
-    def listdir(self, path='.', pattern=None):
+    def listdir(self, path: TransportPath = '.', pattern=None):
         """Get the list of files at path.
 
         :param path: default = '.'
         :param pattern: returns the list of files matching pattern.
                              Unix only. (Use to emulate ``ls *`` for example)
         """
+        path = path_to_str(path)
+
         if path.startswith('/'):
             abs_dir = path
         else:
@@ -1239,33 +1350,41 @@ def listdir(self, path='.', pattern=None):
             abs_dir += '/'
         return [re.sub(abs_dir, '', i) for i in filtered_list]
 
-    def remove(self, path):
+    def remove(self, path: TransportPath):
         """Remove a single file at 'path'"""
+        path = path_to_str(path)
         return self.sftp.remove(path)
 
-    def rename(self, oldpath, newpath):
+    def rename(self, oldpath: TransportPath, newpath: TransportPath):
         """Rename a file or folder from oldpath to newpath.
 
         :param str oldpath: existing name of the file or folder
         :param str newpath: new name for the file or folder
 
         :raises OSError: if oldpath/newpath is not found
-        :raises ValueError: if sroldpathc/newpath is not a valid string
+        :raises ValueError: if sroldpathc/newpath is not a valid path
         """
         if not oldpath:
-            raise ValueError(f'Source {oldpath} is not a valid string')
+            raise ValueError(f'Source {oldpath} is not a valid path')
         if not newpath:
-            raise ValueError(f'Destination {newpath} is not a valid string')
+            raise ValueError(f'Destination {newpath} is not a valid path')
+
+        oldpath = path_to_str(oldpath)
+        newpath = path_to_str(newpath)
+
         if not self.isfile(oldpath):
             if not self.isdir(oldpath):
                 raise OSError(f'Source {oldpath} does not exist')
+        # TODO: this seems to be a bug (?)
+        # why to raise an OSError if the newpath does not exist?
+        # ofcourse newpath shouldn't exist, that's why we are renaming it!
         if not self.isfile(newpath):
             if not self.isdir(newpath):
                 raise OSError(f'Destination {newpath} does not exist')
 
         return self.sftp.rename(oldpath, newpath)
 
-    def isfile(self, path):
+    def isfile(self, path: TransportPath):
         """Return True if the given path is a file, False otherwise.
         Return False also if the path does not exist.
         """
@@ -1274,6 +1393,8 @@ def isfile(self, path):
         # but this is just to be sure
         if not path:
             return False
+
+        path = path_to_str(path)
         try:
             self.logger.debug(
                 f"stat for path '{path}' ('{self.normalize(path)}'): {self.stat(path)} [{self.stat(path).st_mode}]"
@@ -1334,7 +1455,7 @@ def _exec_command_internal(self, command, combine_stderr=False, bufsize=-1, work
         return stdin, stdout, stderr, channel
 
     def exec_command_wait_bytes(
-        self, command, stdin=None, combine_stderr=False, bufsize=-1, timeout=0.01, workdir=None
+        self, command, stdin=None, combine_stderr=False, bufsize=-1, timeout=0.01, workdir: TransportPath = None
     ):
         """Executes the specified command and waits for it to finish.
 
@@ -1354,6 +1475,9 @@ def exec_command_wait_bytes(
         import socket
         import time
 
+        if workdir:
+            workdir = path_to_str(workdir)
+
         ssh_stdin, stdout, stderr, channel = self._exec_command_internal(
             command, combine_stderr, bufsize=bufsize, workdir=workdir
         )
@@ -1447,10 +1571,12 @@ def exec_command_wait_bytes(
 
         return (retval, b''.join(stdout_bytes), b''.join(stderr_bytes))
 
-    def gotocomputer_command(self, remotedir):
+    def gotocomputer_command(self, remotedir: TransportPath):
         """Specific gotocomputer string to connect to a given remote computer via
         ssh and directly go to the calculation folder.
         """
+        remotedir = path_to_str(remotedir)
+
         further_params = []
         if 'username' in self._connect_args:
             further_params.append(f"-l {escape_for_bash(self._connect_args['username'])}")
@@ -1473,21 +1599,25 @@ def gotocomputer_command(self, remotedir):
         cmd = f'ssh -t {self._machine} {further_params_str} {connect_string}'
         return cmd
 
-    def _symlink(self, source, dest):
+    def _symlink(self, source: TransportPath, dest: TransportPath):
         """Wrap SFTP symlink call without breaking API
 
         :param source: source of link
         :param dest: link to create
         """
+        source = path_to_str(source)
+        dest = path_to_str(dest)
         self.sftp.symlink(source, dest)
 
-    def symlink(self, remotesource, remotedestination):
+    def symlink(self, remotesource: TransportPath, remotedestination: TransportPath):
         """Create a symbolic link between the remote source and the remote
         destination.
 
         :param remotesource: remote source. Can contain a pattern.
         :param remotedestination: remote destination
         """
+        remotesource = path_to_str(remotesource)
+        remotedestination = path_to_str(remotedestination)
         # paramiko gives some errors if path is starting with '.'
         source = os.path.normpath(remotesource)
         dest = os.path.normpath(remotedestination)
@@ -1495,7 +1625,7 @@ def symlink(self, remotesource, remotedestination):
         if self.has_magic(source):
             if self.has_magic(dest):
                 # if there are patterns in dest, I don't know which name to assign
-                raise ValueError('Remotedestination cannot have patterns')
+                raise ValueError('`remotedestination` cannot have patterns')
 
             # find all files matching pattern
             for this_source in self.glob(source):
@@ -1505,10 +1635,12 @@ def symlink(self, remotesource, remotedestination):
         else:
             self._symlink(source, dest)
 
-    def path_exists(self, path):
+    def path_exists(self, path: TransportPath):
         """Check if path exists"""
         import errno
 
+        path = path_to_str(path)
+
         try:
             self.stat(path)
         except OSError as exc:
diff --git a/src/aiida/transports/plugins/ssh_async.py b/src/aiida/transports/plugins/ssh_async.py
new file mode 100644
index 0000000000..307cffbbfa
--- /dev/null
+++ b/src/aiida/transports/plugins/ssh_async.py
@@ -0,0 +1,1271 @@
+###########################################################################
+# Copyright (c), The AiiDA team. All rights reserved.                     #
+# This file is part of the AiiDA code.                                    #
+#                                                                         #
+# The code is hosted on GitHub at https://github.com/aiidateam/aiida-core #
+# For further information on the license, see the LICENSE.txt file        #
+# For further information please visit http://www.aiida.net               #
+###########################################################################
+"""Plugin for transport over SSH asynchronously."""
+
+## TODO: put & get methods could be simplified with the asyncssh.sftp.mget() & put() method or sftp.glob()
+import asyncio
+import glob
+import os
+from pathlib import Path, PurePath
+from typing import Optional, Union
+
+import asyncssh
+import click
+from asyncssh import SFTPFileAlreadyExists
+
+from aiida.common.escaping import escape_for_bash
+from aiida.common.exceptions import InvalidOperation
+from aiida.transports.transport import (
+    AsyncTransport,
+    Transport,
+    TransportInternalError,
+    TransportPath,
+    path_to_str,
+    validate_positive_number,
+)
+
+__all__ = ('AsyncSshTransport',)
+
+
+def validate_script(ctx, param, value: str):
+    if value == 'None':
+        return value
+    if not os.path.isabs(value):
+        raise click.BadParameter(f'{value} is not an absolute path')
+    if not os.path.isfile(value):
+        raise click.BadParameter(f'The script file: {value} does not exist')
+    if not os.access(value, os.X_OK):
+        raise click.BadParameter(f'The script {value} is not executable')
+    return value
+
+
+def validate_machine(ctx, param, value: str):
+    async def attempt_connection():
+        try:
+            await asyncssh.connect(value)
+        except Exception:
+            return False
+        return True
+
+    if not asyncio.run(attempt_connection()):
+        raise click.BadParameter("Couldn't connect! " 'Please make sure `ssh {value}` would work without password')
+    else:
+        click.echo(f'`ssh {value}` successful!')
+
+    return value
+
+
+class AsyncSshTransport(AsyncTransport):
+    """Transport plugin via SSH, asynchronously."""
+
+    _DEFAULT_max_io_allowed = 8
+
+    # note, I intentionally wanted to keep connection parameters as simple as possible.
+    _valid_auth_options = [
+        (
+            # the underscore is added to avoid conflict with the machine property
+            # which is passed to __init__ as parameter `machine=computer.hostname`
+            'machine_or_host',
+            {
+                'type': str,
+                'prompt': 'Machine(or host) name as in `ssh <your-host-name>` command.'
+                ' (It should be a password-less setup)',
+                'help': 'Password-less host-setup to connect, as in command `ssh <your-host-name>`. '
+                "You'll need to have a `Host <your-host-name>` entry defined in your `~/.ssh/config` file.",
+                'non_interactive_default': True,
+                'callback': validate_machine,
+            },
+        ),
+        (
+            'max_io_allowed',
+            {
+                'type': int,
+                'default': _DEFAULT_max_io_allowed,
+                'prompt': 'Maximum number of concurrent I/O operations.',
+                'help': 'Depends on various factors, such as your network bandwidth, the server load, etc.'
+                ' (An experimental number)',
+                'non_interactive_default': True,
+                'callback': validate_positive_number,
+            },
+        ),
+        (
+            'script_before',
+            {
+                'type': str,
+                'default': 'None',
+                'prompt': 'Local script to run *before* opening connection (path)',
+                'help': ' (optional) Specify a script to run *before* opening SSH connection. '
+                'The script should be executable',
+                'non_interactive_default': True,
+                'callback': validate_script,
+            },
+        ),
+    ]
+
+    @classmethod
+    def _get_machine_suggestion_string(cls, computer):
+        """Return a suggestion for the parameter machine."""
+        # Originally set as 'Hostname' during `verdi computer setup`
+        # and is passed as `machine=computer.hostname` in the codebase
+        # unfortunately, name of hostname and machine are used interchangeably in the aiida-core codebase
+        # TODO: open an issue to unify the naming
+        return computer.hostname
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # the machine is passed as `machine=computer.hostname` in the codebase
+        # 'machine' is immutable.
+        # 'machine_or_host' is mutable, so it can be changed via command:
+        # 'verdi computer configure core.ssh_async <LABEL>'.
+        # by default, 'machine_or_host' is set to 'machine' in the __init__ method, if not provided.
+        # NOTE: to guarantee a connection,
+        # a computer with core.ssh_async transport plugin should be configured before any instantiation.
+        self.machine = kwargs.pop('machine_or_host', kwargs.pop('machine'))
+        self._max_io_allowed = kwargs.pop('max_io_allowed', self._DEFAULT_max_io_allowed)
+        self.script_before = kwargs.pop('script_before', 'None')
+
+        self._concurrent_io = 0
+
+    @property
+    def max_io_allowed(self):
+        return self._max_io_allowed
+
+    async def _lock(self, sleep_time=0.5):
+        while self._concurrent_io >= self.max_io_allowed:
+            await asyncio.sleep(sleep_time)
+        self._concurrent_io += 1
+
+    async def _unlock(self):
+        self._concurrent_io -= 1
+
+    async def open_async(self):
+        """Open the transport.
+        This plugin supports running scripts before and during the connection.
+        The scripts are run locally, not on the remote machine.
+
+        :raises InvalidOperation: if the transport is already open
+        """
+        if self._is_open:
+            raise InvalidOperation('Cannot open the transport twice')
+
+        if self.script_before != 'None':
+            os.system(f'{self.script_before}')
+
+        self._conn = await asyncssh.connect(self.machine)
+        self._sftp = await self._conn.start_sftp_client()
+
+        self._is_open = True
+
+        return self
+
+    async def close_async(self):
+        """Close the transport.
+
+        :raises InvalidOperation: if the transport is already closed
+        """
+        if not self._is_open:
+            raise InvalidOperation('Cannot close the transport: it is already closed')
+
+        self._conn.close()
+        await self._conn.wait_closed()
+        self._is_open = False
+
+    def __str__(self):
+        return f"{'OPEN' if self._is_open else 'CLOSED'} [AsyncSshTransport]"
+
+    async def get_async(
+        self,
+        remotepath: TransportPath,
+        localpath: TransportPath,
+        dereference=True,
+        overwrite=True,
+        ignore_nonexisting=False,
+        preserve=False,
+        *args,
+        **kwargs,
+    ):
+        """Get a file or folder from remote to local.
+        Redirects to getfile or gettree.
+
+        :param remotepath: an absolute remote path
+        :param localpath: an absolute local path
+        :param dereference: follow symbolic links.
+            Default = True
+        :param overwrite: if True overwrites files and folders.
+            Default = False
+        :param ignore_nonexisting: if True, does not raise an error if the remotepath does not exist
+            Default = False
+        :param preserve: preserve file attributes
+            Default = False
+
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
+        :type overwrite: bool
+        :type ignore_nonexisting: bool
+        :type preserve: bool
+
+        :raise ValueError: if local path is invalid
+        :raise OSError: if the remotepath is not found
+        """
+        remotepath = path_to_str(remotepath)
+        localpath = path_to_str(localpath)
+
+        if not os.path.isabs(localpath):
+            raise ValueError('The localpath must be an absolute path')
+
+        ## TODO: this whole glob part can be simplified via the asyncssh glob
+        ## or by using the asyncssh.sftp.mget() method
+        if self.has_magic(remotepath):
+            if self.has_magic(localpath):
+                raise ValueError('Pathname patterns are not allowed in the destination')
+            # use the self glob to analyze the path remotely
+            to_copy_list = await self.glob_async(remotepath)
+
+            rename_local = False
+            if len(to_copy_list) > 1:
+                # I can't scp more than one file on a single file
+                if os.path.isfile(localpath):
+                    raise OSError('Remote destination is not a directory')
+                # I can't scp more than one file in a non existing directory
+                elif not os.path.exists(localpath):  # this should hold only for files
+                    raise OSError('Remote directory does not exist')
+                else:  # the remote path is a directory
+                    rename_local = True
+
+            for file in to_copy_list:
+                if await self.isfile_async(file):
+                    if rename_local:  # copying more than one file in one directory
+                        # here is the case isfile and more than one file
+                        remote = os.path.join(localpath, os.path.split(file)[1])
+                        await self.getfile_async(file, remote, dereference, overwrite, preserve)
+                    else:  # one file to copy on one file
+                        await self.getfile_async(file, localpath, dereference, overwrite, preserve)
+                else:
+                    await self.gettree_async(file, localpath, dereference, overwrite, preserve)
+
+        elif await self.isdir_async(remotepath):
+            await self.gettree_async(remotepath, localpath, dereference, overwrite, preserve)
+        elif await self.isfile_async(remotepath):
+            if os.path.isdir(localpath):
+                remote = os.path.join(localpath, os.path.split(remotepath)[1])
+                await self.getfile_async(remotepath, remote, dereference, overwrite, preserve)
+            else:
+                await self.getfile_async(remotepath, localpath, dereference, overwrite, preserve)
+        elif ignore_nonexisting:
+            pass
+        else:
+            raise OSError(f'The remote path {remotepath} does not exist')
+
+    async def getfile_async(
+        self,
+        remotepath: TransportPath,
+        localpath: TransportPath,
+        dereference=True,
+        overwrite=True,
+        preserve=False,
+        *args,
+        **kwargs,
+    ):
+        """Get a file from remote to local.
+
+        :param remotepath: an absolute remote path
+        :param localpath: an absolute local path
+        :param overwrite: if True overwrites files and folders.
+            Default = False
+        :param dereference: follow symbolic links.
+            Default = True
+        :param preserve: preserve file attributes
+            Default = False
+
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
+        :type overwrite: bool
+        :type preserve: bool
+
+        :raise ValueError: if local path is invalid
+        :raise OSError: if unintentionally overwriting
+        """
+        remotepath = path_to_str(remotepath)
+        localpath = path_to_str(localpath)
+
+        if not os.path.isabs(localpath):
+            raise ValueError('localpath must be an absolute path')
+
+        if os.path.isfile(localpath) and not overwrite:
+            raise OSError('Destination already exists: not overwriting it')
+
+        try:
+            await self._lock()
+            await self._sftp.get(
+                remotepaths=remotepath,
+                localpath=localpath,
+                preserve=preserve,
+                recurse=False,
+                follow_symlinks=dereference,
+            )
+            await self._unlock()
+        except (OSError, asyncssh.Error) as exc:
+            raise OSError(f'Error while uploading file {localpath}: {exc}')
+
+    async def gettree_async(
+        self,
+        remotepath: TransportPath,
+        localpath: TransportPath,
+        dereference=True,
+        overwrite=True,
+        preserve=False,
+        *args,
+        **kwargs,
+    ):
+        """Get a folder recursively from remote to local.
+
+        :param remotepath: an absolute remote path
+        :param localpath: an absolute local path
+        :param dereference: follow symbolic links.
+            Default = True
+        :param  overwrite: if True overwrites files and folders.
+            Default = True
+        :param preserve: preserve file attributes
+            Default = False
+
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
+        :type overwrite: bool
+        :type preserve: bool
+
+        :raise ValueError: if local path is invalid
+        :raise OSError: if the remotepath is not found
+        :raise OSError: if unintentionally overwriting
+        """
+        remotepath = path_to_str(remotepath)
+        localpath = path_to_str(localpath)
+
+        if not remotepath:
+            raise OSError('Remotepath must be a non empty string')
+        if not localpath:
+            raise ValueError('Localpaths must be a non empty string')
+
+        if not os.path.isabs(localpath):
+            raise ValueError('Localpaths must be an absolute path')
+
+        if not await self.isdir_async(remotepath):
+            raise OSError(f'Input remotepath is not a folder: {localpath}')
+
+        if os.path.exists(localpath) and not overwrite:
+            raise OSError("Can't overwrite existing files")
+        if os.path.isfile(localpath):
+            raise OSError('Cannot copy a directory into a file')
+
+        if not os.path.isdir(localpath):  # in this case copy things in the remotepath directly
+            os.makedirs(localpath, exist_ok=True)  # and make a directory at its place
+        else:  # localpath exists already: copy the folder inside of it!
+            localpath = os.path.join(localpath, os.path.split(remotepath)[1])
+            os.makedirs(localpath, exist_ok=overwrite)  # create a nested folder
+
+        content_list = await self.listdir_async(remotepath)
+        for content_ in content_list:
+            try:
+                await self._lock()
+                await self._sftp.get(
+                    remotepaths=PurePath(remotepath) / content_,
+                    localpath=localpath,
+                    preserve=preserve,
+                    recurse=True,
+                    follow_symlinks=dereference,
+                )
+                await self._unlock()
+            except (OSError, asyncssh.Error) as exc:
+                raise OSError(f'Error while uploading file {localpath}: {exc}')
+
+    async def put_async(
+        self,
+        localpath: TransportPath,
+        remotepath: TransportPath,
+        dereference=True,
+        overwrite=True,
+        ignore_nonexisting=False,
+        preserve=False,
+        *args,
+        **kwargs,
+    ):
+        """Put a file or a folder from local to remote.
+        Redirects to putfile or puttree.
+
+        :param remotepath: an absolute remote path
+        :param localpath: an absolute local path
+        :param dereference: follow symbolic links
+            Default = True
+        :param  overwrite: if True overwrites files and folders
+            Default = False
+        :param ignore_nonexisting: if True, does not raise an error if the localpath does not exist
+            Default = False
+        :param preserve: preserve file attributes
+            Default = False
+
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
+        :type overwrite: bool
+        :type ignore_nonexisting: bool
+        :type preserve: bool
+
+        :raise ValueError: if local path is invalid
+        :raise OSError: if the localpath does not exist
+        """
+        localpath = path_to_str(localpath)
+        remotepath = path_to_str(remotepath)
+
+        if not os.path.isabs(localpath):
+            raise ValueError('The localpath must be an absolute path')
+
+        # TODO: this whole glob part can be simplified via the asyncssh glob
+        if self.has_magic(localpath):
+            if self.has_magic(remotepath):
+                raise ValueError('Pathname patterns are not allowed in the destination')
+
+            # use the imported glob to analyze the path locally
+            to_copy_list = glob.glob(localpath)
+
+            rename_remote = False
+            if len(to_copy_list) > 1:
+                # I can't scp more than one file on a single file
+                if await self.isfile_async(remotepath):
+                    raise OSError('Remote destination is not a directory')
+                # I can't scp more than one file in a non existing directory
+                elif not await self.path_exists_async(remotepath):
+                    raise OSError('Remote directory does not exist')
+                else:  # the remote path is a directory
+                    rename_remote = True
+
+            for file in to_copy_list:
+                if os.path.isfile(file):
+                    if rename_remote:  # copying more than one file in one directory
+                        # here is the case isfile and more than one file
+                        remotefile = os.path.join(remotepath, os.path.split(file)[1])
+                        await self.putfile_async(file, remotefile, dereference, overwrite, preserve)
+
+                    elif await self.isdir_async(remotepath):  # one file to copy in '.'
+                        remotefile = os.path.join(remotepath, os.path.split(file)[1])
+                        await self.putfile_async(file, remotefile, dereference, overwrite, preserve)
+                    else:  # one file to copy on one file
+                        await self.putfile_async(file, remotepath, dereference, overwrite, preserve)
+                else:
+                    await self.puttree_async(file, remotepath, dereference, overwrite, preserve)
+
+        elif os.path.isdir(localpath):
+            await self.puttree_async(localpath, remotepath, dereference, overwrite, preserve)
+        elif os.path.isfile(localpath):
+            if await self.isdir_async(remotepath):
+                remote = os.path.join(remotepath, os.path.split(localpath)[1])
+                await self.putfile_async(localpath, remote, dereference, overwrite, preserve)
+            else:
+                await self.putfile_async(localpath, remotepath, dereference, overwrite, preserve)
+        elif not ignore_nonexisting:
+            raise OSError(f'The local path {localpath} does not exist')
+
+    async def putfile_async(
+        self,
+        localpath: TransportPath,
+        remotepath: TransportPath,
+        dereference=True,
+        overwrite=True,
+        preserve=False,
+        *args,
+        **kwargs,
+    ):
+        """Put a file from local to remote.
+
+        :param remotepath: an absolute remote path
+        :param localpath: an absolute local path
+        :param overwrite: if True overwrites files and folders
+            Default = True
+        :param preserve: preserve file attributes
+            Default = False
+
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
+        :type overwrite: bool
+        :type preserve: bool
+
+        :raise ValueError: if local path is invalid
+        :raise OSError: if the localpath does not exist,
+                    or unintentionally overwriting
+        """
+        localpath = path_to_str(localpath)
+        remotepath = path_to_str(remotepath)
+
+        if not os.path.isabs(localpath):
+            raise ValueError('The localpath must be an absolute path')
+
+        if await self.isfile_async(remotepath) and not overwrite:
+            raise OSError('Destination already exists: not overwriting it')
+
+        try:
+            await self._lock()
+            await self._sftp.put(
+                localpaths=localpath,
+                remotepath=remotepath,
+                preserve=preserve,
+                recurse=False,
+                follow_symlinks=dereference,
+            )
+            await self._unlock()
+        except (OSError, asyncssh.Error) as exc:
+            raise OSError(f'Error while uploading file {localpath}: {exc}')
+
+    async def puttree_async(
+        self,
+        localpath: TransportPath,
+        remotepath: TransportPath,
+        dereference=True,
+        overwrite=True,
+        preserve=False,
+        *args,
+        **kwargs,
+    ):
+        """Put a folder recursively from local to remote.
+
+        :param localpath: an absolute local path
+        :param remotepath: an absolute remote path
+        :param dereference: follow symbolic links
+            Default = True
+        :param overwrite: if True overwrites files and folders (boolean).
+            Default = True
+        :param preserve: preserve file attributes
+            Default = False
+
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
+        :type overwrite: bool
+        :type preserve: bool
+
+        :raise ValueError: if local path is invalid
+        :raise OSError: if the localpath does not exist, or trying to overwrite
+        :raise OSError: if remotepath is invalid
+        """
+        localpath = path_to_str(localpath)
+        remotepath = path_to_str(remotepath)
+
+        if not os.path.isabs(localpath):
+            raise ValueError('The localpath must be an absolute path')
+
+        if not os.path.exists(localpath):
+            raise OSError('The localpath does not exists')
+
+        if not os.path.isdir(localpath):
+            raise ValueError(f'Input localpath is not a folder: {localpath}')
+
+        if not remotepath:
+            raise OSError('remotepath must be a non empty string')
+
+        if await self.path_exists_async(remotepath) and not overwrite:
+            raise OSError("Can't overwrite existing files")
+        if await self.isfile_async(remotepath):
+            raise OSError('Cannot copy a directory into a file')
+
+        if not await self.isdir_async(remotepath):  # in this case copy things in the remotepath directly
+            await self.mkdir_async(remotepath)  # and make a directory at its place
+        else:  # remotepath exists already: copy the folder inside of it!
+            remotepath = os.path.join(remotepath, os.path.split(localpath)[1])
+            await self.makedirs_async(remotepath, ignore_existing=overwrite)  # create a nested folder
+
+        # This is written in this way, only because AiiDA expects to put file inside an existing folder
+        # Or to put and rename the parent folder at the same time
+        content_list = os.listdir(localpath)
+        for content_ in content_list:
+            try:
+                await self._lock()
+                await self._sftp.put(
+                    localpaths=PurePath(localpath) / content_,
+                    remotepath=remotepath,
+                    preserve=preserve,
+                    recurse=True,
+                    follow_symlinks=dereference,
+                )
+                await self._unlock()
+            except (OSError, asyncssh.Error) as exc:
+                raise OSError(f'Error while uploading file {PurePath(localpath)/content_}: {exc}')
+
+    async def copy_async(
+        self,
+        remotesource: TransportPath,
+        remotedestination: TransportPath,
+        dereference: bool = False,
+        recursive: bool = True,
+        preserve: bool = False,
+    ):
+        """Copy a file or a folder from remote to remote.
+
+        :param remotesource: abs path to the remote source directory / file
+        :param remotedestination: abs path to the remote destination directory / file
+        :param dereference: follow symbolic links
+        :param recursive: copy recursively
+        :param preserve: preserve file attributes
+            Default = False
+
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
+        :type recursive: bool
+        :type preserve: bool
+
+        :raises: OSError, src does not exist or if the copy execution failed.
+        """
+
+        remotesource = path_to_str(remotesource)
+        remotedestination = path_to_str(remotedestination)
+        if self.has_magic(remotedestination):
+            raise ValueError('Pathname patterns are not allowed in the destination')
+
+        if not remotedestination:
+            raise ValueError('remotedestination must be a non empty string')
+        if not remotesource:
+            raise ValueError('remotesource must be a non empty string')
+
+        # SFTP.copy() supports remote copy only in very recent version OpenSSH 9.0 and later.
+        # For the older versions, it downloads the file and uploads it again!
+        # For performance reasons, we should check if the remote copy is supported, if so use
+        # self._sftp.mcopy() & self._sftp.copy() otherwise send a `cp` command to the remote machine.
+        # See here: https://github.com/ronf/asyncssh/issues/724
+        if self._sftp.supports_remote_copy:
+            try:
+                if self.has_magic(remotesource):
+                    await self._sftp.mcopy(
+                        remotesource,
+                        remotedestination,
+                        preserve=preserve,
+                        recurse=recursive,
+                        follow_symlinks=dereference,
+                        remote_only=True,
+                    )
+                else:
+                    if not await self.path_exists_async(remotesource):
+                        raise OSError(f'The remote path {remotesource} does not exist')
+                    await self._sftp.copy(
+                        remotesource,
+                        remotedestination,
+                        preserve=preserve,
+                        recurse=recursive,
+                        follow_symlinks=dereference,
+                        remote_only=True,
+                    )
+            except asyncssh.sftp.SFTPFailure as exc:
+                raise OSError(f'Error while copying {remotesource} to {remotedestination}: {exc}')
+        else:
+            self.logger.warning('The remote copy is not supported, using the `cp` command to copy the file/folder')
+            # I copy pasted the whole logic below from SshTransport class:
+
+            async def _exec_cp(cp_exe: str, cp_flags: str, src: str, dst: str):
+                """Execute the ``cp`` command on the remote machine."""
+                # to simplify writing the above copy function
+                command = f'{cp_exe} {cp_flags} {escape_for_bash(src)} {escape_for_bash(dst)}'
+
+                retval, stdout, stderr = await self.exec_command_wait_async(command)
+
+                if retval == 0:
+                    if stderr.strip():
+                        self.logger.warning(f'There was nonempty stderr in the cp command: {stderr}')
+                else:
+                    self.logger.error(
+                        "Problem executing cp. Exit code: {}, stdout: '{}', " "stderr: '{}', command: '{}'".format(
+                            retval, stdout, stderr, command
+                        )
+                    )
+                    if 'No such file or directory' in str(stderr):
+                        raise FileNotFoundError(f'Error while executing cp: {stderr}')
+
+                    raise OSError(
+                        'Error while executing cp. Exit code: {}, '
+                        "stdout: '{}', stderr: '{}', "
+                        "command: '{}'".format(retval, stdout, stderr, command)
+                    )
+
+            cp_exe = 'cp'
+            cp_flags = '-f'
+
+            if recursive:
+                cp_flags += ' -r'
+
+            if preserve:
+                cp_flags += ' -p'
+
+            if dereference:
+                # use -L; --dereference is not supported on mac
+                cp_flags += ' -L'
+
+            if self.has_magic(remotesource):
+                to_copy_list = await self.glob_async(remotesource)
+
+                if len(to_copy_list) > 1:
+                    if not await self.path_exists_async(remotedestination) or await self.isfile_async(
+                        remotedestination
+                    ):
+                        raise OSError("Can't copy more than one file in the same destination file")
+
+                for file in to_copy_list:
+                    await _exec_cp(cp_exe, cp_flags, file, remotedestination)
+
+            else:
+                await _exec_cp(cp_exe, cp_flags, remotesource, remotedestination)
+
+    async def copyfile_async(
+        self,
+        remotesource: TransportPath,
+        remotedestination: TransportPath,
+        dereference: bool = False,
+        preserve: bool = False,
+    ):
+        """Copy a file from remote to remote.
+
+        :param remotesource: path to the remote source file
+        :param remotedestination: path to the remote destination file
+        :param dereference: follow symbolic links
+        :param preserve: preserve file attributes
+            Default = False
+
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
+        :type preserve: bool
+
+        :raises: OSError, src does not exist or if the copy execution failed.
+        """
+        return await self.copy_async(remotesource, remotedestination, dereference, recursive=False, preserve=preserve)
+
+    async def copytree_async(
+        self,
+        remotesource: TransportPath,
+        remotedestination: TransportPath,
+        dereference: bool = False,
+        preserve: bool = False,
+    ):
+        """Copy a folder from remote to remote.
+
+        :param remotesource: path to the remote source directory
+        :param remotedestination: path to the remote destination directory
+        :param dereference: follow symbolic links
+        :param preserve: preserve file attributes
+            Default = False
+
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
+        :type preserve: bool
+
+        :raises: OSError, src does not exist or if the copy execution failed.
+        """
+        return await self.copy_async(remotesource, remotedestination, dereference, recursive=True, preserve=preserve)
+
+    async def exec_command_wait_async(
+        self,
+        command: str,
+        stdin: Optional[str] = None,
+        encoding: str = 'utf-8',
+        workdir: Optional[TransportPath] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        """Execute a command on the remote machine and wait for it to finish.
+
+        :param command: the command to execute
+        :param stdin: the input to pass to the command
+            Default = None
+        :param encoding: (IGNORED) this is here just to keep the same signature as the one in `Transport` class
+            Default = 'utf-8'
+        :param workdir: the working directory where to execute the command
+            Default = None
+        :param timeout: the timeout in seconds
+            Default = None
+
+        :type command: str
+        :type stdin: str
+        :type encoding: str
+        :type workdir:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type timeout: float
+
+        :return: a tuple with the return code, the stdout and the stderr of the command
+        :rtype: tuple(int, str, str)
+        """
+
+        if workdir:
+            workdir = path_to_str(workdir)
+            command = f'cd {workdir} && ( {command} )'
+
+        bash_commmand = self._bash_command_str + '-c '
+
+        result = await self._conn.run(
+            bash_commmand + escape_for_bash(command), input=stdin, check=False, timeout=timeout
+        )
+        # Since the command is str, both stdout and stderr are strings
+        return (result.returncode, ''.join(str(result.stdout)), ''.join(str(result.stderr)))
+
+    async def get_attribute_async(self, path: TransportPath):
+        """Return an object FixedFieldsAttributeDict for file in a given path,
+        as defined in aiida.common.extendeddicts
+        Each attribute object consists in a dictionary with the following keys:
+
+        * st_size: size of files, in bytes
+
+        * st_uid: user id of owner
+
+        * st_gid: group id of owner
+
+        * st_mode: protection bits
+
+        * st_atime: time of most recent access
+
+        * st_mtime: time of most recent modification
+
+        :param path: path to file
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :return: object FixedFieldsAttributeDict
+        """
+        path = path_to_str(path)
+        from aiida.transports.util import FileAttribute
+
+        asyncssh_attr = await self._sftp.lstat(path)
+        aiida_attr = FileAttribute()
+        # map the asyncssh class into the aiida one
+        for key in aiida_attr._valid_fields:
+            if key == 'st_size':
+                aiida_attr[key] = asyncssh_attr.size
+            elif key == 'st_uid':
+                aiida_attr[key] = asyncssh_attr.uid
+            elif key == 'st_gid':
+                aiida_attr[key] = asyncssh_attr.gid
+            elif key == 'st_mode':
+                aiida_attr[key] = asyncssh_attr.permissions
+            elif key == 'st_atime':
+                aiida_attr[key] = asyncssh_attr.atime
+            elif key == 'st_mtime':
+                aiida_attr[key] = asyncssh_attr.mtime
+            else:
+                raise NotImplementedError(f'Mapping the {key} attribute is not implemented')
+        return aiida_attr
+
+    async def isdir_async(self, path: TransportPath):
+        """Return True if the given path is a directory, False otherwise.
+        Return False also if the path does not exist.
+
+        :param path: the absolute path to check
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :return: True if the path is a directory, False otherwise
+        """
+        # Return False on empty string
+        if not path:
+            return False
+
+        path = path_to_str(path)
+
+        return await self._sftp.isdir(path)
+
+    async def isfile_async(self, path: TransportPath):
+        """Return True if the given path is a file, False otherwise.
+        Return False also if the path does not exist.
+
+        :param path: the absolute path to check
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :return: True if the path is a file, False otherwise
+        """
+        # Return False on empty string
+        if not path:
+            return False
+
+        path = path_to_str(path)
+
+        return await self._sftp.isfile(path)
+
+    async def listdir_async(self, path: TransportPath, pattern=None):
+        """Return a list of the names of the entries in the given path.
+        The list is in arbitrary order. It does not include the special
+        entries '.' and '..' even if they are present in the directory.
+
+        :param path: an absolute path
+        :param pattern: if used, listdir returns a list of files matching
+                        filters in Unix style. Unix only.
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :return: a list of strings
+        """
+        path = path_to_str(path)
+        if not pattern:
+            list_ = list(await self._sftp.listdir(path))
+        else:
+            patterned_path = pattern if pattern.startswith('/') else Path(path).joinpath(pattern)
+            # I put the type ignore here because the asyncssh.sftp.glob()
+            # method alwyas returns a sequence of str, if input is str
+            list_ = list(await self._sftp.glob(patterned_path))  # type: ignore[arg-type]
+
+        for item in ['..', '.']:
+            if item in list_:
+                list_.remove(item)
+
+        return list_
+
+    async def listdir_withattributes_async(self, path: TransportPath, pattern: Optional[str] = None):
+        """Return a list of the names of the entries in the given path.
+        The list is in arbitrary order. It does not include the special
+        entries '.' and '..' even if they are present in the directory.
+
+        :param path: absolute path to list
+        :param pattern: if used, listdir returns a list of files matching
+                            filters in Unix style. Unix only.
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type pattern: str
+        :return: a list of dictionaries, one per entry.
+            The schema of the dictionary is
+            the following::
+
+                {
+                   'name': String,
+                   'attributes': FileAttributeObject,
+                   'isdir': Bool
+                }
+
+            where 'name' is the file or folder directory, and any other information is metadata
+            (if the file is a folder, a directory, ...). 'attributes' behaves as the output of
+            transport.get_attribute(); isdir is a boolean indicating if the object is a directory or not.
+        """
+        path = path_to_str(path)
+        retlist = []
+        listdir = await self.listdir_async(path, pattern)
+        for file_name in listdir:
+            filepath = os.path.join(path, file_name)
+            attributes = await self.get_attribute_async(filepath)
+            retlist.append({'name': file_name, 'attributes': attributes, 'isdir': await self.isdir_async(filepath)})
+
+        return retlist
+
+    async def makedirs_async(self, path, ignore_existing=False):
+        """Super-mkdir; create a leaf directory and all intermediate ones.
+        Works like mkdir, except that any intermediate path segment (not
+        just the rightmost) will be created if it does not exist.
+
+        :param path: absolute path to directory to create
+        :param bool ignore_existing: if set to true, it doesn't give any error
+                if the leaf directory does already exist
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raises: OSError, if directory at path already exists
+        """
+        path = path_to_str(path)
+
+        try:
+            await self._sftp.makedirs(path, exist_ok=ignore_existing)
+        except SFTPFileAlreadyExists as exc:
+            raise OSError(f'Error while creating directory {path}: {exc}, directory already exists')
+        except asyncssh.sftp.SFTPFailure as exc:
+            if (self._sftp.version < 6) and not ignore_existing:
+                raise OSError(f'Error while creating directory {path}: {exc}, probably it already exists')
+            else:
+                raise TransportInternalError(f'Error while creating directory {path}: {exc}')
+
+    async def mkdir_async(self, path: TransportPath, ignore_existing=False):
+        """Create a directory.
+
+        :param path: absolute path to directory to create
+        :param bool ignore_existing: if set to true, it doesn't give any error
+                if the leaf directory does already exist
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raises: OSError, if directory at path already exists
+        """
+        path = path_to_str(path)
+
+        try:
+            await self._sftp.mkdir(path)
+        except SFTPFileAlreadyExists as exc:
+            # note: mkdir() in asyncssh does not support the exist_ok parameter
+            if ignore_existing:
+                return
+            raise OSError(f'Error while creating directory {path}: {exc}, directory already exists')
+        except asyncssh.sftp.SFTPFailure as exc:
+            if self._sftp.version < 6:
+                if ignore_existing:
+                    return
+                else:
+                    raise OSError(f'Error while creating directory {path}: {exc}, probably it already exists')
+            else:
+                raise TransportInternalError(f'Error while creating directory {path}: {exc}')
+
+    async def normalize_async(self, path: TransportPath):
+        raise NotImplementedError('Not implemented, waiting for a use case.')
+
+    async def remove_async(self, path: TransportPath):
+        """Remove the file at the given path. This only works on files;
+        for removing folders (directories), use rmdir.
+
+        :param path: path to file to remove
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raise OSError: if the path is a directory
+        """
+        path = path_to_str(path)
+        # TODO: check if asyncssh does return SFTPFileIsADirectory in this case
+        # if that's the case, we can get rid of the isfile check
+        if await self.isdir_async(path):
+            raise OSError(f'The path {path} is a directory')
+        else:
+            await self._sftp.remove(path)
+
+    async def rename_async(self, oldpath: TransportPath, newpath: TransportPath):
+        """
+        Rename a file or folder from oldpath to newpath.
+
+        :param oldpath: existing name of the file or folder
+        :param newpath: new name for the file or folder
+
+        :type oldpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type newpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raises OSError: if oldpath/newpath is not found
+        :raises ValueError: if oldpath/newpath is not a valid string
+        """
+        oldpath = path_to_str(oldpath)
+        newpath = path_to_str(newpath)
+        if not oldpath or not newpath:
+            raise ValueError('oldpath and newpath must be non-empty strings')
+
+        if await self._sftp.exists(newpath):
+            raise OSError(f'Cannot rename {oldpath} to {newpath}: destination exists')
+
+        await self._sftp.rename(oldpath, newpath)
+
+    async def rmdir_async(self, path: TransportPath):
+        """Remove the folder named path.
+        This works only for empty folders. For recursive remove, use rmtree.
+
+        :param str path: absolute path to the folder to remove
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+        path = path_to_str(path)
+        try:
+            await self._sftp.rmdir(path)
+        except asyncssh.sftp.SFTPFailure:
+            raise OSError(f'Error while removing directory {path}: probably directory is not empty')
+
+    async def rmtree_async(self, path: TransportPath):
+        """Remove the folder named path, and all its contents.
+
+        :param str path: absolute path to the folder to remove
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raises OSError: if the operation fails
+        """
+        path = path_to_str(path)
+        try:
+            await self._sftp.rmtree(path, ignore_errors=False)
+        except asyncssh.Error as exc:
+            raise OSError(f'Error while removing directory tree {path}: {exc}')
+
+    async def path_exists_async(self, path: TransportPath):
+        """Returns True if path exists, False otherwise.
+
+        :param path: path to check
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+        path = path_to_str(path)
+        return await self._sftp.exists(path)
+
+    async def whoami_async(self):
+        """Get the remote username
+
+        :return: username (str),
+
+        :raises OSError: if the command fails
+        """
+        command = 'whoami'
+        # Assuming here that the username is either ASCII or UTF-8 encoded
+        # This should be true essentially always
+        retval, username, stderr = await self.exec_command_wait_async(command)
+        if retval == 0:
+            if stderr.strip():
+                self.logger.warning(f'There was nonempty stderr in the whoami command: {stderr}')
+            return username.strip()
+
+        self.logger.error(f"Problem executing whoami. Exit code: {retval}, stdout: '{username}', stderr: '{stderr}'")
+        raise OSError(f'Error while executing whoami. Exit code: {retval}')
+
+    async def symlink_async(self, remotesource: TransportPath, remotedestination: TransportPath):
+        """Create a symbolic link between the remote source and the remote
+        destination.
+
+        :param remotesource: absolute path to remote source
+        :param remotedestination: absolute path to remote destination
+
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raises ValueError: if remotedestination has patterns
+        """
+        remotesource = path_to_str(remotesource)
+        remotedestination = path_to_str(remotedestination)
+
+        if self.has_magic(remotesource):
+            if self.has_magic(remotedestination):
+                raise ValueError('`remotedestination` cannot have patterns')
+
+            # find all files matching pattern
+            for this_source in await self._sftp.glob(remotesource):
+                # create the name of the link: take the last part of the path
+                this_dest = os.path.join(remotedestination, os.path.split(this_source)[-1])  # type: ignore [arg-type]
+                # in the line above I am sure that this_source is a string,
+                # since asyncssh.sftp.glob() returns only str if argument remotesource is a str
+                await self._sftp.symlink(this_source, this_dest)
+        else:
+            await self._sftp.symlink(remotesource, remotedestination)
+
+    async def glob_async(self, pathname: TransportPath):
+        """Return a list of paths matching a pathname pattern.
+
+        The pattern may contain simple shell-style wildcards a la fnmatch.
+
+        :param pathname: the pathname pattern to match.
+            It should only be absolute path.
+
+        :type pathname:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :return: a list of paths matching the pattern.
+        """
+        pathname = path_to_str(pathname)
+        return await self._sftp.glob(pathname)
+
+    async def chmod_async(self, path: TransportPath, mode: int, follow_symlinks: bool = True):
+        """Change the permissions of a file.
+
+        :param path: path to the file
+        :param mode: the new permissions
+        :param bool follow_symlinks: if True, follow symbolic links
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type mode: int
+        :type follow_symlinks: bool
+
+        :raises OSError: if the path is empty
+        """
+        path = path_to_str(path)
+        if not path:
+            raise OSError('Input path is an empty argument.')
+        try:
+            await self._sftp.chmod(path, mode, follow_symlinks=follow_symlinks)
+        except asyncssh.sftp.SFTPNoSuchFile as exc:
+            raise OSError(f'Error {exc}, directory does not exists')
+
+    async def chown_async(self, path: TransportPath, uid: int, gid: int):
+        """Change the owner and group id of a file.
+
+        :param path: path to the file
+        :param uid: the new owner id
+        :param gid: the new group id
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type uid: int
+        :type gid: int
+
+        :raises OSError: if the path is empty
+        """
+        path = path_to_str(path)
+        if not path:
+            raise OSError('Input path is an empty argument.')
+        try:
+            await self._sftp.chown(path, uid, gid, follow_symlinks=True)
+        except asyncssh.sftp.SFTPNoSuchFile as exc:
+            raise OSError(f'Error {exc}, directory does not exists')
+
+    async def copy_from_remote_to_remote_async(
+        self,
+        transportdestination: Union['Transport', 'AsyncTransport'],
+        remotesource: TransportPath,
+        remotedestination: TransportPath,
+        **kwargs,
+    ):
+        """Copy files or folders from a remote computer to another remote computer, asynchronously.
+
+        :param transportdestination: transport to be used for the destination computer
+        :param remotesource: path to the remote source directory / file
+        :param remotedestination: path to the remote destination directory / file
+        :param kwargs: keyword parameters passed to the call to transportdestination.put,
+            except for 'dereference' that is passed to self.get
+
+        :type transportdestination: :class:`Transport <aiida.transports.transport.Transport>`,
+            or :class:`AsyncTransport <aiida.transports.transport.AsyncTransport>`
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        .. note:: the keyword 'dereference' SHOULD be set to False for the
+         final put (onto the destination), while it can be set to the
+         value given in kwargs for the get from the source. In that
+         way, a symbolic link would never be followed in the final
+         copy to the remote destination. That way we could avoid getting
+         unknown (potentially malicious) files into the destination computer.
+         HOWEVER, since dereference=False is currently NOT
+         supported by all plugins, we still force it to True for the final put.
+
+        .. note:: the supported keys in kwargs are callback, dereference,
+           overwrite and ignore_nonexisting.
+        """
+        from aiida.common.folders import SandboxFolder
+
+        kwargs_get = {
+            'callback': None,
+            'dereference': kwargs.pop('dereference', True),
+            'overwrite': True,
+            'ignore_nonexisting': False,
+        }
+        kwargs_put = {
+            'callback': kwargs.pop('callback', None),
+            'dereference': True,
+            'overwrite': kwargs.pop('overwrite', True),
+            'ignore_nonexisting': kwargs.pop('ignore_nonexisting', False),
+        }
+
+        if kwargs:
+            self.logger.error('Unknown parameters passed to copy_from_remote_to_remote')
+
+        with SandboxFolder() as sandbox:
+            await self.get_async(remotesource, sandbox.abspath, **kwargs_get)
+            # Then we scan the full sandbox directory with get_content_list,
+            # because copying directly from sandbox.abspath would not work
+            # to copy a single file into another single file, and copying
+            # from sandbox.get_abs_path('*') would not work for files
+            # beginning with a dot ('.').
+            for filename in sandbox.get_content_list():
+                await transportdestination.put_async(
+                    os.path.join(sandbox.abspath, filename), remotedestination, **kwargs_put
+                )
+
+    def gotocomputer_command(self, remotedir: TransportPath):
+        """Return a string to be used to connect to the remote computer.
+
+        :param remotedir: the remote directory to connect to
+
+        :type remotedir:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+        connect_string = self._gotocomputer_string(remotedir)
+        cmd = f'ssh -t {self.machine} {connect_string}'
+        return cmd
diff --git a/src/aiida/transports/transport.py b/src/aiida/transports/transport.py
index a6d755973e..5a59dbcf09 100644
--- a/src/aiida/transports/transport.py
+++ b/src/aiida/transports/transport.py
@@ -9,18 +9,22 @@
 """Transport interface."""
 
 import abc
+import asyncio
 import fnmatch
 import os
 import re
 import sys
 from collections import OrderedDict
-from pathlib import Path
+from pathlib import Path, PurePosixPath
+from typing import Optional, Union
 
 from aiida.common.exceptions import InternalError
 from aiida.common.lang import classproperty
 from aiida.common.warnings import warn_deprecation
 
-__all__ = ('Transport',)
+__all__ = ('AsyncTransport', 'Transport', 'TransportPath')
+
+TransportPath = Union[str, Path, PurePosixPath]
 
 
 def validate_positive_number(ctx, param, value):
@@ -39,15 +43,22 @@ def validate_positive_number(ctx, param, value):
     return value
 
 
-class Transport(abc.ABC):
-    """Abstract class for a generic transport (ssh, local, ...) contains the set of minimal methods."""
+def path_to_str(path: TransportPath) -> str:
+    """Convert an instance of TransportPath = Union[str, Path, PurePosixPath] instance to a string."""
+    # We could check if the path is a Path or PurePosixPath instance, but it's too much overhead.
+    return str(path)
+
+
+class _BaseTransport:
+    """Abstract class for a generic blocking transport.
+    A plugin inhereting from this class should implement the blocking methods, only."""
 
     # This will be used for ``Computer.get_minimum_job_poll_interval``
     DEFAULT_MINIMUM_JOB_POLL_INTERVAL = 10
 
     # This is used as a global default in case subclasses don't redefine this,
     # but this should  be redefined in plugins where appropriate
-    _DEFAULT_SAFE_OPEN_INTERVAL = 30.0
+    _DEFAULT_SAFE_OPEN_INTERVAL = 3.0
 
     # To be defined in the subclass
     # See the ssh or local plugin to see the format
@@ -103,6 +114,20 @@ def __init__(self, *args, **kwargs):
         # for accessing the identity of the underlying machine
         self.hostname = kwargs.get('machine')
 
+    @abc.abstractmethod
+    def open(self):
+        """Opens a transport channel
+
+        :raises InvalidOperation: if the transport is already open.
+        """
+
+    @abc.abstractmethod
+    def close(self):
+        """Closes the transport channel.
+
+        :raises InvalidOperation: if the transport is already closed.
+        """
+
     def __enter__(self):
         """For transports that require opening a connection, opens
         all required channels (used in 'with' statements).
@@ -142,21 +167,6 @@ def __exit__(self, type_, value, traceback):
     def is_open(self):
         return self._is_open
 
-    @abc.abstractmethod
-    def open(self):
-        """Opens a local transport channel"""
-
-    @abc.abstractmethod
-    def close(self):
-        """Closes the local transport channel"""
-
-    def __repr__(self):
-        return f'<{self.__class__.__name__}: {self!s}>'
-
-    # redefine this in each subclass
-    def __str__(self):
-        return '[Transport class or subclass]'
-
     def set_logger_extra(self, logger_extra):
         """Pass the data that should be passed automatically to self.logger
         as 'extra' keyword. This is typically useful if you pass data
@@ -245,93 +255,144 @@ def get_safe_open_interval(self):
         """
         return self._safe_open_interval
 
-    @abc.abstractmethod
-    def chdir(self, path):
-        """
-        DEPRECATED: This method is deprecated and should be removed in the next major version.
-            PLEASE DON'T USE IT IN THE INTERFACE!!
-
-        Change directory to 'path'.
-        :param str path: path to change working directory into.
-        :raises: OSError, if the requested path does not exist
-        :rtype: str
-        """
+    def has_magic(self, string: TransportPath):
+        string = path_to_str(string)
+        """Return True if the given string contains any special shell characters."""
+        return self._MAGIC_CHECK.search(string) is not None
 
-        warn_deprecation(
-            '`chdir()` is deprecated and will be removed in the next major version.',
-            version=3,
+    def _gotocomputer_string(self, remotedir):
+        """Command executed when goto computer."""
+        connect_string = (
+            """ "if [ -d {escaped_remotedir} ] ;"""
+            """ then cd {escaped_remotedir} ; {bash_command} ; else echo '  ** The directory' ; """
+            """echo '  ** {remotedir}' ; echo '  ** seems to have been deleted, I logout...' ; fi" """.format(
+                bash_command=self._bash_command_str, escaped_remotedir="'{}'".format(remotedir), remotedir=remotedir
+            )
         )
 
+        return connect_string
+
+
+class Transport(abc.ABC, _BaseTransport):
+    """Abstract class for a generic blocking transport.
+    A plugin inhereting from this class should implement the blocking methods, only."""
+
+    # This will be used for connection authentication
+    # To be defined in the subclass, the format is a list of tuples
+    # where the first element is the name of the parameter and the second
+    # is a dictionary with the following
+    # keys: 'default', 'prompt', 'help', 'non_interactive_default'
+    _valid_auth_options = []
+
+    def __init__(self, *args, **kwargs):
+        # if __init__ is overridden in a subclass, it should always call the parent __init__
+        super().__init__(*args, **kwargs)
+
+    def __repr__(self):
+        return f'<{self.__class__.__name__}: {self!s}>'
+
     @abc.abstractmethod
-    def chmod(self, path, mode):
+    def __str__(self):
+        """return [Transport class or subclass]"""
+
+    @abc.abstractmethod
+    def chmod(self, path: TransportPath, mode):
         """Change permissions of a path.
 
-        :param str path: path to file
-        :param int mode: new permissions
+        :param path: path to file
+        :param mode: new permissions
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type mode: int
         """
 
     @abc.abstractmethod
-    def chown(self, path, uid, gid):
+    def chown(self, path: TransportPath, uid: int, gid: int):
         """Change the owner (uid) and group (gid) of a file.
         As with python's os.chown function, you must pass both arguments,
         so if you only want to change one, use stat first to retrieve the
         current owner and group.
 
-        :param str path: path to the file to change the owner and group of
-        :param int uid: new owner's uid
-        :param int gid: new group id
+        :param path: path to the file to change the owner and group of
+        :param uid: new owner's uid
+        :param gid: new group id
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type uid: int
+        :type gid: int
         """
 
     @abc.abstractmethod
-    def copy(self, remotesource, remotedestination, dereference=False, recursive=True):
+    def copy(self, remotesource: TransportPath, remotedestination: TransportPath, dereference=False, recursive=True):
         """Copy a file or a directory from remote source to remote destination
         (On the same remote machine)
 
-        :param str remotesource: path of the remote source directory / file
-        :param str remotedestination: path of the remote destination directory / file
+        :param remotesource: path of the remote source directory / file
+        :param remotedestination: path of the remote destination directory / file
         :param dereference: if True copy the contents of any symlinks found, otherwise copy the symlinks themselves
-        :type dereference: bool
         :param recursive: if True copy directories recursively, otherwise only copy the specified file(s)
+
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
         :type recursive: bool
 
         :raises: OSError, if one of src or dst does not exist
         """
 
     @abc.abstractmethod
-    def copyfile(self, remotesource, remotedestination, dereference=False):
+    def copyfile(self, remotesource: TransportPath, remotedestination: TransportPath, dereference=False):
         """Copy a file from remote source to remote destination
         (On the same remote machine)
 
-        :param str remotesource: path of the remote source directory / file
-        :param str remotedestination: path of the remote destination directory / file
+        :param remotesource: path of the remote source directory / file
+        :param remotedestination: path of the remote destination directory / file
         :param dereference: if True copy the contents of any symlinks found, otherwise copy the symlinks themselves
+
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
         :type dereference: bool
 
         :raises OSError: if one of src or dst does not exist
         """
 
     @abc.abstractmethod
-    def copytree(self, remotesource, remotedestination, dereference=False):
+    def copytree(self, remotesource: TransportPath, remotedestination: TransportPath, dereference=False):
         """Copy a folder from remote source to remote destination
         (On the same remote machine)
 
-        :param str remotesource: path of the remote source directory / file
-        :param str remotedestination: path of the remote destination directory / file
+        :param remotesource: path of the remote source directory / file
+        :param remotedestination: path of the remote destination directory / file
         :param dereference: if True copy the contents of any symlinks found, otherwise copy the symlinks themselves
+
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
         :type dereference: bool
 
         :raise OSError: if one of src or dst does not exist
         """
 
-    def copy_from_remote_to_remote(self, transportdestination, remotesource, remotedestination, **kwargs):
+    ## non-abtract methods. Plugin developers can safely ingore developing these methods
+    def copy_from_remote_to_remote(
+        self,
+        transportdestination: Union['Transport', 'AsyncTransport'],
+        remotesource: TransportPath,
+        remotedestination: TransportPath,
+        **kwargs,
+    ):
         """Copy files or folders from a remote computer to another remote computer.
 
         :param transportdestination: transport to be used for the destination computer
-        :param str remotesource: path to the remote source directory / file
-        :param str remotedestination: path to the remote destination directory / file
+        :param remotesource: path to the remote source directory / file
+        :param remotedestination: path to the remote destination directory / file
         :param kwargs: keyword parameters passed to the call to transportdestination.put,
             except for 'dereference' that is passed to self.get
 
+        :type transportdestination: :class:`Transport <aiida.transports.transport.Transport>`,
+            or :class:`AsyncTransport <aiida.transports.transport.AsyncTransport>`
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
         .. note:: the keyword 'dereference' SHOULD be set to False for the
          final put (onto the destination), while it can be set to the
          value given in kwargs for the get from the source. In that
@@ -370,10 +431,12 @@ def copy_from_remote_to_remote(self, transportdestination, remotesource, remoted
             # from sandbox.get_abs_path('*') would not work for files
             # beginning with a dot ('.').
             for filename in sandbox.get_content_list():
+                # no matter is transpordestination is Transport or AsyncTransport
+                # the following method will work, as both classes support put(), blocking method
                 transportdestination.put(os.path.join(sandbox.abspath, filename), remotedestination, **kwargs_put)
 
     @abc.abstractmethod
-    def _exec_command_internal(self, command, workdir=None, **kwargs):
+    def _exec_command_internal(self, command: str, workdir: Optional[TransportPath] = None, **kwargs):
         """Execute the command on the shell, similarly to os.system.
 
         Enforce the execution to be run from `workdir`.
@@ -381,15 +444,19 @@ def _exec_command_internal(self, command, workdir=None, **kwargs):
         If possible, use the higher-level
         exec_command_wait function.
 
-        :param str command: execute the command given as a string
+        :param command: execute the command given as a string
         :param workdir: (optional, default=None) if set, the command will be executed
                 in the specified working directory.
+
+        :type command: str
+        :type workdir:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
         :return: stdin, stdout, stderr and the session, when this exists \
                  (can be None).
         """
 
     @abc.abstractmethod
-    def exec_command_wait_bytes(self, command, stdin=None, workdir=None, **kwargs):
+    def exec_command_wait_bytes(self, command: str, stdin=None, workdir: Optional[TransportPath] = None, **kwargs):
         """Execute the command on the shell, waits for it to finish,
         and return the retcode, the stdout and the stderr as bytes.
 
@@ -397,14 +464,20 @@ def exec_command_wait_bytes(self, command, stdin=None, workdir=None, **kwargs):
 
         The command implementation can have some additional plugin-specific kwargs.
 
-        :param str command: execute the command given as a string
-        :param stdin: (optional,default=None) can be a string or a file-like object.
+        :param command: execute the command given as a string
+        :param stdin: (optional,default=None) can be bytes or a file-like object.
         :param workdir: (optional, default=None) if set, the command will be executed
                 in the specified working directory.
+
+        :type command: str
+        :type workdir:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
         :return: a tuple: the retcode (int), stdout (bytes) and stderr (bytes).
         """
 
-    def exec_command_wait(self, command, stdin=None, encoding='utf-8', workdir=None, **kwargs):
+    def exec_command_wait(
+        self, command, stdin=None, encoding='utf-8', workdir: Optional[TransportPath] = None, **kwargs
+    ):
         """Executes the specified command and waits for it to finish.
 
         :note: this function also decodes the bytes received into a string with the specified encoding,
@@ -422,6 +495,10 @@ def exec_command_wait(self, command, stdin=None, encoding='utf-8', workdir=None,
         :param workdir: (optional, default=None) if set, the command will be executed
             in the specified working directory.
 
+        :type command: str
+        :type encoding: str
+        :type workdir:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
         :return: a tuple with (return_value, stdout, stderr) where stdout and stderr are both strings, decoded
             with the specified encoding.
         """
@@ -432,30 +509,42 @@ def exec_command_wait(self, command, stdin=None, encoding='utf-8', workdir=None,
         return (retval, stdout_bytes.decode(encoding), stderr_bytes.decode(encoding))
 
     @abc.abstractmethod
-    def get(self, remotepath, localpath, *args, **kwargs):
+    def get(self, remotepath: TransportPath, localpath: TransportPath, *args, **kwargs):
         """Retrieve a file or folder from remote source to local destination
-        dst must be an absolute path (src not necessarily)
+        both localpath and remotepath must be an absolute path.
+
+        This method should be able to handle remothpath containing glob patterns,
+            in that case should only downloading matching patterns.
+
+        :param remotepath: remote_folder_path
+        :param localpath: (local_folder_path
 
-        :param remotepath: (str) remote_folder_path
-        :param localpath: (str) local_folder_path
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
         """
 
     @abc.abstractmethod
-    def getfile(self, remotepath, localpath, *args, **kwargs):
+    def getfile(self, remotepath: TransportPath, localpath: TransportPath, *args, **kwargs):
         """Retrieve a file from remote source to local destination
-        dst must be an absolute path (src not necessarily)
+        both localpath and remotepath must be an absolute path.
 
-        :param str remotepath: remote_folder_path
-        :param str localpath: local_folder_path
+        :param remotepath: remote_folder_path
+        :param localpath: local_folder_path
+
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
         """
 
     @abc.abstractmethod
-    def gettree(self, remotepath, localpath, *args, **kwargs):
+    def gettree(self, remotepath: TransportPath, localpath: TransportPath, *args, **kwargs):
         """Retrieve a folder recursively from remote source to local destination
-        dst must be an absolute path (src not necessarily)
+        both localpath and remotepath must be an absolute path.
+
+        :param remotepath: remote_folder_path
+        :param localpath: local_folder_path
 
-        :param str remotepath: remote_folder_path
-        :param str localpath: local_folder_path
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
         """
 
     @abc.abstractmethod
@@ -474,7 +563,7 @@ def getcwd(self):
         )
 
     @abc.abstractmethod
-    def get_attribute(self, path):
+    def get_attribute(self, path: TransportPath):
         """Return an object FixedFieldsAttributeDict for file in a given path,
         as defined in aiida.common.extendeddicts
         Each attribute object consists in a dictionary with the following keys:
@@ -491,14 +580,20 @@ def get_attribute(self, path):
 
         * st_mtime: time of most recent modification
 
-        :param str path: path to file
+        :param path: path to file
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
         :return: object FixedFieldsAttributeDict
         """
 
-    def get_mode(self, path):
+    def get_mode(self, path: TransportPath):
         """Return the portion of the file's mode that can be set by chmod().
 
-        :param str path: path to file
+        :param path: path to file
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
         :return: the portion of the file's mode that can be set by chmod()
         """
         import stat
@@ -506,43 +601,57 @@ def get_mode(self, path):
         return stat.S_IMODE(self.get_attribute(path).st_mode)
 
     @abc.abstractmethod
-    def isdir(self, path):
+    def isdir(self, path: TransportPath):
         """True if path is an existing directory.
+        Return False also if the path does not exist.
+
+        :param path: path to directory
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
 
-        :param str path: path to directory
         :return: boolean
         """
 
     @abc.abstractmethod
-    def isfile(self, path):
+    def isfile(self, path: TransportPath):
         """Return True if path is an existing file.
+        Return False also if the path does not exist.
+
+        :param path: path to file
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
 
-        :param str path: path to file
         :return: boolean
         """
 
     @abc.abstractmethod
-    def listdir(self, path='.', pattern=None):
+    def listdir(self, path: TransportPath = '.', pattern=None):
         """Return a list of the names of the entries in the given path.
         The list is in arbitrary order. It does not include the special
         entries '.' and '..' even if they are present in the directory.
 
-        :param str path: path to list (default to '.')
-        :param str pattern: if used, listdir returns a list of files matching
+        :param path: path to list (default to '.')
+            DEPRECATED: using '.' is deprecated and will be removed in the next major version.
+        :param pattern: if used, listdir returns a list of files matching
                             filters in Unix style. Unix only.
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
         :return: a list of strings
         """
 
-    def listdir_withattributes(self, path='.', pattern=None):
+    def listdir_withattributes(self, path: TransportPath = '.', pattern: Optional[str] = None):
         """Return a list of the names of the entries in the given path.
         The list is in arbitrary order. It does not include the special
         entries '.' and '..' even if they are present in the directory.
 
-        :param str path: path to list (default to '.')
+        :param path: path to list (default to '.')
             if using a relative path, it is relative to the current working directory,
             taken from DEPRECATED `self.getcwd()`.
-        :param str pattern: if used, listdir returns a list of files matching
+        :param pattern: if used, listdir returns a list of files matching
                             filters in Unix style. Unix only.
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type pattern: str
         :return: a list of dictionaries, one per entry.
             The schema of the dictionary is
             the following::
@@ -557,6 +666,7 @@ def listdir_withattributes(self, path='.', pattern=None):
             (if the file is a folder, a directory, ...). 'attributes' behaves as the output of
             transport.get_attribute(); isdir is a boolean indicating if the object is a directory or not.
         """
+        path = path_to_str(path)
         retlist = []
         if path.startswith('/'):
             cwd = Path(path).resolve().as_posix()
@@ -574,106 +684,133 @@ def listdir_withattributes(self, path='.', pattern=None):
         return retlist
 
     @abc.abstractmethod
-    def makedirs(self, path, ignore_existing=False):
+    def makedirs(self, path: TransportPath, ignore_existing=False):
         """Super-mkdir; create a leaf directory and all intermediate ones.
         Works like mkdir, except that any intermediate path segment (not
         just the rightmost) will be created if it does not exist.
 
-        :param str path: directory to create
+        :param path: directory to create
         :param bool ignore_existing: if set to true, it doesn't give any error
                                      if the leaf directory does already exist
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
 
         :raises: OSError, if directory at path already exists
         """
 
     @abc.abstractmethod
-    def mkdir(self, path, ignore_existing=False):
+    def mkdir(self, path: TransportPath, ignore_existing=False):
         """Create a folder (directory) named path.
 
-        :param str path: name of the folder to create
+        :param path: name of the folder to create
         :param bool ignore_existing: if True, does not give any error if the
                                      directory already exists
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
 
         :raises: OSError, if directory at path already exists
         """
 
     @abc.abstractmethod
-    def normalize(self, path='.'):
+    def normalize(self, path: TransportPath = '.'):
         """Return the normalized path (on the server) of a given path.
         This can be used to quickly resolve symbolic links or determine
         what the server is considering to be the "current folder".
 
-        :param str path: path to be normalized
+        :param path: path to be normalized
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
 
         :raise OSError: if the path can't be resolved on the server
         """
 
     @abc.abstractmethod
-    def put(self, localpath, remotepath, *args, **kwargs):
+    def put(self, localpath: TransportPath, remotepath: TransportPath, *args, **kwargs):
         """Put a file or a directory from local src to remote dst.
-        src must be an absolute path (dst not necessarily))
+        both localpath and remotepath must be an absolute path.
         Redirects to putfile and puttree.
 
-        :param str localpath: absolute path to local source
-        :param str remotepath: path to remote destination
+        This method should be able to handle localpath containing glob patterns,
+            in that case should only uploading matching patterns.
+
+        :param localpath: absolute path to local source
+        :param remotepath: path to remote destination
+
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
         """
 
     @abc.abstractmethod
-    def putfile(self, localpath, remotepath, *args, **kwargs):
+    def putfile(self, localpath: TransportPath, remotepath: TransportPath, *args, **kwargs):
         """Put a file from local src to remote dst.
-        src must be an absolute path (dst not necessarily))
+        both localpath and remotepath must be an absolute path.
 
-        :param str localpath: absolute path to local file
-        :param str remotepath: path to remote file
+        :param localpath: absolute path to local file
+        :param remotepath: path to remote file
+
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
         """
 
     @abc.abstractmethod
-    def puttree(self, localpath, remotepath, *args, **kwargs):
+    def puttree(self, localpath: TransportPath, remotepath: TransportPath, *args, **kwargs):
         """Put a folder recursively from local src to remote dst.
-        src must be an absolute path (dst not necessarily))
+        both localpath and remotepath must be an absolute path.
+
+        :param localpath: absolute path to local folder
+        :param remotepath: path to remote folder
 
-        :param str localpath: absolute path to local folder
-        :param str remotepath: path to remote folder
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
         """
 
     @abc.abstractmethod
-    def remove(self, path):
+    def remove(self, path: TransportPath):
         """Remove the file at the given path. This only works on files;
         for removing folders (directories), use rmdir.
 
-        :param str path: path to file to remove
+        :param path: path to file to remove
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
 
         :raise OSError: if the path is a directory
         """
 
     @abc.abstractmethod
-    def rename(self, oldpath, newpath):
+    def rename(self, oldpath: TransportPath, newpath: TransportPath):
         """Rename a file or folder from oldpath to newpath.
 
-        :param str oldpath: existing name of the file or folder
-        :param str newpath: new name for the file or folder
+        :param oldpath: existing name of the file or folder
+        :param newpath: new name for the file or folder
+
+        :type oldpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type newpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
 
         :raises OSError: if oldpath/newpath is not found
         :raises ValueError: if oldpath/newpath is not a valid string
         """
 
     @abc.abstractmethod
-    def rmdir(self, path):
+    def rmdir(self, path: TransportPath):
         """Remove the folder named path.
         This works only for empty folders. For recursive remove, use rmtree.
 
-        :param str path: absolute path to the folder to remove
+        :param path: absolute path to the folder to remove
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
         """
 
     @abc.abstractmethod
-    def rmtree(self, path):
+    def rmtree(self, path: TransportPath):
         """Remove recursively the content at path
 
-        :param str path: absolute path to remove
+        :param  path: absolute path to remove
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raise OSError: if the rm execution failed.
         """
 
     @abc.abstractmethod
-    def gotocomputer_command(self, remotedir):
+    def gotocomputer_command(self, remotedir: TransportPath):
         """Return a string to be run using os.system in order to connect
         via the transport to the remote directory.
 
@@ -683,24 +820,29 @@ def gotocomputer_command(self, remotedir):
 
         * A reasonable error message is produced if the folder does not exist
 
-        :param str remotedir: the full path of the remote directory
+        :param remotedir: the full path of the remote directory
+
+        :type remotedir:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
         """
 
     @abc.abstractmethod
-    def symlink(self, remotesource, remotedestination):
+    def symlink(self, remotesource: TransportPath, remotedestination: TransportPath):
         """Create a symbolic link between the remote source and the remote
         destination.
 
         :param remotesource: remote source
         :param remotedestination: remote destination
+
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
         """
 
     def whoami(self):
         """Get the remote username
 
-        :return: list of username (str),
-                 retval (int),
-                 stderr (str)
+        :return: username (str)
+
+        :raise OSError: if the whoami command fails.
         """
         command = 'whoami'
         # Assuming here that the username is either ASCII or UTF-8 encoded
@@ -715,21 +857,29 @@ def whoami(self):
         raise OSError(f'Error while executing whoami. Exit code: {retval}')
 
     @abc.abstractmethod
-    def path_exists(self, path):
-        """Returns True if path exists, False otherwise."""
+    def path_exists(self, path: TransportPath):
+        """Returns True if path exists, False otherwise.
+
+        :param path: path to check for existence
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`"""
 
     # The following definitions are almost copied and pasted
     # from the python module glob.
-    def glob(self, pathname):
+    def glob(self, pathname: TransportPath):
         """Return a list of paths matching a pathname pattern.
 
         The pattern may contain simple shell-style wildcards a la fnmatch.
 
-        :param str pathname: the pathname pattern to match.
-            It should only be absolute path.
+        :param pathname: the pathname pattern to match.
+            It should only be an absolute path.
             DEPRECATED: using relative path is deprecated.
+
+        :type pathname:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
         :return: a list of paths matching the pattern.
         """
+        pathname = path_to_str(pathname)
         if not pathname.startswith('/'):
             warn_deprecation(
                 'Using relative paths across transport in `glob` is deprecated '
@@ -743,6 +893,7 @@ def iglob(self, pathname):
 
         The pattern may contain simple shell-style wildcards a la fnmatch.
 
+        :param pathname: the pathname pattern to match.
         """
         if not self.has_magic(pathname):
             # if os.path.lexists(pathname): # ORIGINAL
@@ -773,15 +924,16 @@ def iglob(self, pathname):
     # takes a literal basename (so it only has to check for its existence).
 
     def glob1(self, dirname, pattern):
-        """Match subpaths of dirname against pattern."""
+        """Match subpaths of dirname against pattern.
+
+        :param dirname: path to the directory
+        :param pattern: pattern to match against
+        """
         if not dirname:
-            # dirname = os.curdir # ORIGINAL
             dirname = self.getcwd()
         if isinstance(pattern, str) and not isinstance(dirname, str):
             dirname = dirname.decode(sys.getfilesystemencoding() or sys.getdefaultencoding())
         try:
-            # names = os.listdir(dirname)
-            # print dirname
             names = self.listdir(dirname)
         except EnvironmentError:
             return []
@@ -790,7 +942,11 @@ def glob1(self, dirname, pattern):
         return fnmatch.filter(names, pattern)
 
     def glob0(self, dirname, basename):
-        """Wrap basename i a list if it is empty or if dirname/basename is an existing path, else return empty list."""
+        """Wrap basename i a list if it is empty or if dirname/basename is an existing path, else return empty list.
+
+        :param dirname: path to the directory
+        :param basename: basename to match against
+        """
         if basename == '':
             # `os.path.split()` returns an empty basename for paths ending with a
             # directory separator.  'q*x/' should match only directories.
@@ -802,21 +958,731 @@ def glob0(self, dirname, basename):
             return [basename]
         return []
 
-    def has_magic(self, string):
-        """Return True if the given string contains any special shell characters."""
-        return self._MAGIC_CHECK.search(string) is not None
+    ## Here we bring the async counterparts of the methods.
+    ## This is done by defining new methods that calls the sync method and awaits.
+    ## aiida-core engine is ultimately moving towards async, so this is a step in that direction.
+    ## To keep backward compatibility, the sync methods are kept as they are.
 
-    def _gotocomputer_string(self, remotedir):
-        """Command executed when goto computer."""
-        connect_string = (
-            """ "if [ -d {escaped_remotedir} ] ;"""
-            """ then cd {escaped_remotedir} ; {bash_command} ; else echo '  ** The directory' ; """
-            """echo '  ** {remotedir}' ; echo '  ** seems to have been deleted, I logout...' ; fi" """.format(
-                bash_command=self._bash_command_str, escaped_remotedir="'{}'".format(remotedir), remotedir=remotedir
-            )
-        )
+    async def open_async(self):
+        """Counterpart to open() that is async."""
+        return self.open()
 
-        return connect_string
+    async def close_async(self):
+        """Counterpart to close() that is async."""
+        return self.close()
+
+    async def chmod_async(self, path, mode):
+        """Counterpart to chmod() that is async."""
+        return self.chmod(path, mode)
+
+    async def chown_async(self, path, uid, gid):
+        """Counterpart to chown() that is async."""
+        return self.chown(path, uid, gid)
+
+    async def copy_async(self, remotesource, remotedestination, dereference=False, recursive=True):
+        """Counterpart to copy() that is async."""
+        return self.copy(remotesource, remotedestination, dereference, recursive)
+
+    async def copyfile_async(self, remotesource, remotedestination, dereference=False):
+        """Counterpart to copyfile() that is async."""
+        return self.copyfile(remotesource, remotedestination, dereference)
+
+    async def copytree_async(self, remotesource, remotedestination, dereference=False):
+        """Counterpart to copytree() that is async."""
+        return self.copytree(remotesource, remotedestination, dereference)
+
+    async def copy_from_remote_to_remote_async(self, transportdestination, remotesource, remotedestination, **kwargs):
+        """Counterpart to copy_from_remote_to_remote()."""
+        return self.copy_from_remote_to_remote(transportdestination, remotesource, remotedestination, **kwargs)
+
+    async def exec_command_internal_async(self, command, workdir=None, **kwargs):
+        """Counterpart to _exec_command_internal() that is async."""
+        return self._exec_command_internal(command, workdir, **kwargs)
+
+    async def exec_command_wait_bytes_async(self, command, stdin=None, workdir=None, **kwargs):
+        """Counterpart to exec_command_wait_bytes() that is async."""
+        return self.exec_command_wait_bytes(command, stdin, workdir, **kwargs)
+
+    async def exec_command_wait_async(self, command, stdin=None, encoding='utf-8', workdir=None, **kwargs):
+        """Counterpart to exec_command_wait() that is async."""
+        return self.exec_command_wait(command, stdin, encoding, workdir, **kwargs)
+
+    async def get_async(self, remotepath, localpath, *args, **kwargs):
+        """Counterpart to get() that is async."""
+        return self.get(remotepath, localpath, *args, **kwargs)
+
+    async def getfile_async(self, remotepath, localpath, *args, **kwargs):
+        """Counterpart to getfile() that is async."""
+        return self.getfile(remotepath, localpath, *args, **kwargs)
+
+    async def gettree_async(self, remotepath, localpath, *args, **kwargs):
+        """Counterpart to gettree() that is async."""
+        return self.gettree(remotepath, localpath, *args, **kwargs)
+
+    async def get_attribute_async(self, path):
+        """Counterpart to get_attribute() that is async."""
+        return self.get_attribute(path)
+
+    async def get_mode_async(self, path):
+        """Counterpart to get_mode() that is async."""
+        return self.get_mode(path)
+
+    async def isdir_async(self, path):
+        """Counterpart to isdir() that is async."""
+        return self.isdir(path)
+
+    async def isfile_async(self, path):
+        """Counterpart to isfile() that is async."""
+        return self.isfile(path)
+
+    async def listdir_async(self, path, pattern=None):
+        """Counterpart to listdir() that is async."""
+        return self.listdir(path, pattern)
+
+    async def listdir_withattributes_async(self, path: TransportPath, pattern=None):
+        """Counterpart to listdir_withattributes() that is async."""
+        return self.listdir_withattributes(path, pattern)
+
+    async def makedirs_async(self, path, ignore_existing=False):
+        """Counterpart to makedirs() that is async."""
+        return self.makedirs(path, ignore_existing)
+
+    async def mkdir_async(self, path, ignore_existing=False):
+        """Counterpart to mkdir() that is async."""
+        return self.mkdir(path, ignore_existing)
+
+    async def normalize_async(self, path):
+        """Counterpart to normalize() that is async."""
+        return self.normalize(path)
+
+    async def put_async(self, localpath, remotepath, *args, **kwargs):
+        """Counterpart to put() that is async."""
+        return self.put(localpath, remotepath, *args, **kwargs)
+
+    async def putfile_async(self, localpath, remotepath, *args, **kwargs):
+        """Counterpart to putfile() that is async."""
+        return self.putfile(localpath, remotepath, *args, **kwargs)
+
+    async def puttree_async(self, localpath, remotepath, *args, **kwargs):
+        """Counterpart to puttree() that is async."""
+        return self.puttree(localpath, remotepath, *args, **kwargs)
+
+    async def remove_async(self, path):
+        """Counterpart to remove() that is async."""
+        return self.remove(path)
+
+    async def rename_async(self, oldpath, newpath):
+        """Counterpart to rename() that is async."""
+        return self.rename(oldpath, newpath)
+
+    async def rmdir_async(self, path):
+        """Counterpart to rmdir() that is async."""
+        return self.rmdir(path)
+
+    async def rmtree_async(self, path):
+        """Counterpart to rmtree() that is async."""
+        return self.rmtree(path)
+
+    async def symlink_async(self, remotesource, remotedestination):
+        """Counterpart to symlink() that is async."""
+        return self.symlink(remotesource, remotedestination)
+
+    async def whoami_async(self):
+        """Counterpart to whoami() that is async."""
+        return self.whoami()
+
+    async def path_exists_async(self, path):
+        """Counterpart to path_exists() that is async."""
+        return self.path_exists(path)
+
+    async def glob_async(self, pathname):
+        """Counterpart to glob() that is async."""
+        return self.glob(pathname)
+
+
+class AsyncTransport(abc.ABC, _BaseTransport):
+    """An abstract base class for asynchronous transports.
+    All methods are asynchronous and should be implemented by subclasses.
+    avoid overriding the sync methods, as they are implemented for backward compatibility, only."""
+
+    # This will be used for connection authentication
+    # To be defined in the subclass, the format is a list of tuples
+    # where the first element is the name of the parameter and the second
+    # is a dictionary with the following
+    # keys: 'default', 'prompt', 'help', 'non_interactive_default'
+    _valid_auth_options = []
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @abc.abstractmethod
+    async def open_async(self):
+        """Open a transport channel.
+
+        :raises InvalidOperation: if the transport is already open.
+        """
+
+    @abc.abstractmethod
+    async def close_async(self):
+        """Close the transport channel.
+
+        :raises InvalidOperation: if the transport is already closed.
+        """
+
+    @abc.abstractmethod
+    async def chmod_async(self, path: TransportPath, mode: int):
+        """Change permissions of a path.
+
+        :param path: path to file or directory
+        :param mode: new permissions
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type mode: int
+        """
+
+    @abc.abstractmethod
+    async def chown_async(self, path: TransportPath, uid: int, gid: int):
+        """Change the owner (uid) and group (gid) of a file.
+
+        :param path: path to file
+        :param uid: user id of the new owner
+        :param gid: group id of the new owner
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type uid: int
+        :type gid: int
+        """
+
+    @abc.abstractmethod
+    async def copy_async(self, remotesource, remotedestination, dereference=False, recursive=True):
+        """Copy a file or a directory from remote source to remote destination
+        (On the same remote machine)
+
+        :param remotesource: path to the remote source directory / file
+        :param remotedestination: path to the remote destination directory / file
+        :param dereference: follow symbolic links
+        :param recursive: copy recursively
+
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
+        :type recursive: bool
+
+        :raises: OSError, src does not exist or if the copy execution failed.
+        """
+
+    @abc.abstractmethod
+    async def copyfile_async(self, remotesource: TransportPath, remotedestination: TransportPath, dereference=False):
+        """Copy a file from remote source to remote destination
+        (On the same remote machine)
+
+        :param remotesource: path to the remote source file
+        :param remotedestination: path to the remote destination file
+        :param dereference: follow symbolic links
+
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
+
+        :raises: OSError, src does not exist or if the copy execution failed."""
+
+    @abc.abstractmethod
+    async def copytree_async(self, remotesource: TransportPath, remotedestination: TransportPath, dereference=False):
+        """Copy a folder from remote source to remote destination
+        (On the same remote machine)
+
+        :param remotesource: path to the remote source folder
+        :param remotedestination: path to the remote destination folder
+        :param dereference: follow symbolic links
+
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type dereference: bool
+
+        :raises: OSError, src does not exist or if the copy execution failed."""
+
+    @abc.abstractmethod
+    async def copy_from_remote_to_remote_async(
+        self,
+        transportdestination: Union['Transport', 'AsyncTransport'],
+        remotesource: TransportPath,
+        remotedestination: TransportPath,
+        **kwargs,
+    ):
+        """Copy files or folders from a remote computer to another remote computer.
+
+        :param transportdestination: destination transport
+        :param remotesource: path to the remote source directory / file
+        :param remotedestination: path to the remote destination directory / file
+        :param kwargs: keyword parameters passed to the call to transportdestination.put,
+            except for 'dereference' that is passed to self.get
+
+        :type transportdestination: :class:`Transport <aiida.transports.transport.Transport>`,
+            or :class:`AsyncTransport <aiida.transports.transport.AsyncTransport>`
+        :type remotesource:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotedestination:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+
+    @abc.abstractmethod
+    async def exec_command_wait_async(
+        self,
+        command: str,
+        stdin: Optional[str] = None,
+        encoding: str = 'utf-8',
+        workdir: Optional[TransportPath] = None,
+        **kwargs,
+    ):
+        """Executes the specified command and waits for it to finish.
+
+        :param command: the command to execute
+        :param stdin: input to the command
+        :param encoding: (IGNORED) this is here just to keep the same signature as the one in `Transport` class
+        :param workdir: working directory where the command will be executed
+
+        :type command: str
+        :type stdin: str
+        :type encoding: str
+        :type workdir:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :return: a tuple with (return_value, stdout, stderr) where stdout and stderr are both strings.
+        :rtype: Tuple[int, str, str]
+        """
+
+    @abc.abstractmethod
+    async def get_async(self, remotepath: TransportPath, localpath: TransportPath, *args, **kwargs):
+        """Retrieve a file or folder from remote source to local destination
+        both remotepath and localpath must be absolute paths
+
+        This method should be able to handle remotepath containing glob patterns,
+            in that case should only downloading matching patterns.
+
+        :param remotepath: remote_folder_path
+        :param localpath: local_folder_path
+
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+
+    @abc.abstractmethod
+    async def getfile_async(self, remotepath: TransportPath, localpath: TransportPath, *args, **kwargs):
+        """Retrieve a file from remote source to local destination
+        both remotepath and localpath must be absolute paths
+
+        :param remotepath: remote_folder_path
+        :param localpath: local_folder_path
+
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+
+    @abc.abstractmethod
+    async def gettree_async(self, remotepath: TransportPath, localpath: TransportPath, *args, **kwargs):
+        """Retrieve a folder recursively from remote source to local destination
+        both remotepath and localpath must be absolute paths
+
+        :param remotepath: remote_folder_path
+        :param localpath: local_folder_path
+
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+
+    @abc.abstractmethod
+    async def get_attribute_async(self, path: TransportPath):
+        """Return an object FixedFieldsAttributeDict for file in a given path,
+        as defined in aiida.common.extendeddicts
+        Each attribute object consists in a dictionary with the following keys:
+
+        * st_size: size of files, in bytes
+
+        * st_uid: user id of owner
+
+        * st_gid: group id of owner
+
+        * st_mode: protection bits
+
+        * st_atime: time of most recent access
+
+        * st_mtime: time of most recent modification
+
+        :param path: path to file
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :return: object FixedFieldsAttributeDict
+        """
+
+    async def get_mode_async(self, path: TransportPath):
+        """Return the portion of the file's mode that can be set by chmod().
+
+        :param str path: path to file
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :return: the portion of the file's mode that can be set by chmod()
+        """
+        import stat
+
+        attr = await self.get_attribute_async(path)
+        return stat.S_IMODE(attr.st_mode)
+
+    @abc.abstractmethod
+    async def isdir_async(self, path: TransportPath):
+        """True if path is an existing directory.
+        Return False also if the path does not exist.
+
+        :param path: path to directory
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :return: boolean
+        """
+
+    @abc.abstractmethod
+    async def isfile_async(self, path: TransportPath):
+        """Return True if path is an existing file.
+        Return False also if the path does not exist.
+
+        :param path: path to file
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :return: boolean
+        """
+
+    @abc.abstractmethod
+    async def listdir_async(self, path: TransportPath, pattern: Optional[str] = None):
+        """Return a list of the names of the entries in the given path.
+        The list is in arbitrary order. It does not include the special
+        entries '.' and '..' even if they are present in the directory.
+
+        :param path: an absolute path
+        :param pattern: if used, listdir returns a list of files matching
+                        filters in Unix style. Unix only.
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :return: a list of strings
+        """
+
+    @abc.abstractmethod
+    async def listdir_withattributes_async(
+        self,
+        path: TransportPath,
+        pattern: Optional[str] = None,
+    ):
+        """Return a list of the names of the entries in the given path.
+        The list is in arbitrary order. It does not include the special
+        entries '.' and '..' even if they are present in the directory.
+
+        :param path: absolute path to list.
+        :param pattern: if used, listdir returns a list of files matching
+                        filters in Unix style. Unix only.
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type pattern: str
+        :return: a list of dictionaries, one per entry.
+            The schema of the dictionary is
+            the following::
+
+                {
+                   'name': String,
+                   'attributes': FileAttributeObject,
+                   'isdir': Bool
+                }
+
+            where 'name' is the file or folder directory, and any other information is metadata
+            (if the file is a folder, a directory, ...). 'attributes' behaves as the output of
+            transport.get_attribute(); isdir is a boolean indicating if the object is a directory or not.
+        """
+
+    @abc.abstractmethod
+    async def makedirs_async(self, path: TransportPath, ignore_existing=False):
+        """Super-mkdir; create a leaf directory and all intermediate ones.
+        Works like mkdir, except that any intermediate path segment (not
+        just the rightmost) will be created if it does not exist.
+
+        :param path: directory to create
+        :param bool ignore_existing: if set to true, it doesn't give any error
+                                     if the leaf directory does already exist
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raises: OSError, if directory at path already exists
+        """
+
+    @abc.abstractmethod
+    async def mkdir_async(self, path: TransportPath, ignore_existing=False):
+        """Create a folder (directory) named path.
+
+        :param path: name of the folder to create
+        :param bool ignore_existing: if True, does not give any error if the
+                                     directory already exists.
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raises: OSError, if directory at path already exists
+        """
+
+    @abc.abstractmethod
+    async def normalize_async(self, path: TransportPath):
+        """Return the normalized path (on the server) of a given path.
+        This can be used to quickly resolve symbolic links or determine
+        what the server is considering to be the "current folder".
+
+        :param path: path to be normalized
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raise OSError: if the path can't be resolved on the server
+        """
+
+    @abc.abstractmethod
+    async def put_async(self, localpath: TransportPath, remotepath: TransportPath, *args, **kwargs):
+        """Put a file or a directory from local src to remote dst.
+        both localpath and remotepath must be absolute paths.
+        Redirects to putfile and puttree.
+
+        This method should be able to handle localpath containing glob patterns,
+            in that case should only uploading matching patterns.
+
+        :param localpath: absolute path to local source
+        :param remotepath: path to remote destination
+
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+
+    @abc.abstractmethod
+    async def putfile_async(self, localpath: TransportPath, remotepath: TransportPath, *args, **kwargs):
+        """Put a file from local src to remote dst.
+        both localpath and remotepath must be absolute paths.
+
+        :param localpath: absolute path to local file
+        :param remotepath: path to remote file
+
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+
+    @abc.abstractmethod
+    async def puttree_async(self, localpath: TransportPath, remotepath: TransportPath, *args, **kwargs):
+        """Put a folder recursively from local src to remote dst.
+        both localpath and remotepath must be absolute paths.
+
+        :param localpath: absolute path to local folder
+        :param remotepath: path to remote folder
+
+        :type localpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type remotepath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+
+    @abc.abstractmethod
+    async def remove_async(self, path: TransportPath):
+        """Remove the file at the given path. This only works on files;
+        for removing folders (directories), use rmdir.
+
+        :param path: path to file to remove
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raise OSError: if the path is a directory
+        """
+
+    @abc.abstractmethod
+    async def rename_async(self, oldpath: TransportPath, newpath: TransportPath):
+        """Rename a file or folder from oldpath to newpath.
+
+        :param oldpath: existing name of the file or folder
+        :param newpath: new name for the file or folder
+
+        :type oldpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        :type newpath:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raises OSError: if oldpath/newpath is not found
+        :raises ValueError: if oldpath/newpath is not a valid string
+        """
+
+    @abc.abstractmethod
+    async def rmdir_async(self, path: TransportPath):
+        """Remove the folder named path.
+        This works only for empty folders. For recursive remove, use rmtree.
+
+        :param path: absolute path to the folder to remove
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+
+    @abc.abstractmethod
+    async def rmtree_async(self, path: TransportPath):
+        """Remove recursively the content at path
+
+        :param  path: absolute path to remove
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :raise OSError: if the rm execution failed.
+        """
+
+    @abc.abstractmethod
+    def gotocomputer_command(self, remotedir: TransportPath):
+        """Return a string to be run using os.system in order to connect
+        via the transport to the remote directory.
+
+        NOTE: This method is not async, abd need not to be,
+            as it's eventually used for interactive shell commands.
+
+        Expected behaviors:
+
+        * A new bash session is opened
+
+        * A reasonable error message is produced if the folder does not exist
+
+        :param remotedir: the full path of the remote directory
+
+        :type remotedir:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+
+    @abc.abstractmethod
+    async def symlink_async(self, remotesource: TransportPath, remotedestination: TransportPath):
+        """Create a symbolic link between the remote source and the remote destination.
+
+        :param remotesource: remote source
+        :param remotedestination: remote destination
+
+        :param remotesource: absolute path to remote source
+        :param remotedestination: absolute path to remote destination
+        """
+
+    @abc.abstractmethod
+    async def whoami_async(self):
+        """Get the remote username
+
+        :return: username (str)
+
+        :raise OSError: if the whoami command fails.
+        """
+
+    @abc.abstractmethod
+    async def path_exists_async(self, path: TransportPath):
+        """Returns True if path exists, False otherwise.
+
+        :param path: path to check for existence
+
+        :type path:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+        """
+
+    @abc.abstractmethod
+    async def glob_async(self, pathname: TransportPath):
+        """Return a list of paths matching a pathname pattern.
+
+        The pattern may contain simple shell-style wildcards a la fnmatch.
+
+        :param pathname: the pathname pattern to match.
+            It should only be absolute path.
+
+        :type pathname:  :class:`Path <pathlib.Path>`, :class:`PurePosixPath <pathlib.PurePosixPath>`, or `str`
+
+        :return: a list of paths matching the pattern.
+        """
+
+    ## Blocking counterpart methods. We need these for backwards compatibility
+    # We need these methods, only because some part of codebase and
+    # many external plugins are synchronous, in those cases blocking calls make more sense.
+    # However, be aware you cannot use these methods in an async functions,
+    # because they will block the event loop.
+
+    def run_command_blocking(self, func, *args, **kwargs):
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(func(*args, **kwargs))
+
+    def open(self):
+        return self.run_command_blocking(self.open_async)
+
+    def close(self):
+        return self.run_command_blocking(self.close_async)
+
+    def get(self, *args, **kwargs):
+        return self.run_command_blocking(self.get_async, *args, **kwargs)
+
+    def getfile(self, *args, **kwargs):
+        return self.run_command_blocking(self.getfile_async, *args, **kwargs)
+
+    def gettree(self, *args, **kwargs):
+        return self.run_command_blocking(self.gettree_async, *args, **kwargs)
+
+    def get_mode(self, *args, **kwargs):
+        return self.run_command_blocking(self.get_mode_async, *args, **kwargs)
+
+    def put(self, *args, **kwargs):
+        return self.run_command_blocking(self.put_async, *args, **kwargs)
+
+    def putfile(self, *args, **kwargs):
+        return self.run_command_blocking(self.putfile_async, *args, **kwargs)
+
+    def puttree(self, *args, **kwargs):
+        return self.run_command_blocking(self.puttree_async, *args, **kwargs)
+
+    def chmod(self, *args, **kwargs):
+        return self.run_command_blocking(self.chmod_async, *args, **kwargs)
+
+    def copy(self, *args, **kwargs):
+        return self.run_command_blocking(self.copy_async, *args, **kwargs)
+
+    def copyfile(self, *args, **kwargs):
+        return self.run_command_blocking(self.copyfile_async, *args, **kwargs)
+
+    def copytree(self, *args, **kwargs):
+        return self.run_command_blocking(self.copytree_async, *args, **kwargs)
+
+    def exec_command_wait(self, *args, **kwargs):
+        return self.run_command_blocking(self.exec_command_wait_async, *args, **kwargs)
+
+    def get_attribute(self, *args, **kwargs):
+        return self.run_command_blocking(self.get_attribute_async, *args, **kwargs)
+
+    def isdir(self, *args, **kwargs):
+        return self.run_command_blocking(self.isdir_async, *args, **kwargs)
+
+    def isfile(self, *args, **kwargs):
+        return self.run_command_blocking(self.isfile_async, *args, **kwargs)
+
+    def listdir(self, *args, **kwargs):
+        return self.run_command_blocking(self.listdir_async, *args, **kwargs)
+
+    def listdir_withattributes(self, *args, **kwargs):
+        return self.run_command_blocking(self.listdir_withattributes_async, *args, **kwargs)
+
+    def makedirs(self, *args, **kwargs):
+        return self.run_command_blocking(self.makedirs_async, *args, **kwargs)
+
+    def mkdir(self, *args, **kwargs):
+        return self.run_command_blocking(self.mkdir_async, *args, **kwargs)
+
+    def remove(self, *args, **kwargs):
+        return self.run_command_blocking(self.remove_async, *args, **kwargs)
+
+    def rename(self, *args, **kwargs):
+        return self.run_command_blocking(self.rename_async, *args, **kwargs)
+
+    def rmdir(self, *args, **kwargs):
+        return self.run_command_blocking(self.rmdir_async, *args, **kwargs)
+
+    def rmtree(self, *args, **kwargs):
+        return self.run_command_blocking(self.rmtree_async, *args, **kwargs)
+
+    def path_exists(self, *args, **kwargs):
+        return self.run_command_blocking(self.path_exists_async, *args, **kwargs)
+
+    def whoami(self, *args, **kwargs):
+        return self.run_command_blocking(self.whoami_async, *args, **kwargs)
+
+    def symlink(self, *args, **kwargs):
+        return self.run_command_blocking(self.symlink_async, *args, **kwargs)
+
+    def glob(self, *args, **kwargs):
+        return self.run_command_blocking(self.glob_async, *args, **kwargs)
+
+    def normalize(self, *args, **kwargs):
+        return self.run_command_blocking(self.normalize_async, *args, **kwargs)
 
 
 class TransportInternalError(InternalError):
diff --git a/src/aiida/transports/util.py b/src/aiida/transports/util.py
index 12d3b3d882..9e338df97d 100644
--- a/src/aiida/transports/util.py
+++ b/src/aiida/transports/util.py
@@ -86,3 +86,24 @@ def copy_from_remote_to_remote(transportsource, transportdestination, remotesour
     .. note:: it uses the method transportsource.copy_from_remote_to_remote
     """
     transportsource.copy_from_remote_to_remote(transportdestination, remotesource, remotedestination, **kwargs)
+
+
+async def copy_from_remote_to_remote_async(
+    transportsource, transportdestination, remotesource, remotedestination, **kwargs
+):
+    """Copy files or folders from a remote computer to another remote computer.
+    Note: To have a proper async performance,
+    both transports should be instance `core.async_ssh`.
+    Even if either or both are not async, the function will work,
+    but the performance might be lower than the sync version.
+
+    :param transportsource: transport to be used for the source computer
+    :param transportdestination: transport to be used for the destination computer
+    :param str remotesource: path to the remote source directory / file
+    :param str remotedestination: path to the remote destination directory / file
+    :param kwargs: keyword parameters passed to the final put,
+        except for 'dereference' that is passed to the initial get
+
+    .. note:: it uses the method transportsource.copy_from_remote_to_remote
+    """
+    await transportsource.copy_from_remote_to_remote(transportdestination, remotesource, remotedestination, **kwargs)
diff --git a/tests/cmdline/commands/test_computer.py b/tests/cmdline/commands/test_computer.py
index cf8fb01df9..3c98b7d1db 100644
--- a/tests/cmdline/commands/test_computer.py
+++ b/tests/cmdline/commands/test_computer.py
@@ -986,3 +986,26 @@ def test_computer_ssh_auto(run_cli_command, aiida_computer):
     options = ['core.ssh_auto', computer.uuid, '--non-interactive', '--safe-interval', '0']
     run_cli_command(computer_configure, options, use_subprocess=False)
     assert computer.is_configured
+
+
+def test_computer_ssh_async(run_cli_command, aiida_computer):
+    """Test setup of computer with ``core.ssh_async`` entry point.
+
+    The configure step should only require the common shared options ``safe_interval`` and ``use_login_shell``.
+    """
+    computer = aiida_computer(transport_type='core.ssh_async').store()
+    assert not computer.is_configured
+
+    # It is important that 'ssh localhost' is functional in your test environment.
+    # It should connect without asking for a password.
+    options = [
+        'core.ssh_async',
+        computer.uuid,
+        '--non-interactive',
+        '--safe-interval',
+        '0',
+        '--machine-or-host',
+        'localhost',
+    ]
+    run_cli_command(computer_configure, options, use_subprocess=False)
+    assert computer.is_configured
diff --git a/tests/engine/daemon/test_execmanager.py b/tests/engine/daemon/test_execmanager.py
index b0b4e4f1bd..850ec57b47 100644
--- a/tests/engine/daemon/test_execmanager.py
+++ b/tests/engine/daemon/test_execmanager.py
@@ -16,6 +16,7 @@
 from aiida.common.datastructures import CalcInfo, CodeInfo, FileCopyOperation
 from aiida.common.folders import SandboxFolder
 from aiida.engine.daemon import execmanager
+from aiida.manage import get_manager
 from aiida.orm import CalcJobNode, FolderData, PortableCode, RemoteData, SinglefileData
 from aiida.transports.plugins.local import LocalTransport
 
@@ -124,10 +125,11 @@ def test_retrieve_files_from_list(
     target = tmp_path_factory.mktemp('target')
 
     create_file_hierarchy(file_hierarchy, source)
+    runner = get_manager().get_runner()
 
     with LocalTransport() as transport:
         node = generate_calcjob_node(workdir=source)
-        execmanager.retrieve_files_from_list(node, transport, target, retrieve_list)
+        runner.loop.run_until_complete(execmanager.retrieve_files_from_list(node, transport, target, retrieve_list))
 
     assert serialize_file_hierarchy(target, read_bytes=False) == expected_hierarchy
 
@@ -165,7 +167,8 @@ def test_upload_local_copy_list(
     calc_info.local_copy_list = [[folder.uuid] + local_copy_list]
 
     with node.computer.get_transport() as transport:
-        execmanager.upload_calculation(node, transport, calc_info, fixture_sandbox)
+        runner = get_manager().get_runner()
+        runner.loop.run_until_complete(execmanager.upload_calculation(node, transport, calc_info, fixture_sandbox))
 
     # Check that none of the files were written to the repository of the calculation node, since they were communicated
     # through the ``local_copy_list``.
@@ -202,7 +205,8 @@ def test_upload_local_copy_list_files_folders(
     ]
 
     with node.computer.get_transport() as transport:
-        execmanager.upload_calculation(node, transport, calc_info, fixture_sandbox)
+        runner = get_manager().get_runner()
+        runner.loop.run_until_complete(execmanager.upload_calculation(node, transport, calc_info, fixture_sandbox))
 
     # Check that none of the files were written to the repository of the calculation node, since they were communicated
     # through the ``local_copy_list``.
@@ -233,7 +237,8 @@ def test_upload_remote_symlink_list(
     ]
 
     with node.computer.get_transport() as transport:
-        execmanager.upload_calculation(node, transport, calc_info, fixture_sandbox)
+        runner = get_manager().get_runner()
+        runner.loop.run_until_complete(execmanager.upload_calculation(node, transport, calc_info, fixture_sandbox))
 
     filepath_workdir = pathlib.Path(node.get_remote_workdir())
     assert (filepath_workdir / 'file_a.txt').is_symlink()
@@ -297,7 +302,8 @@ def test_upload_file_copy_operation_order(node_and_calc_info, tmp_path, order, e
         calc_info.file_copy_operation_order = order
 
     with node.computer.get_transport() as transport:
-        execmanager.upload_calculation(node, transport, calc_info, sandbox, inputs)
+        runner = get_manager().get_runner()
+        runner.loop.run_until_complete(execmanager.upload_calculation(node, transport, calc_info, sandbox, inputs))
         filepath = pathlib.Path(node.get_remote_workdir()) / 'file.txt'
         assert filepath.is_file()
         assert filepath.read_text() == expected
@@ -568,18 +574,20 @@ def test_upload_combinations(
         calc_info.remote_copy_list.append(
             (node.computer.uuid, (sub_tmp_path_remote / source_path).as_posix(), target_path)
         )
-
+    runner = get_manager().get_runner()
     if expected_exception is not None:
         with pytest.raises(expected_exception):
             with node.computer.get_transport() as transport:
-                execmanager.upload_calculation(node, transport, calc_info, fixture_sandbox)
+                runner.loop.run_until_complete(
+                    execmanager.upload_calculation(node, transport, calc_info, fixture_sandbox)
+                )
 
             filepath_workdir = pathlib.Path(node.get_remote_workdir())
 
             assert serialize_file_hierarchy(filepath_workdir, read_bytes=False) == expected_hierarchy
     else:
         with node.computer.get_transport() as transport:
-            execmanager.upload_calculation(node, transport, calc_info, fixture_sandbox)
+            runner.loop.run_until_complete(execmanager.upload_calculation(node, transport, calc_info, fixture_sandbox))
 
         filepath_workdir = pathlib.Path(node.get_remote_workdir())
 
@@ -607,9 +615,12 @@ def test_upload_calculation_portable_code(fixture_sandbox, node_and_calc_info, t
     calc_info.codes_info = [code_info]
 
     with node.computer.get_transport() as transport:
-        execmanager.upload_calculation(
-            node,
-            transport,
-            calc_info,
-            fixture_sandbox,
+        runner = get_manager().get_runner()
+        runner.loop.run_until_complete(
+            execmanager.upload_calculation(
+                node,
+                transport,
+                calc_info,
+                fixture_sandbox,
+            )
         )
diff --git a/tests/manage/tests/test_pytest_fixtures.py b/tests/manage/tests/test_pytest_fixtures.py
index 93ea7c1b80..6cd5f58ba6 100644
--- a/tests/manage/tests/test_pytest_fixtures.py
+++ b/tests/manage/tests/test_pytest_fixtures.py
@@ -7,7 +7,7 @@
 from aiida.manage.configuration import get_config
 from aiida.manage.configuration.config import Config
 from aiida.orm import Computer
-from aiida.transports import Transport
+from aiida.transports import AsyncTransport, Transport
 
 
 def test_profile_config():
@@ -64,3 +64,26 @@ def test_aiida_computer_ssh(aiida_computer_ssh):
 
     computer_unconfigured = aiida_computer_ssh(label=str(uuid.uuid4()), configure=False)
     assert not computer_unconfigured.is_configured
+
+
+@pytest.mark.usefixtures('aiida_profile_clean')
+def test_aiida_computer_ssh_async(aiida_computer_ssh_async):
+    """Test the ``aiida_computer_ssh_async`` fixture."""
+    computer = aiida_computer_ssh_async()
+    assert isinstance(computer, Computer)
+    assert computer.is_configured
+    assert computer.hostname == 'localhost'
+    assert computer.transport_type == 'core.ssh_async'
+
+    with computer.get_transport() as transport:
+        assert isinstance(transport, AsyncTransport)
+
+    # Calling it again with the same label should simply return the existing computer
+    computer_alt = aiida_computer_ssh_async(label=computer.label)
+    assert computer_alt.uuid == computer.uuid
+
+    computer_new = aiida_computer_ssh_async(label=str(uuid.uuid4()))
+    assert computer_new.uuid != computer.uuid
+
+    computer_unconfigured = aiida_computer_ssh_async(label=str(uuid.uuid4()), configure=False)
+    assert not computer_unconfigured.is_configured
diff --git a/tests/plugins/test_factories.py b/tests/plugins/test_factories.py
index 49f3140fbe..f42a257f6d 100644
--- a/tests/plugins/test_factories.py
+++ b/tests/plugins/test_factories.py
@@ -19,7 +19,7 @@
 from aiida.schedulers import Scheduler
 from aiida.tools.data.orbital import Orbital
 from aiida.tools.dbimporters import DbImporter
-from aiida.transports import Transport
+from aiida.transports import AsyncTransport, Transport
 
 
 def custom_load_entry_point(group, name):
@@ -69,7 +69,8 @@ def work_function():
             'invalid': Node,
         },
         'aiida.transports': {
-            'valid': Transport,
+            'valid_AsyncTransport': AsyncTransport,
+            'valid_Transport': Transport,
             'invalid': Node,
         },
         'aiida.workflows': {
@@ -190,8 +191,11 @@ def test_storage_factory(self):
     @pytest.mark.usefixtures('mock_load_entry_point')
     def test_transport_factory(self):
         """Test the ``TransportFactory``."""
-        plugin = factories.TransportFactory('valid')
+        plugin = factories.TransportFactory('valid_Transport')
         assert plugin is Transport
 
+        plugin = factories.TransportFactory('valid_AsyncTransport')
+        assert plugin is AsyncTransport
+
         with pytest.raises(InvalidEntryPointTypeError):
             factories.TransportFactory('invalid')
diff --git a/tests/test_calculation_node.py b/tests/test_calculation_node.py
index 2bd1bd3e32..5250723c85 100644
--- a/tests/test_calculation_node.py
+++ b/tests/test_calculation_node.py
@@ -121,7 +121,7 @@ def test_get_authinfo(self):
 
     def test_get_transport(self):
         """Test that we can get the Transport object from the calculation instance."""
-        from aiida.transports import Transport
+        from aiida.transports import AsyncTransport, Transport
 
         transport = self.calcjob.get_transport()
-        assert isinstance(transport, Transport)
+        assert isinstance(transport, Transport) or isinstance(transport, AsyncTransport)
diff --git a/tests/transports/test_all_plugins.py b/tests/transports/test_all_plugins.py
index 7b4fa6954f..bc8c438e55 100644
--- a/tests/transports/test_all_plugins.py
+++ b/tests/transports/test_all_plugins.py
@@ -12,18 +12,20 @@
 """
 
 import io
+import os
 import shutil
 import signal
 import tempfile
 import time
 import uuid
 from pathlib import Path
+from typing import Union
 
 import psutil
 import pytest
 
 from aiida.plugins import SchedulerFactory, TransportFactory, entry_point
-from aiida.transports import Transport
+from aiida.transports import AsyncTransport, Transport
 
 # TODO : test for copy with pattern
 # TODO : test for copy with/without patterns, overwriting folder
@@ -43,8 +45,12 @@ def tmp_path_local(tmp_path_factory):
     return tmp_path_factory.mktemp('local')
 
 
-@pytest.fixture(scope='function', params=entry_point.get_entry_point_names('aiida.transports'))
-def custom_transport(request, tmp_path_factory, monkeypatch) -> Transport:
+# Skip for any transport plugins that are locally installed but are not part of `aiida-core`
+@pytest.fixture(
+    scope='function',
+    params=[name for name in entry_point.get_entry_point_names('aiida.transports') if name.startswith('core.')],
+)
+def custom_transport(request, tmp_path_factory, monkeypatch) -> Union['Transport', 'AsyncTransport']:
     """Fixture that parametrizes over all the registered implementations of the ``CommonRelaxWorkChain``."""
     plugin = TransportFactory(request.param)
 
@@ -56,8 +62,12 @@ def custom_transport(request, tmp_path_factory, monkeypatch) -> Transport:
         # with the files under operating.
         filepath_config = tmp_path_factory.mktemp('transport') / 'config'
         monkeypatch.setattr(plugin, 'FILEPATH_CONFIG', filepath_config)
-
-        filepath_config.write_text('Host localhost')
+        if not filepath_config.exists():
+            filepath_config.write_text('Host localhost')
+    elif request.param == 'core.ssh_async':
+        kwargs = {
+            'machine': 'localhost',
+        }
     else:
         kwargs = {}
 
@@ -74,69 +84,61 @@ def test_is_open(custom_transport):
     assert not custom_transport.is_open
 
 
-def test_chdir_and_getcwd_deprecated(custom_transport, tmp_path_remote):
-    """Test to be deprecated ``chdir``/``getcwd`` methods still work."""
+def test_makedirs(custom_transport, tmpdir):
+    """Verify the functioning of makedirs command"""
     with custom_transport as transport:
-        location = str(tmp_path_remote)
-        transport.chdir(location)
+        _scratch = Path(tmpdir / 'sampledir')
+        transport.mkdir(_scratch)
+        assert _scratch.exists()
 
-        assert location == transport.getcwd()
+        _scratch = tmpdir / 'sampledir2' / 'subdir'
+        transport.makedirs(_scratch)
+        assert _scratch.exists()
 
-
-def test_chdir_to_empty_string_deprecated(custom_transport, tmp_path_remote):
-    """I check that if I pass an empty string to chdir, the cwd does
-    not change (this is a paramiko default behavior), but getcwd()
-    is still correctly defined.
-    """
-    with custom_transport as transport:
-        new_dir = str(tmp_path_remote)
-        transport.chdir(new_dir)
-        transport.chdir('')
-        assert new_dir == transport.getcwd()
+        # raise if directory already exists
+        with pytest.raises(OSError):
+            transport.makedirs(tmpdir / 'sampledir2')
+        with pytest.raises(OSError):
+            transport.mkdir(tmpdir / 'sampledir')
 
 
-def test_makedirs(custom_transport, tmp_path_remote):
-    """Verify the functioning of makedirs command"""
+def test_is_dir(custom_transport, tmpdir):
     with custom_transport as transport:
-        # define folder structure
-        dir_tree = str(tmp_path_remote / '1' / '2')
-        # I create the tree
-        transport.makedirs(dir_tree)
-        # verify the existence
-        assert transport.isdir(str(tmp_path_remote / '1'))
-        assert dir_tree
-
-        # try to recreate the same folder
-        with pytest.raises(OSError):
-            transport.makedirs(dir_tree)
+        _scratch = tmpdir / 'sampledir'
+        transport.mkdir(_scratch)
 
-        # recreate but with ignore flag
-        transport.makedirs(dir_tree, True)
+        assert transport.isdir(_scratch)
+        assert not transport.isdir(_scratch / 'does_not_exist')
 
 
-def test_rmtree(custom_transport, tmp_path_remote):
+def test_rmtree(custom_transport, tmp_path_remote, tmp_path_local):
     """Verify the functioning of rmtree command"""
     with custom_transport as transport:
-        # define folder structure
-        dir_tree = str(tmp_path_remote / '1' / '2')
-        # I create the tree
-        transport.makedirs(dir_tree)
-        # remove it
-        transport.rmtree(str(tmp_path_remote / '1'))
-        # verify the removal
-        assert not transport.isdir(str(tmp_path_remote / '1'))
-
-        # also tests that it works with a single file
-        # create file
-        local_file_name = 'file.txt'
-        text = 'Viva Verdi\n'
-        single_file_path = str(tmp_path_remote / local_file_name)
-        with open(single_file_path, 'w', encoding='utf8') as fhandle:
-            fhandle.write(text)
-        # remove it
-        transport.rmtree(single_file_path)
-        # verify the removal
-        assert not transport.isfile(single_file_path)
+        _remote = tmp_path_remote
+        _local = tmp_path_local
+
+        Path(_local / 'samplefile').touch()
+
+        # remove a non-empty directory with rmtree()
+        _scratch = _remote / 'sampledir'
+        _scratch.mkdir()
+        Path(_remote / 'sampledir' / 'samplefile_remote').touch()
+        transport.rmtree(_scratch)
+        assert not _scratch.exists()
+
+        # remove a non-empty directory should raise with rmdir()
+        transport.mkdir(_remote / 'sampledir')
+        Path(_remote / 'sampledir' / 'samplefile_remote').touch()
+        with pytest.raises(OSError):
+            transport.rmdir(_remote / 'sampledir')
+
+        # remove a file with remove()
+        transport.remove(_remote / 'sampledir' / 'samplefile_remote')
+        assert not Path(_remote / 'sampledir' / 'samplefile_remote').exists()
+
+        # remove a empty directory with rmdir
+        transport.rmdir(_remote / 'sampledir')
+        assert not _scratch.exists()
 
 
 def test_listdir(custom_transport, tmp_path_remote):
@@ -145,20 +147,20 @@ def test_listdir(custom_transport, tmp_path_remote):
         list_of_dir = ['1', '-f a&', 'as', 'a2', 'a4f']
         list_of_files = ['a', 'b']
         for this_dir in list_of_dir:
-            transport.mkdir(str(tmp_path_remote / this_dir))
+            transport.mkdir(tmp_path_remote / this_dir)
 
         for fname in list_of_files:
             with tempfile.NamedTemporaryFile() as tmpf:
                 # Just put an empty file there at the right file name
-                transport.putfile(tmpf.name, str(tmp_path_remote / fname))
+                transport.putfile(tmpf.name, tmp_path_remote / fname)
 
-        list_found = transport.listdir(str(tmp_path_remote))
+        list_found = transport.listdir(tmp_path_remote)
 
         assert sorted(list_found) == sorted(list_of_dir + list_of_files)
 
-        assert sorted(transport.listdir(str(tmp_path_remote), 'a*')), sorted(['as', 'a2', 'a4f'])
-        assert sorted(transport.listdir(str(tmp_path_remote), 'a?')), sorted(['as', 'a2'])
-        assert sorted(transport.listdir(str(tmp_path_remote), 'a[2-4]*')), sorted(['a2', 'a4f'])
+        assert sorted(transport.listdir(tmp_path_remote, 'a*')), sorted(['as', 'a2', 'a4f'])
+        assert sorted(transport.listdir(tmp_path_remote, 'a?')), sorted(['as', 'a2'])
+        assert sorted(transport.listdir(tmp_path_remote, 'a[2-4]*')), sorted(['a2', 'a4f'])
 
 
 def test_listdir_withattributes(custom_transport, tmp_path_remote):
@@ -177,58 +179,42 @@ def simplify_attributes(data):
         list_of_dir = ['1', '-f a&', 'as', 'a2', 'a4f']
         list_of_files = ['a', 'b']
         for this_dir in list_of_dir:
-            transport.mkdir(str(tmp_path_remote / this_dir))
-
+            transport.mkdir(tmp_path_remote / this_dir)
         for fname in list_of_files:
             with tempfile.NamedTemporaryFile() as tmpf:
                 # Just put an empty file there at the right file name
-                transport.putfile(tmpf.name, str(tmp_path_remote / fname))
+                transport.putfile(tmpf.name, tmp_path_remote / fname)
 
         comparison_list = {k: True for k in list_of_dir}
         for k in list_of_files:
             comparison_list[k] = False
 
-        assert simplify_attributes(transport.listdir_withattributes(str(tmp_path_remote))), comparison_list
-        assert simplify_attributes(transport.listdir_withattributes(str(tmp_path_remote), 'a*')), {
+        assert simplify_attributes(transport.listdir_withattributes(tmp_path_remote)), comparison_list
+        assert simplify_attributes(transport.listdir_withattributes(tmp_path_remote, 'a*')), {
             'as': True,
             'a2': True,
             'a4f': True,
             'a': False,
         }
-        assert simplify_attributes(transport.listdir_withattributes(str(tmp_path_remote), 'a?')), {
+        assert simplify_attributes(transport.listdir_withattributes(tmp_path_remote, 'a?')), {
             'as': True,
             'a2': True,
         }
-        assert simplify_attributes(transport.listdir_withattributes(str(tmp_path_remote), 'a[2-4]*')), {
+        assert simplify_attributes(transport.listdir_withattributes(tmp_path_remote, 'a[2-4]*')), {
             'a2': True,
             'a4f': True,
         }
 
 
-def test_dir_creation_deletion(custom_transport, tmp_path_remote):
-    """Test creating and deleting directories."""
-    with custom_transport as transport:
-        new_dir = str(tmp_path_remote / 'new')
-        transport.mkdir(new_dir)
-
-        with pytest.raises(OSError):
-            # I create twice the same directory
-            transport.mkdir(new_dir)
-
-        transport.isdir(new_dir)
-        assert not transport.isfile(new_dir)
-
-
 def test_dir_copy(custom_transport, tmp_path_remote):
     """Verify if in the copy of a directory also the protection bits
     are carried over
     """
     with custom_transport as transport:
-        # Create a src dir
-        src_dir = str(tmp_path_remote / 'copy_src')
+        src_dir = tmp_path_remote / 'copy_src'
         transport.mkdir(src_dir)
 
-        dst_dir = str(tmp_path_remote / 'copy_dst')
+        dst_dir = tmp_path_remote / 'copy_dst'
         transport.copy(src_dir, dst_dir)
 
         with pytest.raises(ValueError):
@@ -243,7 +229,7 @@ def test_dir_permissions_creation_modification(custom_transport, tmp_path_remote
     non-existing folder
     """
     with custom_transport as transport:
-        directory = str(tmp_path_remote / 'test')
+        directory = tmp_path_remote / 'test'
 
         transport.makedirs(directory)
 
@@ -268,22 +254,20 @@ def test_dir_permissions_creation_modification(custom_transport, tmp_path_remote
         # use get_attribute
 
         # change permissions of an empty string, non existing folder.
-        fake_dir = ''
         with pytest.raises(OSError):
-            transport.chmod(fake_dir, 0o777)
+            transport.chmod('', 0o777)
 
+        # change permissions of a non existing folder.
         fake_dir = 'pippo'
         with pytest.raises(OSError):
             # chmod to a non existing folder
-            transport.chmod(str(tmp_path_remote / fake_dir), 0o777)
+            transport.chmod(tmp_path_remote / fake_dir, 0o777)
 
 
 def test_dir_reading_permissions(custom_transport, tmp_path_remote):
-    """Try to enter a directory with no read permissions.
-    Verify that the cwd has not changed after failed try.
-    """
+    """Try to enter a directory with no read & write permissions."""
     with custom_transport as transport:
-        directory = str(tmp_path_remote / 'test')
+        directory = tmp_path_remote / 'test'
 
         # create directory with non default permissions
         transport.mkdir(directory)
@@ -294,35 +278,47 @@ def test_dir_reading_permissions(custom_transport, tmp_path_remote):
         # test if the security bits have changed
         assert transport.get_mode(directory) == 0
 
-        old_cwd = transport.getcwd()
-
-        with pytest.raises(OSError):
-            transport.chdir(directory)
-
-        new_cwd = transport.getcwd()
-
-        assert old_cwd == new_cwd
+        # TODO : the test leaves a directory even if it is successful
+        #        The bug is in paramiko. After lowering the permissions,
+        #        I cannot restore them to higher values
+        # transport.rmdir(directory)
 
 
-def test_isfile_isdir_to_empty_string(custom_transport):
-    """I check that isdir or isfile return False when executed on an
-    empty string
-    """
+def test_isfile_isdir(custom_transport, tmp_path_remote):
     with custom_transport as transport:
+        # return False on empty string
         assert not transport.isdir('')
         assert not transport.isfile('')
+        # return False on non-existing files
+        assert not transport.isfile(tmp_path_remote / 'does_not_exist')
+        assert not transport.isdir(tmp_path_remote / 'does_not_exist')
+
+        # isfile and isdir should not confuse files and directories
+        Path(tmp_path_remote / 'samplefile').touch()
+        assert transport.isfile(tmp_path_remote / 'samplefile')
+        assert not transport.isdir(tmp_path_remote / 'samplefile')
+
+        transport.mkdir(tmp_path_remote / 'sampledir')
+
+        assert transport.isdir(tmp_path_remote / 'sampledir')
+        assert not transport.isfile(tmp_path_remote / 'sampledir')
 
 
-def test_isfile_isdir_to_non_existing_string(custom_transport, tmp_path_remote):
-    """I check that isdir or isfile return False when executed on an
-    empty string
+def test_chdir_to_empty_string(custom_transport):
+    """I check that if I pass an empty string to chdir, the cwd does
+    not change (this is a paramiko default behavior), but getcwd()
+    is still correctly defined.
+
+    chdir() is no longer an abstract method, to be removed from interface
     """
+    if not hasattr(custom_transport, 'chdir'):
+        return
+
     with custom_transport as transport:
-        fake_folder = str(tmp_path_remote / 'pippo')
-        assert not transport.isfile(fake_folder)
-        assert not transport.isdir(fake_folder)
-        with pytest.raises(OSError):
-            transport.chdir(fake_folder)
+        new_dir = transport.normalize(os.path.join('/', 'tmp'))
+        transport.chdir(new_dir)
+        transport.chdir('')
+        assert new_dir == transport.getcwd()
 
 
 def test_put_and_get(custom_transport, tmp_path_remote, tmp_path_local):
@@ -331,7 +327,7 @@ def test_put_and_get(custom_transport, tmp_path_remote, tmp_path_local):
 
     with custom_transport as transport:
         (tmp_path_local / directory).mkdir()
-        transport.mkdir(str(tmp_path_remote / directory))
+        transport.mkdir(tmp_path_remote / directory)
 
         local_file_name = 'file.txt'
         retrieved_file_name = 'file_retrieved.txt'
@@ -339,9 +335,9 @@ def test_put_and_get(custom_transport, tmp_path_remote, tmp_path_local):
         remote_file_name = 'file_remote.txt'
 
         # here use full path in src and dst
-        local_file_abs_path = str(tmp_path_local / directory / local_file_name)
-        retrieved_file_abs_path = str(tmp_path_local / directory / retrieved_file_name)
-        remote_file_abs_path = str(tmp_path_remote / directory / remote_file_name)
+        local_file_abs_path = tmp_path_local / directory / local_file_name
+        retrieved_file_abs_path = tmp_path_local / directory / retrieved_file_name
+        remote_file_abs_path = tmp_path_remote / directory / remote_file_name
 
         text = 'Viva Verdi\n'
         with open(local_file_abs_path, 'w', encoding='utf8') as fhandle:
@@ -350,7 +346,7 @@ def test_put_and_get(custom_transport, tmp_path_remote, tmp_path_local):
         transport.put(local_file_abs_path, remote_file_abs_path)
         transport.get(remote_file_abs_path, retrieved_file_abs_path)
 
-        list_of_files = transport.listdir(str(tmp_path_remote / directory))
+        list_of_files = transport.listdir((tmp_path_remote / directory))
         # it is False because local_file_name has the full path,
         # while list_of_files has not
         assert local_file_name not in list_of_files
@@ -367,7 +363,7 @@ def test_putfile_and_getfile(custom_transport, tmp_path_remote, tmp_path_local):
 
     with custom_transport as transport:
         (local_dir / directory).mkdir()
-        transport.mkdir(str(remote_dir / directory))
+        transport.mkdir((remote_dir / directory))
 
         local_file_name = 'file.txt'
         retrieved_file_name = 'file_retrieved.txt'
@@ -375,9 +371,9 @@ def test_putfile_and_getfile(custom_transport, tmp_path_remote, tmp_path_local):
         remote_file_name = 'file_remote.txt'
 
         # here use full path in src and dst
-        local_file_abs_path = str(local_dir / directory / local_file_name)
-        retrieved_file_abs_path = str(local_dir / directory / retrieved_file_name)
-        remote_file_abs_path = str(remote_dir / directory / remote_file_name)
+        local_file_abs_path = local_dir / directory / local_file_name
+        retrieved_file_abs_path = local_dir / directory / retrieved_file_name
+        remote_file_abs_path = remote_dir / directory / remote_file_name
 
         text = 'Viva Verdi\n'
         with open(local_file_abs_path, 'w', encoding='utf8') as fhandle:
@@ -386,7 +382,7 @@ def test_putfile_and_getfile(custom_transport, tmp_path_remote, tmp_path_local):
         transport.putfile(local_file_abs_path, remote_file_abs_path)
         transport.getfile(remote_file_abs_path, retrieved_file_abs_path)
 
-        list_of_files = transport.listdir(str(remote_dir / directory))
+        list_of_files = transport.listdir(remote_dir / directory)
         # it is False because local_file_name has the full path,
         # while list_of_files has not
         assert local_file_name not in list_of_files
@@ -403,7 +399,7 @@ def test_put_get_abs_path_file(custom_transport, tmp_path_remote, tmp_path_local
 
     with custom_transport as transport:
         (local_dir / directory).mkdir()
-        transport.mkdir(str(remote_dir / directory))
+        transport.mkdir((remote_dir / directory))
 
         local_file_name = 'file.txt'
         retrieved_file_name = 'file_retrieved.txt'
@@ -412,8 +408,8 @@ def test_put_get_abs_path_file(custom_transport, tmp_path_remote, tmp_path_local
         local_file_rel_path = local_file_name
         remote_file_rel_path = remote_file_name
 
-        retrieved_file_abs_path = str(local_dir / directory / retrieved_file_name)
-        remote_file_abs_path = str(remote_dir / directory / remote_file_name)
+        retrieved_file_abs_path = local_dir / directory / retrieved_file_name
+        remote_file_abs_path = remote_dir / directory / remote_file_name
 
         # partial_file_name is not an abs path
         with pytest.raises(ValueError):
@@ -442,14 +438,14 @@ def test_put_get_abs_path_file(custom_transport, tmp_path_remote, tmp_path_local
 
 def test_put_get_empty_string_file(custom_transport, tmp_path_remote, tmp_path_local):
     """Test of exception put/get of empty strings"""
+    # TODO : verify the correctness of \n at the end of a file
     local_dir = tmp_path_local
     remote_dir = tmp_path_remote
-
     directory = 'tmp_try'
 
     with custom_transport as transport:
         (local_dir / directory).mkdir()
-        transport.mkdir(str(remote_dir / directory))
+        transport.mkdir((remote_dir / directory))
 
         local_file_name = 'file.txt'
         retrieved_file_name = 'file_retrieved.txt'
@@ -457,9 +453,9 @@ def test_put_get_empty_string_file(custom_transport, tmp_path_remote, tmp_path_l
         remote_file_name = 'file_remote.txt'
 
         # here use full path in src and dst
-        local_file_abs_path = str(local_dir / directory / local_file_name)
-        retrieved_file_abs_path = str(local_dir / directory / retrieved_file_name)
-        remote_file_abs_path = str(remote_dir / directory / remote_file_name)
+        local_file_abs_path = local_dir / directory / local_file_name
+        retrieved_file_abs_path = local_dir / directory / retrieved_file_name
+        remote_file_abs_path = remote_dir / directory / remote_file_name
 
         text = 'Viva Verdi\n'
         with open(local_file_abs_path, 'w', encoding='utf8') as fhandle:
@@ -502,12 +498,14 @@ def test_put_get_empty_string_file(custom_transport, tmp_path_remote, tmp_path_l
         t1 = Path(retrieved_file_abs_path).stat().st_mtime_ns
 
         # overwrite retrieved_file_name in 0.01 s
-        time.sleep(0.01)
+        time.sleep(1)
         transport.getfile(remote_file_abs_path, retrieved_file_abs_path)
         assert Path(retrieved_file_abs_path).exists()
         t2 = Path(retrieved_file_abs_path).stat().st_mtime_ns
 
-        # Check st_mtime_ns to sure it is override
+        # Check st_mtime_ns to sure it is overwritten
+        # Note: this test will fail if getfile() would preserve the remote timestamp,
+        # this is supported by core.ssh_async, but the default value is False
         assert t2 > t1
 
 
@@ -532,8 +530,8 @@ def test_put_and_get_tree(custom_transport, tmp_path_remote, tmp_path_local):
             fhandle.write(text)
 
         # here use full path in src and dst
-        transport.puttree(str(local_subfolder), str(remote_subfolder))
-        transport.gettree(str(remote_subfolder), str(retrieved_subfolder))
+        transport.puttree((local_subfolder), (remote_subfolder))
+        transport.gettree((remote_subfolder), (retrieved_subfolder))
 
         list_of_dirs = [p.name for p in (local_dir / directory).iterdir()]
 
@@ -543,7 +541,7 @@ def test_put_and_get_tree(custom_transport, tmp_path_remote, tmp_path_local):
         assert 'tmp1' in list_of_dirs
         assert 'tmp3' in list_of_dirs
 
-        list_pushed_file = transport.listdir(str(remote_subfolder))
+        list_pushed_file = transport.listdir(remote_subfolder)
         list_retrieved_file = [p.name for p in retrieved_subfolder.iterdir()]
         assert 'file.txt' in list_pushed_file
         assert 'file.txt' in list_retrieved_file
@@ -629,7 +627,7 @@ def test_copy(custom_transport, tmp_path_remote):
     with custom_transport as transport:
         workdir = remote_dir / directory
 
-        transport.mkdir(str(workdir))
+        transport.mkdir(workdir)
 
         base_dir = workdir / 'origin'
         base_dir.mkdir()
@@ -644,52 +642,49 @@ def test_copy(custom_transport, tmp_path_remote):
                 fhandle.write(text)
 
         # first test the copy. Copy of two files matching patterns, into a folder
-        transport.copy(str(base_dir / '*.txt'), str(workdir))
-        assert set(['a.txt', 'c.txt', 'origin']) == set(transport.listdir(str(workdir)))
-        transport.remove(str(workdir / 'a.txt'))
-        transport.remove(str(workdir / 'c.txt'))
+        transport.copy(base_dir / '*.txt', workdir)
+        assert set(['a.txt', 'c.txt', 'origin']) == set(transport.listdir(workdir))
+        transport.remove(workdir / 'a.txt')
+        transport.remove(workdir / 'c.txt')
 
         # second test copy. Copy of two folders
-        transport.copy(str(base_dir), str(workdir / 'prova'))
-        assert set(['prova', 'origin']) == set(transport.listdir(str(workdir)))
-        assert set(['a.txt', 'b.tmp', 'c.txt']) == set(transport.listdir(str(workdir / 'prova')))
-        transport.rmtree(str(workdir / 'prova'))
+        transport.copy(base_dir, workdir / 'prova')
+        assert set(['prova', 'origin']) == set(transport.listdir(workdir))
+        assert set(['a.txt', 'b.tmp', 'c.txt']) == set(transport.listdir(workdir / 'prova'))
+        transport.rmtree(workdir / 'prova')
 
         # third test copy. Can copy one file into a new file
-        transport.copy(str(base_dir / '*.tmp'), str(workdir / 'prova'))
-        assert transport.isfile(str(workdir / 'prova'))
-        transport.remove(str(workdir / 'prova'))
+        transport.copy(base_dir / '*.tmp', workdir / 'prova')
+        assert transport.isfile(workdir / 'prova')
+        transport.remove(workdir / 'prova')
 
         # fourth test copy: can't copy more than one file on the same file,
         # i.e., the destination should be a folder
         with pytest.raises(OSError):
-            transport.copy(str(base_dir / '*.txt'), str(workdir / 'prova'))
+            transport.copy(base_dir / '*.txt', workdir / 'prova')
 
         # fifth test, copying one file into a folder
-        transport.mkdir(str(workdir / 'prova'))
-        transport.copy(str(base_dir / 'a.txt'), str(workdir / 'prova'))
-        assert set(transport.listdir(str(workdir / 'prova'))) == set(['a.txt'])
-        transport.rmtree(str(workdir / 'prova'))
+        transport.mkdir((workdir / 'prova'))
+        transport.copy((base_dir / 'a.txt'), (workdir / 'prova'))
+        assert set(transport.listdir((workdir / 'prova'))) == set(['a.txt'])
+        transport.rmtree((workdir / 'prova'))
 
         # sixth test, copying one file into a file
-        transport.copy(str(base_dir / 'a.txt'), str(workdir / 'prova'))
-        assert transport.isfile(str(workdir / 'prova'))
-        transport.remove(str(workdir / 'prova'))
+        transport.copy((base_dir / 'a.txt'), (workdir / 'prova'))
+        assert transport.isfile((workdir / 'prova'))
+        transport.remove((workdir / 'prova'))
         # copy of folder into an existing folder
         # NOTE: the command cp has a different behavior on Mac vs Ubuntu
         # tests performed locally on a Mac may result in a failure.
-        transport.mkdir(str(workdir / 'prova'))
-        transport.copy(str(base_dir), str(workdir / 'prova'))
-        assert set(['origin']) == set(transport.listdir(str(workdir / 'prova')))
-        assert set(['a.txt', 'b.tmp', 'c.txt']) == set(transport.listdir(str(workdir / 'prova' / 'origin')))
-        transport.rmtree(str(workdir / 'prova'))
-        # exit
-        transport.rmtree(str(workdir))
+        transport.mkdir((workdir / 'prova'))
+        transport.copy((base_dir), (workdir / 'prova'))
+        assert set(['origin']) == set(transport.listdir((workdir / 'prova')))
+        assert set(['a.txt', 'b.tmp', 'c.txt']) == set(transport.listdir((workdir / 'prova' / 'origin')))
 
 
 def test_put(custom_transport, tmp_path_remote, tmp_path_local):
     """Test putting files.
-    Those are similar tests of copy, just with the put function which copy from mocked local to mocked remote
+    These are similar tests of copy, just with the put function which copy from mocked local to mocked remote
     and therefore the local path must be absolute
     """
     local_dir = tmp_path_local
@@ -700,7 +695,7 @@ def test_put(custom_transport, tmp_path_remote, tmp_path_local):
         local_workdir = local_dir / directory
         remote_workdir = remote_dir / directory
 
-        transport.mkdir(str(remote_workdir))
+        transport.mkdir(remote_workdir)
 
         local_base_dir: Path = local_workdir / 'origin'
         local_base_dir.mkdir(parents=True)
@@ -715,59 +710,61 @@ def test_put(custom_transport, tmp_path_remote, tmp_path_local):
                 fhandle.write(text)
 
         # first test the put. Copy of two files matching patterns, into a folder
-        transport.put(str(local_base_dir / '*.txt'), str(remote_workdir))
-        assert set(['a.txt', 'c.txt']) == set(transport.listdir(str(remote_workdir)))
-        transport.remove(str(remote_workdir / 'a.txt'))
-        transport.remove(str(remote_workdir / 'c.txt'))
+        transport.put((local_base_dir / '*.txt'), (remote_workdir))
+        assert set(['a.txt', 'c.txt']) == set(transport.listdir((remote_workdir)))
+        transport.remove((remote_workdir / 'a.txt'))
+        transport.remove((remote_workdir / 'c.txt'))
 
         # second test put. Put of two folders
-        transport.put(str(local_base_dir), str(remote_workdir / 'prova'))
-        assert set(['prova']) == set(transport.listdir(str(remote_workdir)))
-        assert set(['a.txt', 'b.tmp', 'c.txt']) == set(transport.listdir(str(remote_workdir / 'prova')))
-        transport.rmtree(str(remote_workdir / 'prova'))
+        transport.put((local_base_dir), (remote_workdir / 'prova'))
+        assert set(['prova']) == set(transport.listdir((remote_workdir)))
+        assert set(['a.txt', 'b.tmp', 'c.txt']) == set(transport.listdir((remote_workdir / 'prova')))
+        transport.rmtree((remote_workdir / 'prova'))
 
         # third test put. Can copy one file into a new file
-        transport.put(str(local_base_dir / '*.tmp'), str(remote_workdir / 'prova'))
-        assert transport.isfile(str(remote_workdir / 'prova'))
-        transport.remove(str(remote_workdir / 'prova'))
+        transport.put((local_base_dir / '*.tmp'), (remote_workdir / 'prova'))
+        assert transport.isfile((remote_workdir / 'prova'))
+        transport.remove((remote_workdir / 'prova'))
 
         # fourth test put: can't copy more than one file to the same file,
         # i.e., the destination should be a folder
         with pytest.raises(OSError):
-            transport.put(str(local_base_dir / '*.txt'), str(remote_workdir / 'prova'))
+            transport.put((local_base_dir / '*.txt'), (remote_workdir / 'prova'))
 
         # can't copy folder to an exist file
         with open(remote_workdir / 'existing.txt', 'w', encoding='utf8') as fhandle:
             fhandle.write(text)
         with pytest.raises(OSError):
-            transport.put(str(local_base_dir), str(remote_workdir / 'existing.txt'))
-        transport.remove(str(remote_workdir / 'existing.txt'))
+            transport.put((local_base_dir), (remote_workdir / 'existing.txt'))
+        transport.remove((remote_workdir / 'existing.txt'))
 
         # fifth test, copying one file into a folder
-        transport.mkdir(str(remote_workdir / 'prova'))
-        transport.put(str(local_base_dir / 'a.txt'), str(remote_workdir / 'prova'))
-        assert set(transport.listdir(str(remote_workdir / 'prova'))) == set(['a.txt'])
-        transport.rmtree(str(remote_workdir / 'prova'))
+        transport.mkdir((remote_workdir / 'prova'))
+        transport.put((local_base_dir / 'a.txt'), (remote_workdir / 'prova'))
+        assert set(transport.listdir((remote_workdir / 'prova'))) == set(['a.txt'])
+        transport.rmtree((remote_workdir / 'prova'))
 
         # sixth test, copying one file into a file
-        transport.put(str(local_base_dir / 'a.txt'), str(remote_workdir / 'prova'))
-        assert transport.isfile(str(remote_workdir / 'prova'))
-        transport.remove(str(remote_workdir / 'prova'))
+        transport.put((local_base_dir / 'a.txt'), (remote_workdir / 'prova'))
+        assert transport.isfile((remote_workdir / 'prova'))
+        transport.remove((remote_workdir / 'prova'))
 
         # put of folder into an existing folder
         # NOTE: the command cp has a different behavior on Mac vs Ubuntu
         # tests performed locally on a Mac may result in a failure.
-        transport.mkdir(str(remote_workdir / 'prova'))
-        transport.put(str(local_base_dir), str(remote_workdir / 'prova'))
-        assert set(['origin']) == set(transport.listdir(str(remote_workdir / 'prova')))
-        assert set(['a.txt', 'b.tmp', 'c.txt']) == set(transport.listdir(str(remote_workdir / 'prova' / 'origin')))
-        transport.rmtree(str(remote_workdir / 'prova'))
+        transport.mkdir((remote_workdir / 'prova'))
+        transport.put((local_base_dir), (remote_workdir / 'prova'))
+        assert set(['origin']) == set(transport.listdir((remote_workdir / 'prova')))
+        assert set(['a.txt', 'b.tmp', 'c.txt']) == set(transport.listdir((remote_workdir / 'prova' / 'origin')))
+        transport.rmtree((remote_workdir / 'prova'))
         # exit
-        transport.rmtree(str(remote_workdir))
+        transport.rmtree((remote_workdir))
 
 
 def test_get(custom_transport, tmp_path_remote, tmp_path_local):
     """Test getting files."""
+    # exactly the same tests of copy, just with the put function
+    # and therefore the local path must be absolute
     local_dir = tmp_path_local
     remote_dir = tmp_path_remote
     directory = 'tmp_try'
@@ -791,27 +788,27 @@ def test_get(custom_transport, tmp_path_remote, tmp_path_local):
                 fhandle.write(text)
 
         # first test get. Get two files matching patterns, from mocked remote folder into a local folder
-        transport.get(str(remote_base_dir / '*.txt'), str(local_workdir))
+        transport.get((remote_base_dir / '*.txt'), (local_workdir))
         assert set(['a.txt', 'c.txt']) == set([p.name for p in (local_workdir).iterdir()])
         (local_workdir / 'a.txt').unlink()
         (local_workdir / 'c.txt').unlink()
 
         # second. Copy of folder into a non existing folder
-        transport.get(str(remote_base_dir), str(local_workdir / 'prova'))
+        transport.get((remote_base_dir), (local_workdir / 'prova'))
         assert set(['prova']) == set([p.name for p in local_workdir.iterdir()])
         assert set(['a.txt', 'b.tmp', 'c.txt']) == set([p.name for p in (local_workdir / 'prova').iterdir()])
         shutil.rmtree(local_workdir / 'prova')
 
         # third. copy of folder into an existing folder
         (local_workdir / 'prova').mkdir()
-        transport.get(str(remote_base_dir), str(local_workdir / 'prova'))
+        transport.get((remote_base_dir), (local_workdir / 'prova'))
         assert set(['prova']) == set([p.name for p in local_workdir.iterdir()])
         assert set(['origin']) == set([p.name for p in (local_workdir / 'prova').iterdir()])
         assert set(['a.txt', 'b.tmp', 'c.txt']) == set([p.name for p in (local_workdir / 'prova' / 'origin').iterdir()])
         shutil.rmtree(local_workdir / 'prova')
 
         # test get one file into a new file prova
-        transport.get(str(remote_base_dir / '*.tmp'), str(local_workdir / 'prova'))
+        transport.get((remote_base_dir / '*.tmp'), (local_workdir / 'prova'))
         assert set(['prova']) == set([p.name for p in local_workdir.iterdir()])
         assert (local_workdir / 'prova').is_file()
         (local_workdir / 'prova').unlink()
@@ -819,22 +816,22 @@ def test_get(custom_transport, tmp_path_remote, tmp_path_local):
         # fourth test copy: can't copy more than one file on the same file,
         # i.e., the destination should be a folder
         with pytest.raises(OSError):
-            transport.get(str(remote_base_dir / '*.txt'), str(local_workdir / 'prova'))
+            transport.get((remote_base_dir / '*.txt'), (local_workdir / 'prova'))
         # copy of folder into file
         with open(local_workdir / 'existing.txt', 'w', encoding='utf8') as fhandle:
             fhandle.write(text)
         with pytest.raises(OSError):
-            transport.get(str(remote_base_dir), str(local_workdir / 'existing.txt'))
+            transport.get((remote_base_dir), (local_workdir / 'existing.txt'))
         (local_workdir / 'existing.txt').unlink()
 
         # fifth test, copying one file into a folder
         (local_workdir / 'prova').mkdir()
-        transport.get(str(remote_base_dir / 'a.txt'), str(local_workdir / 'prova'))
+        transport.get((remote_base_dir / 'a.txt'), (local_workdir / 'prova'))
         assert set(['a.txt']) == set([p.name for p in (local_workdir / 'prova').iterdir()])
         shutil.rmtree(local_workdir / 'prova')
 
         # sixth test, copying one file into a file
-        transport.get(str(remote_base_dir / 'a.txt'), str(local_workdir / 'prova'))
+        transport.get((remote_base_dir / 'a.txt'), (local_workdir / 'prova'))
         assert (local_workdir / 'prova').is_file()
         (local_workdir / 'prova').unlink()
 
@@ -846,9 +843,9 @@ def test_put_get_abs_path_tree(custom_transport, tmp_path_remote, tmp_path_local
     directory = 'tmp_try'
 
     with custom_transport as transport:
-        local_subfolder = str(local_dir / directory / 'tmp1')
-        remote_subfolder = str(remote_dir / 'tmp2')
-        retrieved_subfolder = str(local_dir / directory / 'tmp3')
+        local_subfolder = local_dir / directory / 'tmp1'
+        remote_subfolder = remote_dir / 'tmp2'
+        retrieved_subfolder = local_dir / directory / 'tmp3'
 
         (local_dir / directory / local_subfolder).mkdir(parents=True)
 
@@ -858,7 +855,7 @@ def test_put_get_abs_path_tree(custom_transport, tmp_path_remote, tmp_path_local
         with open(local_file_name, 'w', encoding='utf8') as fhandle:
             fhandle.write(text)
 
-        # here use full path in src and dst
+        # here use absolute path in src and dst
         # 'tmp1' is not an abs path
         with pytest.raises(ValueError):
             transport.put('tmp1', remote_subfolder)
@@ -922,7 +919,7 @@ def test_put_get_empty_string_tree(custom_transport, tmp_path_remote, tmp_path_l
         with pytest.raises(OSError):
             transport.puttree(local_subfolder, '')
 
-        transport.puttree(str(local_subfolder), str(remote_subfolder))
+        transport.puttree(local_subfolder, remote_subfolder)
 
         # remote path is an empty string
         with pytest.raises(OSError):
@@ -935,7 +932,7 @@ def test_put_get_empty_string_tree(custom_transport, tmp_path_remote, tmp_path_l
 
         # TODO : get doesn't retrieve empty files.
         # Is it what we want?
-        transport.gettree(str(remote_subfolder), str(retrieved_subfolder))
+        transport.gettree((remote_subfolder), (retrieved_subfolder))
 
         assert 'file.txt' in [p.name for p in retrieved_subfolder.iterdir()]
 
@@ -946,13 +943,13 @@ def test_gettree_nested_directory(custom_transport, tmp_path_remote, tmp_path_lo
     dir_path = tmp_path_remote / 'sub' / 'path'
     dir_path.mkdir(parents=True)
 
-    file_path = str(dir_path / 'filename.txt')
+    file_path = dir_path / 'filename.txt'
 
     with open(file_path, 'wb') as handle:
         handle.write(content)
 
     with custom_transport as transport:
-        transport.gettree(str(tmp_path_remote), str(tmp_path_local))
+        transport.gettree((tmp_path_remote), (tmp_path_local))
 
     assert (tmp_path_local / 'sub' / 'path' / 'filename.txt').is_file
 
@@ -963,21 +960,34 @@ def test_exec_pwd(custom_transport, tmp_path_remote):
     escaping of funny characters, both in the directory
     creation (which should be done by paramiko) and in the command
     execution (done in this module, in the _exec_command_internal function).
+
+    Note: chdir() & getcwd() is no longer an abstract method, therefore this test is skipped for AsyncSshTransport.
     """
     # Start value
+    if not hasattr(custom_transport, 'chdir'):
+        return
+
     with custom_transport as transport:
         # To compare with: getcwd uses the normalized ('realpath') path
+        location = transport.normalize('/tmp')
         subfolder = """_'s f"#"""  # A folder with characters to escape
-        subfolder_fullpath = str(tmp_path_remote / subfolder)
+        subfolder_fullpath = os.path.join(location, subfolder)
 
-        transport.mkdir(subfolder_fullpath)
+        transport.chdir(location)
+        if not transport.isdir(subfolder):
+            # Since I created the folder, I will remember to
+            # delete it at the end of this test
+            transport.mkdir(subfolder)
 
-        assert transport.isdir(subfolder_fullpath)
+            assert transport.isdir(subfolder)
+            transport.chdir(subfolder)
 
-        retcode, stdout, stderr = transport.exec_command_wait(f'ls {tmp_path_remote!s}')
-        assert retcode == 0
-        assert stdout.strip() in subfolder_fullpath
-        assert stderr == ''
+            assert subfolder_fullpath == transport.getcwd()
+            retcode, stdout, stderr = transport.exec_command_wait('pwd')
+            assert retcode == 0
+            # I have to strip it because 'pwd' returns a trailing \n
+            assert stdout.strip() == subfolder_fullpath
+            assert stderr == ''
 
 
 def test_exec_with_stdin_string(custom_transport):
@@ -996,6 +1006,11 @@ def test_exec_with_stdin_bytes(custom_transport):
     I test directly the exec_command_wait_bytes function; I also pass some non-unicode
     bytes to check that there is no internal implicit encoding/decoding in the code.
     """
+
+    # Skip this test for AsyncSshTransport
+    if 'AsyncSshTransport' in custom_transport.__str__():
+        return
+
     test_string = b'some_test bytes with non-unicode -> \xfa'
     with custom_transport as transport:
         retcode, stdout, stderr = transport.exec_command_wait_bytes('cat', stdin=test_string)
@@ -1006,6 +1021,11 @@ def test_exec_with_stdin_bytes(custom_transport):
 
 def test_exec_with_stdin_filelike(custom_transport):
     """Test command execution with a stdin from filelike."""
+
+    # Skip this test for AsyncSshTransport
+    if 'AsyncSshTransport' in custom_transport.__str__():
+        return
+
     test_string = 'some_test String'
     stdin = io.StringIO(test_string)
     with custom_transport as transport:
@@ -1025,6 +1045,10 @@ def test_exec_with_stdin_filelike_bytes(custom_transport):
     cannot be decoded to UTF8). (Note: we cannot test for all encodings, we test for
     unicode hoping that this would already catch possible issues.)
     """
+    # Skip this test for AsyncSshTransport
+    if 'AsyncSshTransport' in custom_transport.__str__():
+        return
+
     test_string = b'some_test bytes with non-unicode -> \xfa'
     stdin = io.BytesIO(test_string)
     with custom_transport as transport:
@@ -1044,6 +1068,10 @@ def test_exec_with_stdin_filelike_bytes_decoding(custom_transport):
     cannot be decoded to UTF8). (Note: we cannot test for all encodings, we test for
     unicode hoping that this would already catch possible issues.)
     """
+    # Skip this test for AsyncSshTransport
+    if 'AsyncSshTransport' in custom_transport.__str__():
+        return
+
     test_string = b'some_test bytes with non-unicode -> \xfa'
     stdin = io.BytesIO(test_string)
     with custom_transport as transport:
@@ -1053,6 +1081,10 @@ def test_exec_with_stdin_filelike_bytes_decoding(custom_transport):
 
 def test_exec_with_wrong_stdin(custom_transport):
     """Test command execution with incorrect stdin string."""
+    # Skip this test for AsyncSshTransport
+    if 'AsyncSshTransport' in custom_transport.__str__():
+        return
+
     # I pass a number
     with custom_transport as transport:
         with pytest.raises(ValueError):
@@ -1078,14 +1110,14 @@ def test_transfer_big_stdout(custom_transport, tmp_path_remote):
         # We cannot use tempfile.mkdtemp because we're on a remote folder
         directory_name = 'temp_dir_test_transfer_big_stdout'
         directory_path = tmp_path_remote / directory_name
-        transport.mkdir(str(directory_path))
+        transport.mkdir(directory_path)
 
         with tempfile.NamedTemporaryFile(mode='wb') as tmpf:
             tmpf.write(fcontent.encode('utf8'))
             tmpf.flush()
 
             # I put a file with specific content there at the right file name
-            transport.putfile(tmpf.name, str(directory_path / fname))
+            transport.putfile(tmpf.name, directory_path / fname)
 
         python_code = r"""import sys
 
@@ -1109,11 +1141,11 @@ def test_transfer_big_stdout(custom_transport, tmp_path_remote):
             tmpf.flush()
 
             # I put a file with specific content there at the right file name
-            transport.putfile(tmpf.name, str(directory_path / script_fname))
+            transport.putfile(tmpf.name, directory_path / script_fname)
 
         # I get its content via the stdout; emulate also network slowness (note I cat twice)
         retcode, stdout, stderr = transport.exec_command_wait(
-            f'cat {fname} ; sleep 1 ; cat {fname}', workdir=str(directory_path)
+            f'cat {fname} ; sleep 1 ; cat {fname}', workdir=directory_path
         )
         assert stderr == ''
         assert stdout == fcontent + fcontent
@@ -1121,7 +1153,7 @@ def test_transfer_big_stdout(custom_transport, tmp_path_remote):
 
         # I get its content via the stderr; emulate also network slowness (note I cat twice)
         retcode, stdout, stderr = transport.exec_command_wait(
-            f'cat {fname} >&2 ; sleep 1 ; cat {fname} >&2', workdir=str(directory_path)
+            f'cat {fname} >&2 ; sleep 1 ; cat {fname} >&2', workdir=directory_path
         )
         assert stderr == fcontent + fcontent
         assert stdout == ''
@@ -1135,7 +1167,7 @@ def test_transfer_big_stdout(custom_transport, tmp_path_remote):
         #        line_repetitions, file_line, file_line))
         # However this is pretty slow (and using 'cat' of a file containing only one line is even slower)
 
-        retcode, stdout, stderr = transport.exec_command_wait(f'python3 {script_fname}', workdir=str(directory_path))
+        retcode, stdout, stderr = transport.exec_command_wait(f'python3 {script_fname}', workdir=directory_path)
 
         assert stderr == fcontent
         assert stdout == fcontent
@@ -1163,10 +1195,10 @@ def test_asynchronous_execution(custom_transport, tmp_path):
                 tmpf.write(b'#!/bin/bash\nsleep 10\n')
                 tmpf.flush()
 
-                transport.putfile(tmpf.name, str(tmp_path / script_fname))
+                transport.putfile(tmpf.name, tmp_path / script_fname)
 
             timestamp_before = time.time()
-            job_id_string = scheduler.submit_job(str(tmp_path), script_fname)
+            job_id_string = scheduler.submit_job(tmp_path, script_fname)
 
             elapsed_time = time.time() - timestamp_before
             # We want to get back control. If it takes < 5 seconds, it means that it is not blocking
diff --git a/utils/dependency_management.py b/utils/dependency_management.py
old mode 100755
new mode 100644
diff --git a/uv.lock b/uv.lock
index f569268776..3c84eabf19 100644
--- a/uv.lock
+++ b/uv.lock
@@ -25,6 +25,7 @@ source = { editable = "." }
 dependencies = [
     { name = "alembic" },
     { name = "archive-path" },
+    { name = "asyncssh" },
     { name = "circus" },
     { name = "click" },
     { name = "click-spinner" },
@@ -160,6 +161,7 @@ requires-dist = [
     { name = "alembic", specifier = "~=1.2" },
     { name = "archive-path", specifier = "~=0.4.2" },
     { name = "ase", marker = "extra == 'atomic-tools'", specifier = "~=3.18" },
+    { name = "asyncssh", specifier = "~=2.19.0" },
     { name = "bpython", marker = "extra == 'bpython'", specifier = "~=0.18.0" },
     { name = "circus", specifier = "~=0.18.0" },
     { name = "click", specifier = "~=8.1" },
@@ -191,7 +193,7 @@ requires-dist = [
     { name = "pg8000", marker = "extra == 'tests'", specifier = "~=1.13" },
     { name = "pgsu", specifier = "~=0.3.0" },
     { name = "pgtest", marker = "extra == 'tests'", specifier = "~=1.3,>=1.3.1" },
-    { name = "plumpy", specifier = "~=0.22.3" },
+    { name = "plumpy", specifier = "~=0.23.0" },
     { name = "pre-commit", marker = "extra == 'pre-commit'", specifier = "~=3.5" },
     { name = "psutil", specifier = "~=5.6" },
     { name = "psycopg", extras = ["binary"], specifier = "~=3.0" },
@@ -246,16 +248,15 @@ sdist = { url = "https://files.pythonhosted.org/packages/ea/90/1c9c13f2fdfa96602
 
 [[package]]
 name = "aio-pika"
-version = "9.5.0"
+version = "9.4.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiormq" },
-    { name = "exceptiongroup" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/34/7f/887bd24feaa14f9b7290ca2d4d840af4f340b528a8127fdcd6601b8af0d4/aio_pika-9.5.0.tar.gz", hash = "sha256:d45d49e6543bcdfd2fe4b1a0ee59d931c15a96e99497bc599cf0fddb94061925", size = 48323 }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/69/8649bdb97fa1521af3dafe23dbc5debadd4b01abb2850a4d193dae9b0451/aio_pika-9.4.3.tar.gz", hash = "sha256:fd2b1fce25f6ed5203ef1dd554dc03b90c9a46a64aaf758d032d78dc31e5295d", size = 47693 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/66/89/f4248e0da87cf492a97fdd9166bd14f197fb99baee77a3dcbb6f51289bb8/aio_pika-9.5.0-py3-none-any.whl", hash = "sha256:7e03b80fab5a0d354dca45fb5ac95f074b87c639db34c6a1962cabe0fd95bd56", size = 54165 },
+    { url = "https://files.pythonhosted.org/packages/85/66/cad391d83b7266a667c85c826bb6c0d7f68519a0eed7634098c12fb39a4b/aio_pika-9.4.3-py3-none-any.whl", hash = "sha256:f1423d2d5a8b7315d144efe1773763bf687ac17aa1535385982687e9e5ed49bb", size = 53240 },
 ]
 
 [[package]]
@@ -447,6 +448,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fa/9f/3c3503693386c4b0f245eaf5ca6198e3b28879ca0a40bde6b0e319793453/async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224", size = 6111 },
 ]
 
+[[package]]
+name = "asyncssh"
+version = "2.19.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cryptography" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/75/85/c723aa7dd69570a31b6638c1405e659712f18f569f280da2da27989445d3/asyncssh-2.19.0.tar.gz", hash = "sha256:723dead4d068b558708dc66a4ca7e7a93a813aa9416036eccb9af4c03ae2cf30", size = 533702 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/8f/f0749af566fa39204f6380473e6f9632b804daeb0ecb24cc7de1fc9f2717/asyncssh-2.19.0-py3-none-any.whl", hash = "sha256:bb82ac30ff0cb4393fbaf1114e606ad7a4f13d6c4bdaed423c033ee26b455228", size = 372704 },
+]
+
 [[package]]
 name = "attrs"
 version = "24.2.0"
@@ -1914,16 +1928,16 @@ wheels = [
 
 [[package]]
 name = "kiwipy"
-version = "0.8.4"
+version = "0.8.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "deprecation" },
     { name = "pyyaml" },
     { name = "shortuuid" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/0e/ae/3831e1562f1273195e686796690cba656e8937f414d2efcf47466ebfd949/kiwipy-0.8.4.tar.gz", hash = "sha256:625830fa07faac2c2a307bd3aa1caedac6596f37f9b9aba31b7f84c3d9c9f57a", size = 40782 }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/c9/60f4597b2f7ce9f1ce9f202c1ddc70b857716597d828fc5baa123a2fa17e/kiwipy-0.8.5.tar.gz", hash = "sha256:23b746f60577120764d662673335cea40cf34083d15f1ee8ab4fa6155b50d60f", size = 41087 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/fe/ad668377767dcc44d94258ac3ccbedbd55645cba893da842ed820c4ed937/kiwipy-0.8.4-py3-none-any.whl", hash = "sha256:f2b260f1595689a0d835f1e2bf5373714001203d17c4d94e56ec299e793da495", size = 41753 },
+    { url = "https://files.pythonhosted.org/packages/68/50/2d180b54272d467a3e5eb4d7e64df80a8bb11d483e908404d71905a2801b/kiwipy-0.8.5-py3-none-any.whl", hash = "sha256:b6acf17ba69fdfc9ce246673efd35e1db06a27b2c624ba1735d2159f8e665a1b", size = 41820 },
 ]
 
 [package.optional-dependencies]
@@ -2919,16 +2933,16 @@ wheels = [
 
 [[package]]
 name = "plumpy"
-version = "0.22.3"
+version = "0.23.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "kiwipy", extra = ["rmq"] },
     { name = "nest-asyncio" },
     { name = "pyyaml" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ab/99/6c931d3f4697acd34cf18eb3fbfe96ed55cd0408d9be7c0f316349117a8e/plumpy-0.22.3.tar.gz", hash = "sha256:e58f45e6360f173babf04e2a4abacae9867622768ce2a126c8260db3b46372c4", size = 73582 }
+sdist = { url = "https://files.pythonhosted.org/packages/05/49/1b3fb528192668bcae90e5aaa695c85d1759edfd04568b120bb3c61977e3/plumpy-0.23.0.tar.gz", hash = "sha256:ec3cf7d16edcb377eba89f1a6aca9eeed534d5d639eaa5d6e40772d50872b5c8", size = 73920 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/95/d9/12fd8281f494ca79d6a7a9d40099616d16415be5807959e5b024dffe8aed/plumpy-0.22.3-py3-none-any.whl", hash = "sha256:63ae6c90713f52483836a3b2b3e1941eab7ada920c303092facc27e78229bdc3", size = 74244 },
+    { url = "https://files.pythonhosted.org/packages/db/d6/46d534213aea8e8a1826752d094cce527b264fdf37e3f00e329bc9ce85a8/plumpy-0.23.0-py3-none-any.whl", hash = "sha256:bd2a48933bb1bfc1f327f3e600ad9c0d8cc985ab00b1e6ed9f2772a97f8634a4", size = 73533 },
 ]
 
 [[package]]