diff --git a/.github/workflows/gempyor-ci.yml b/.github/workflows/gempyor-ci.yml
index d70d19071..451235d8d 100644
--- a/.github/workflows/gempyor-ci.yml
+++ b/.github/workflows/gempyor-ci.yml
@@ -43,6 +43,7 @@ jobs:
         shell: bash
       - name: Run gempyor tests
         run: |
+          export FLEPI_PATH=$(pwd)
           cd flepimop/gempyor_pkg
           pytest --exitfirst
         shell: bash
diff --git a/.gitignore b/.gitignore
index 6eb84927e..1e9726360 100644
--- a/.gitignore
+++ b/.gitignore
@@ -78,3 +78,6 @@ flepimop/gempyor_pkg/.coverage
 
 # Environment variables
 .env
+
+# info/ directory
+info/**/*.json
diff --git a/flepimop/gempyor_pkg/pyproject.toml b/flepimop/gempyor_pkg/pyproject.toml
index 6f90e1053..dfb6b28bd 100644
--- a/flepimop/gempyor_pkg/pyproject.toml
+++ b/flepimop/gempyor_pkg/pyproject.toml
@@ -20,11 +20,13 @@ dependencies = [
     "emcee",
     "graphviz",
     "h5py",
+    "Jinja2",
     "matplotlib",
     "numba>=0.53.1",
     "numpy",
     "pandas",
     "pyarrow",
+    "pydantic",
     "scipy",
     "seaborn",
     "sympy",
@@ -51,7 +53,8 @@ gempyor-simulate = "gempyor.simulate:_deprecated_simulate"
 
 [tool.setuptools]
 package-dir = {"" = "src"}
-include-package-data = false
+include-package-data = true
+package-data = { "gempyor" = ["templates/*.j2"] }
 
 [tool.setuptools.packages.find]
 where = ["src"]
diff --git a/flepimop/gempyor_pkg/src/gempyor/_jinja.py b/flepimop/gempyor_pkg/src/gempyor/_jinja.py
new file mode 100644
index 000000000..bae0e9aae
--- /dev/null
+++ b/flepimop/gempyor_pkg/src/gempyor/_jinja.py
@@ -0,0 +1,120 @@
+"""
+Internal Jinja2 template rendering utilities.
+
+This module contains utilities for finding and rendering Jinja2 templates. This module
+is tightly coupled to the organization of the package and not intended for external use.
+"""
+
+# Exports
+__all__ = []
+
+
+# Imports
+from os.path import dirname
+from pathlib import Path
+from tempfile import mkstemp
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader, PackageLoader, Template
+
+
+# Globals
+try:
+    _jinja_environment = Environment(
+        loader=FileSystemLoader(dirname(__file__).replace("\\", "/") + "/templates")
+    )
+except ValueError:
+    _jinja_environment = Environment(loader=PackageLoader("gempyor"))
+
+
+# Functions
+def _get_template(name: str) -> Template:
+    """
+    Get a jinja template by name.
+
+    Args:
+        name: The name of the template to pull.
+
+    Returns:
+        A jinja template object corresponding to `name`.
+
+    Examples:
+        >>> _get_template("test_template.j2")
+        <Template 'test_template.j2'>
+    """
+    return _jinja_environment.get_template(name)
+
+
+def _render_template(name: str, data: dict[str, Any]) -> str:
+    """
+    Render a jinja template by name.
+
+    Args:
+        name: The name of the template to pull.
+        data: The data to pass to the template when rendering.
+
+    Returns:
+        The rendered template as a string.
+
+    Examples:
+        >>> _render_template("test_template.j2", {"name": "Bob"})
+        'Hello Bob!'
+    """
+    return _get_template(name).render(data)
+
+
+def _render_template_to_file(name: str, data: dict[str, Any], file: Path) -> None:
+    """
+    Render a jinja template and save to a file.
+
+    Args:
+        name: The name of the template to pull.
+        data: The data to pass to the template when rendering.
+        file: The file to save the rendered template to.
+
+    Examples:
+        >>> from pathlib import Path
+        >>> file = Path("hi.txt")
+        >>> _render_template_to_file("test_template.j2", {"name": "Jane"}, file)
+        >>> file.read_text()
+        'Hello Jane!'
+    """
+    with file.open(mode="w", encoding="utf-8") as f:
+        f.write(_render_template(name, data))
+
+
+def _render_template_to_temp_file(
+    name: str,
+    data: dict[str, Any],
+    suffix: str | None = None,
+    prefix: str | None = None,
+) -> Path:
+    """
+    Render a jinja template and save to a temporary file.
+
+    Args:
+        name: The name of the template to pull.
+        data: The data to pass to the template when rendering.
+        suffix: The suffix of the temporary file, such as an extension. Passed on to
+            `tempfile.mkstemp`.
+        prefix: The prefix of the temporary file. Passed on to `tempfile.mkstemp`.
+
+    Returns:
+        The file containing the rendered template as a `Path` object.
+
+    See Also:
+        [`tempfile.mkstemp`](https://docs.python.org/3/library/tempfile.html#tempfile.mkstemp)
+
+    Examples:
+        >>> file = _render_template_to_temp_file(
+        ...     "test_template.j2", {"name": "John"}, suffix=".txt", prefix="foo_"
+        ... )
+        >>> file
+        PosixPath('/var/folders/2z/h3pc0p7s3ng1tvxrgsw5kr680000gp/T/foo_ocaomg4k.txt')
+        >>> file.read_text()
+        'Hello John!'
+    """
+    _, tmp = mkstemp(suffix=suffix, prefix=prefix, text=True)
+    tmp = Path(tmp)
+    _render_template_to_file(name, data, tmp)
+    return tmp
diff --git a/flepimop/gempyor_pkg/src/gempyor/batch.py b/flepimop/gempyor_pkg/src/gempyor/batch.py
new file mode 100644
index 000000000..e8bbc78a9
--- /dev/null
+++ b/flepimop/gempyor_pkg/src/gempyor/batch.py
@@ -0,0 +1,1245 @@
+"""
+Functionality for creating and submitting batch jobs.
+
+This module provides functionality for required for batch jobs, including creating 
+metadata and job size calculations for example.
+"""
+
+__all__ = ["BatchSystem", "JobSize", "JobResources", "JobTimeLimit", "write_manifest"]
+
+
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from enum import Enum, auto
+from getpass import getuser
+from itertools import product
+import json
+import math
+from pathlib import Path
+import re
+from shlex import quote
+from stat import S_IXUSR
+import subprocess
+import sys
+from typing import Any, Literal
+
+import click
+
+from ._jinja import _render_template_to_file, _render_template_to_temp_file
+from .file_paths import run_id
+from .info import Cluster, _infer_cluster_from_fqdn, get_cluster_info
+from .logging import get_script_logger
+from .utils import _format_cli_options, _git_checkout, _git_head, _shutil_which, config
+from .shared_cli import (
+    DurationParamType,
+    MemoryParamType,
+    cli,
+    config_file_options,
+    config_files_argument,
+    log_cli_inputs,
+    mock_context,
+    parse_config_files,
+    verbosity_options,
+)
+
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    Self = Any
+
+
+_JOB_NAME_REGEX = re.compile(r"^[a-z]{1}([a-z0-9\_\-]+)?$", flags=re.IGNORECASE)
+
+
+class BatchSystem(Enum):
+    """
+    Enum representing the various batch systems that flepiMoP can run on.
+    """
+
+    AWS = auto()
+    LOCAL = auto()
+    SLURM = auto()
+
+    @classmethod
+    def from_options(
+        cls,
+        batch_system: Literal["aws", "local", "slurm"] | None,
+        aws: bool,
+        local: bool,
+        slurm: bool,
+    ) -> "BatchSystem":
+        """
+        Resolve the batch system options.
+
+        Args:
+            batch_system: The name of the batch system to use if provided explicitly by
+                name or `None` to rely on the other flags.
+            aws: A flag indicating if the batch system should be AWS.
+            local: A flag indicating if the batch system should be local.
+            slurm: A flag indicating if the batch system should be slurm.
+
+        Returns:
+            The name of the batch system to use given the user options.
+        """
+        batch_system = batch_system.lower() if batch_system is not None else batch_system
+        if (boolean_flags := sum((aws, local, slurm))) > 1:
+            raise ValueError(
+                f"There were {boolean_flags} boolean flags given, expected either 0 or 1."
+            )
+        if batch_system is not None:
+            for name, flag in zip(("aws", "local", "slurm"), (aws, local, slurm)):
+                if flag and batch_system != name:
+                    raise ValueError(
+                        "Conflicting batch systems given. The batch system name "
+                        f"is '{batch_system}' and the flags indicate '{name}'."
+                    )
+        if batch_system is None:
+            if aws:
+                batch_system = "aws"
+            elif local:
+                batch_system = "local"
+            else:
+                batch_system = "slurm"
+        if batch_system == "aws":
+            return cls.AWS
+        elif batch_system == "local":
+            return cls.LOCAL
+        return cls.SLURM
+
+
+@dataclass(frozen=True, slots=True)
+class JobSize:
+    """
+    A batch submission job size.
+
+    Attributes:
+        jobs: The number of jobs to use.
+        simulations: The number of simulations to run per a block.
+        blocks: The number of sequential blocks to run per a job.
+
+    Raises:
+        ValueError: If any of the attributes are less than 1.
+    """
+
+    jobs: int
+    simulations: int
+    blocks: int
+
+    def __post_init__(self) -> None:
+        for p in self.__slots__:
+            if (val := getattr(self, p)) < 1:
+                raise ValueError(
+                    (
+                        f"The '{p}' attribute must be greater than 0, "
+                        f"but instead was given '{val}'."
+                    )
+                )
+
+    @classmethod
+    def from_jobs_simulations_blocks(
+        cls,
+        jobs: int | None,
+        simulations: int | None,
+        blocks: int | None,
+        inference_method: Literal["emcee"] | None,
+        batch_system: BatchSystem | None,
+    ) -> "JobSize":
+        """
+        Infer a job size from several explicit and implicit parameters.
+
+        Args:
+            jobs: An explicit number of jobs.
+            simulations: An explicit number of simulations per a block.
+            blocks: An explicit number of blocks per a job.
+            inference_method: The inference method being used as different methods have
+                different restrictions.
+
+        Returns:
+            A job size instance with either the explicit or inferred job sizing.
+        """
+        if batch_system == BatchSystem.LOCAL:
+            blocks = 11 if blocks is None else blocks
+            simulations = 11 if simulations is None else simulations
+            return cls(jobs=1, simulations=min(blocks * simulations, 10), blocks=1)
+        if inference_method == "emcee":
+            return cls(jobs=jobs, simulations=blocks * simulations, blocks=1)
+        return cls(jobs=jobs, simulations=simulations, blocks=blocks)
+
+
+@dataclass(frozen=True, slots=True)
+class JobResources:
+    """
+    A batch submission job resources request.
+
+    Attributes:
+        nodes: The number of nodes to request.
+        cpus: The number of CPUs to request per a node.
+        memory: The amount of memory to request per a node in MB.
+
+    Raises:
+        ValueError: If any of the attributes are less than 1.
+    """
+
+    nodes: int
+    cpus: int
+    memory: int
+
+    def __post_init__(self) -> None:
+        for p in self.__slots__:
+            if (val := getattr(self, p)) < 1:
+                raise ValueError(
+                    (
+                        f"The '{p}' attribute must be greater than 0, "
+                        f"but instead was given '{val}'."
+                    )
+                )
+
+    @classmethod
+    def from_presets(
+        cls,
+        job_size: JobSize,
+        inference_method: Literal["emcee"] | None,
+        nodes: int | None = None,
+        cpus: int | None = None,
+        memory: int | None = None,
+    ) -> "JobResources":
+        """
+        Calculate suggested job resources from presets with optional overrides.
+
+        Args:
+            job_size: The size of the job being ran.
+            inference_method: The inference method being used for this job.
+            nodes: Optional manual override for the number of nodes.
+            cpus: Optional manual override for the number of CPUs per node.
+            memory: Optional manual override for the amount of memory per node.
+
+        Returns:
+            A job resources instances scaled to the job size given.
+        """
+        if inference_method == "emcee":
+            nodes = 1 if nodes is None else nodes
+            cpus = 2 * job_size.jobs if cpus is None else cpus
+            memory = 2 * 1024 * job_size.simulations if memory is None else memory
+        else:
+            nodes = job_size.jobs if nodes is None else nodes
+            cpus = 2 if cpus is None else cpus
+            memory = 2 * 1024 if memory is None else memory
+        return cls(nodes=nodes, cpus=cpus, memory=memory)
+
+    @property
+    def total_cpus(self) -> int:
+        """
+        Calculate the total number of CPUs.
+
+        Returns:
+            The total number of CPUs represented by this instance.
+        """
+        return self.nodes * self.cpus
+
+    @property
+    def total_memory(self) -> int:
+        """
+        Calculate the total amount of memory.
+
+        Returns:
+            The total amount of memory represented by this instance.
+        """
+        return self.nodes * self.memory
+
+    def total_resources(self) -> tuple[int, int, int]:
+        """
+        Calculate the total resources.
+
+        Returns:
+            A tuple of the nodes, total CPUs, and total memory represented by
+            this instance.
+        """
+        return (self.nodes, self.total_cpus, self.total_memory)
+
+    def format_nodes(self, batch_system: BatchSystem | None) -> str:
+        return str(self.nodes)
+
+    def format_cpus(self, batch_system: BatchSystem | None) -> str:
+        return str(self.cpus)
+
+    def format_memory(self, batch_system: BatchSystem | None) -> str:
+        if batch_system == BatchSystem.SLURM:
+            return f"{self.memory}MB"
+        return str(self.memory)
+
+
+@dataclass(frozen=True, slots=True)
+class JobTimeLimit:
+    """
+    A batch submission job time limit.
+
+    Attributes:
+        time_limit: The time limit of the batch job.
+
+    Raises:
+        ValueError: If the `time_limit` attribute is not positive.
+    """
+
+    time_limit: timedelta
+
+    def __post_init__(self) -> None:
+        if (total_seconds := self.time_limit.total_seconds()) <= 0.0:
+            raise ValueError(
+                f"The `time_limit` attribute has {math.floor(total_seconds):,} "
+                "seconds, which is less than or equal to 0."
+            )
+
+    def __str__(self) -> str:
+        return self.format()
+
+    def __hash__(self) -> int:
+        return hash(self.time_limit)
+
+    def __eq__(self, other: Self | timedelta) -> bool:
+        if isinstance(other, JobTimeLimit):
+            return self.time_limit == other.time_limit
+        if isinstance(other, timedelta):
+            return self.time_limit == other
+        raise TypeError(
+            "'==' not supported between instances of "
+            f"'JobTimeLimit' and '{type(other).__name__}'."
+        )
+
+    def __lt__(self, other: Self | timedelta) -> bool:
+        if isinstance(other, JobTimeLimit):
+            return self.time_limit < other.time_limit
+        if isinstance(other, timedelta):
+            return self.time_limit < other
+        raise TypeError(
+            "'<' not supported between instances of "
+            f"'JobTimeLimit' and '{type(other).__name__}'."
+        )
+
+    def __le__(self, other: Self | timedelta) -> bool:
+        return self.__eq__(other) or self.__lt__(other)
+
+    def __gt__(self, other: Self | timedelta) -> bool:
+        return not self.__le__(other)
+
+    def __ge__(self, other: Self | timedelta) -> bool:
+        return self.__eq__(other) or self.__gt__(other)
+
+    def format(self, batch_system: BatchSystem | None = None) -> str:
+        """
+        Format the job time limit as a string appropriate for a given batch system.
+
+        Args:
+            batch_system: The batch system the format should be formatted for.
+
+        Returns:
+            The time limit formatted for the batch system.
+
+        Examples:
+            >>> from gempyor.batch import BatchSystem
+            >>> from datetime import timedelta
+            >>> job_time_limit = JobTimeLimit(
+            ...     time_limit=timedelta(days=1, hours=2, minutes=34, seconds=5)
+            ... )
+            >>> job_time_limit.format()
+            '1595'
+            >>> job_time_limit.format(batch_system=BatchSystem.SLURM)
+            '26:34:05'
+        """
+        if batch_system == BatchSystem.SLURM:
+            total_seconds = self.time_limit.total_seconds()
+            hours = math.floor(total_seconds / (60.0 * 60.0))
+            minutes = math.floor((total_seconds - (60.0 * 60.0 * hours)) / 60.0)
+            seconds = math.ceil(total_seconds - (60.0 * minutes) - (60.0 * 60.0 * hours))
+            return f"{hours}:{minutes:02d}:{seconds:02d}"
+        limit_in_mins = math.ceil(self.time_limit.total_seconds() / 60.0)
+        return str(limit_in_mins)
+
+    @classmethod
+    def from_per_simulation_time(
+        cls, job_size: JobSize, time_per_simulation: timedelta, initial_time: timedelta
+    ) -> "JobTimeLimit":
+        """
+        Construct a job time limit that scales with job size.
+
+        Args:
+            job_size: The job size to scale the time limit with.
+            time_per_simulation: The time per a simulation.
+            initial_time: Time required to setup per a job.
+
+        Returns:
+            A job time limit that is scaled to match `job_size`.
+
+        Raises:
+            ValueError: If `time_per_simulation` is non-positive.
+            ValueError: If `initial_time` is non-positive.
+        """
+        if (total_seconds := time_per_simulation.total_seconds()) <= 0.0:
+            raise ValueError(
+                f"The `time_per_simulation` is '{math.floor(total_seconds):,}' "
+                "seconds, which is less than or equal to 0."
+            )
+        if (total_seconds := initial_time.total_seconds()) <= 0.0:
+            raise ValueError(
+                f"The `initial_time` is '{math.floor(total_seconds):,}' "
+                "seconds, which is less than or equal to 0."
+            )
+        time_limit = (
+            job_size.blocks * job_size.simulations * time_per_simulation
+        ) + initial_time
+        return cls(time_limit=time_limit)
+
+
+def write_manifest(
+    job_name: str,
+    flepi_path: Path,
+    project_path: Path,
+    destination: Path | None = None,
+    **additional_meta: Any,
+) -> Path:
+    """
+    Write job metadata to a manifest file.
+
+    This function produces a manifest metadata file for a batch run. By default the
+    json generated by this function will contain:
+    * 'cmd': The command line arguments provided to the CLI script invoked.
+    * 'job_name': A human readable unique job name.
+    * 'data_sha': The git commit of the project git repository, called 'data' for
+        legacy reasons.
+    * 'flepimop_sha': The git commit of the flepiMoP git repository.
+    Further data can be provided via `**additional_meta`, but these values are
+    overridden by the defaults described above.
+
+    Args:
+        job_name: A user specified or generated from user specified values unique name
+            for the job.
+        flepi_path: The path to the flepiMoP git repository being used.
+        project_path: The path to the project git repository being used.
+        destination: Either a path to where the json file should be written or `None` to
+            write the json file to 'manifest.json' in the current working directory.
+        additional_meta: User specified additional fields added to the manifest json.
+            Values with the name 'cmd', 'job_name', 'data_sha', or 'flepimop_sha' will
+            be overridden by the default behavior. Must be a json encodable type.
+
+    Returns:
+        The path to the written json file.
+
+    Examples:
+        >>> from pathlib import Path
+        >>> flepi_path = Path("~/Desktop/GitHub/HopkinsIDD/flepiMoP").expanduser()
+        >>> project_path = Path("~/Desktop/GitHub/HopkinsIDD/flepimop_sample").expanduser()
+        >>> manifest = write_manifest("Foobar", flepi_path, project_path)
+        >>> manifest.name
+        'manifest.json'
+        >>> print(manifest.read_text())
+        {
+            "cmd": "",
+            "job_name": "Foobar",
+            "data_sha": "59fe36d13fe34b6c1fb5c92bf8c53b83bd3ba593",
+            "flepimop_sha": "2bdfbc74e69bdd0243ef8340dda238f5504f1ad9"
+        }
+    """
+    flepimop_sha = _git_head(flepi_path)
+    data_sha = _git_head(project_path)
+
+    manifest = {
+        "cmd": " ".join(sys.argv),
+        "job_name": job_name,
+        "data_sha": data_sha,
+        "flepimop_sha": flepimop_sha,
+    }
+    if additional_meta:
+        manifest = {**additional_meta, **manifest}
+
+    destination = Path("manifest.json").absolute() if destination is None else destination
+    with destination.open(mode="w", encoding="utf-8") as f:
+        json.dump(manifest, f, indent=4)
+
+    return destination
+
+
+def _local(script: Path, verbosity: int | None, dry_run: bool) -> None:
+    """
+    Execute a local script.
+
+    Args:
+        script: The script to run.
+        verbosity: A integer verbosity level to enable logging or `None` for no logging.
+        dry_run: A boolean indicating if this is a dry run or not, if set to `True` this
+            function will not actually execute the script given.
+    """
+    if verbosity is not None:
+        logger = get_script_logger(__name__, verbosity)
+        logger.debug("Using script '%s' for local execution", script.absolute())
+
+    if not script.exists() or not script.is_file():
+        raise ValueError(
+            f"The script '{script.absolute()}' either does not exist or is not a file."
+        )
+    if not bool((current_perms := script.stat().st_mode) & S_IXUSR):
+        if verbosity is not None:
+            logger.warning(
+                "The script '%s' is not executable, making it executable.",
+                script.absolute(),
+            )
+        new_perms = current_perms | S_IXUSR
+        script.chmod(new_perms)
+    cmd_args = [str(script.absolute())]
+
+    if dry_run:
+        if verbosity is not None:
+            logger.info(
+                "If not dry mode would have executed script with: %s",
+                " ".join(cmd_args),
+            )
+        return
+
+    if verbosity is not None:
+        logger.info("Executing script with: %s", " ".join(cmd_args))
+    process = subprocess.run(cmd_args, capture_output=True)
+    stdout = process.stdout.decode().strip()
+    stderr = process.stderr.decode().strip()
+    if verbosity is not None:
+        if process.returncode != 0:
+            logger.critical(
+                "Received non-zero exit code, %u, from executed script.", process.returncode
+            )
+        if stdout:
+            logger.debug("Captured stdout from executed script: %s", stdout)
+        if stderr:
+            logger.error("Captured stderr from executed script: %s", stderr)
+
+
+def _local_template(
+    template: str,
+    script: Path | None,
+    template_data: dict[str, Any],
+    verbosity: int | None,
+    dry_run: bool,
+) -> Path:
+    """
+    Execute a local script generated from a template.
+
+    Args:
+        template: The name of the template to use for rendering the executable script.
+        script: Either the path of where to save the rendered executable script to or
+            `None` for a tmp file.
+        template_data: Data accessible to the template when rendering.
+        verbosity: A integer verbosity level to enable logging or `None` for no logging.
+        dry_run: A boolean indicating if this is a dry run or not, if set to `True` this
+            function will not actually submit a job to slurm.
+
+    Returns:
+        The rendered executable script, either a tmp file if `script` is None otherwise
+        `script` is returned.
+    """
+    if script is None:
+        script = _render_template_to_temp_file(template, template_data, suffix=".bash")
+        new_perms = script.stat().st_mode | S_IXUSR
+        script.chmod(new_perms)
+    else:
+        _render_template_to_file(template, template_data, script)
+    _local(script, verbosity, dry_run)
+    return script
+
+
+def _sbatch(
+    script: Path,
+    environment_variables: dict[str, Any] | Literal["all", "nil", "none"],
+    options: dict[str, Any],
+    verbosity: int | None,
+    dry_run: bool,
+) -> None:
+    """
+    Submit a job to slurm via the `sbatch` command.
+
+    Args:
+        script: The batch file to submit to slurm.
+        environment_variables: Environment variables to pass to the job via the
+            '--export' option. Keys correspond to the variable name and the value is
+            the variable value. All values are coerced to a string and then escaped.
+            Or can be a literal for one of the '--export' option's special values.
+        options: Options to pass when calling sbatch. Keys correspond to the option
+            name and the value is the option value. Options can be provided as either
+            the long or short name, but this function will not be able to determine that
+            these are duplicates so only using long names is recommended.
+        verbosity: A integer verbosity level to enable logging or `None` for no logging.
+        dry_run: A boolean indicating if this is a dry run or not, if set to `True` this
+            function will not actually submit a job to slurm.
+
+    Raises:
+        ValueError: If 'export' is given as a key in `options` instead of using
+            `environment_variables`.
+
+    Examples:
+        >>> from pathlib import Path
+        >>> _sbatch(
+        ...     Path("my_batch_script.sbatch"),
+        ...     {"VAR1": 1, "VAR2": "true"},
+        ...     {"J": "My job name", "output": Path("out.log")},
+        ...     3,
+        ...     True,
+        ... )
+        2024-10-31 09:26:48,361:DEBUG:gempyor._slurm> Using batch script '/my_batch_script.sbatch' to submit to slurm.
+        2024-10-31 09:26:48,363:INFO:gempyor._slurm> If not dry mode would have submitted to slurm with: /usr/bin/sbatch --export=VAR1=1,VAR2=true -J='My job name' --output=out.log /my_batch_script.sbatch.
+
+    See Also:
+        [`sbatch`'s documentation](https://slurm.schedmd.com/sbatch.html)
+    """
+    if "export" in options:
+        raise ValueError(
+            "Found 'export' in `options`, please use `environment_variables` instead."
+        )
+
+    if verbosity is not None:
+        logger = get_script_logger(__name__, verbosity)
+        logger.debug("Using batch script '%s' to submit to slurm", script.absolute())
+
+    if isinstance(environment_variables, dict):
+        env_vars = [f"{k}={quote(str(v))}" for k, v in environment_variables.items()]
+        export = "--export=" + ",".join(env_vars)
+    else:
+        export = f"--export={environment_variables.upper()}"
+    options = _format_cli_options(options)
+    sbatch_cmd = _shutil_which("sbatch")
+    if len(export) > 9:
+        cmd_args = [sbatch_cmd, export] + options + [str(script.absolute())]
+    else:
+        cmd_args = [sbatch_cmd] + options + [str(script.absolute())]
+
+    if dry_run:
+        if verbosity is not None:
+            logger.info(
+                "If not dry mode would have submitted to slurm with: %s",
+                " ".join(cmd_args),
+            )
+        return
+
+    if verbosity is not None:
+        logger.info("Submitting to slurm with: %s", " ".join(cmd_args))
+    process = subprocess.run(cmd_args, capture_output=True)
+    stdout = process.stdout.decode().strip()
+    stderr = process.stderr.decode().strip()
+    if verbosity is not None:
+        if process.returncode != 0:
+            logger.critical(
+                "Received non-zero exit code, %u, from executed script.", process.returncode
+            )
+        if stdout:
+            logger.debug("Captured stdout from sbatch submission: %s", stdout)
+        if stderr:
+            logger.error("Captured stderr from sbatch submission: %s", stderr)
+
+
+def _sbatch_template(
+    template: str,
+    script: Path | None,
+    template_data: dict[str, Any],
+    environment_variables: dict[str, Any] | Literal["all", "nil", "none"],
+    options: dict[str, Any],
+    verbosity: int | None,
+    dry_run: bool,
+) -> Path:
+    """
+    Submit a job from a template to slurm via the `sbatch` command.
+
+    Args:
+        template: The name of the template to use for rendering the sbatch script.
+        script: Either the path of where to save the rendered sbatch script to or `None`
+            for a tmp file.
+        template_data: Data accessible to the template when rendering.
+        environment_variables: Environment variables to pass to the job via the
+            '--export' option. Keys correspond to the variable name and the value is
+            the variable value. All values are coerced to a string and then escaped.
+            Or can be a literal for one of the '--export' option's special values.
+        options: Options to pass when calling sbatch. Keys correspond to the option
+            name and the value is the option value. Options can be provided as either
+            the long or short name, but this function will not be able to determine that
+            these are duplicates so only using long names is recommended.
+        verbosity: A integer verbosity level to enable logging or `None` for no logging.
+        dry_run: A boolean indicating if this is a dry run or not, if set to `True` this
+            function will not actually submit a job to slurm.
+
+    Returns:
+        The rendered sbatch script, either a tmp file if `script` is None otherwise
+        `script` is returned.
+
+    Raises:
+        ValueError: If 'options' is found in `template_data` and `options` is not empty.
+    """
+    if "options" in template_data and options:
+        raise ValueError(
+            "Found 'options' in `template_data` but `options` is not empty, can only one."
+        )
+    template_data["options"] = _format_cli_options(template_data.get("options", options))
+    if script is None:
+        script = _render_template_to_temp_file(template, template_data, suffix=".sbatch")
+    else:
+        _render_template_to_file(template, template_data, script)
+    _sbatch(script, environment_variables, {}, verbosity, dry_run)
+    return script
+
+
+def _job_name(name: str | None, timestamp: datetime | None) -> str:
+    """
+    Generate a unique human readable job name.
+
+    Args:
+        name: The config name used as a prefix or `None` for no prefix.
+        timestamp: The timestamp used to make the job name unique or `None` to use the
+            current UTC timestamp.
+
+    Returns:
+        A job name that is unique and intended for use when submitting to slurm.
+
+    Raises:
+        ValueError: If `name` does not start with a letter and contains characters other
+            than the alphabet, numbers, underscores or dashes.
+
+    Examples:
+        >>> from gempyor.batch import _job_name
+        >>> _job_name(None, None)
+        '20241105T153818'
+        >>> _job_name("foobar", None)
+        'foobar-20241105T153831'
+        >>> from datetime import datetime, timezone
+        >>> _job_name(None, datetime(2024, 1, 1, tzinfo=timezone.utc))
+        '20240101T000000'
+    """
+    timestamp = datetime.now(timezone.utc) if timestamp is None else timestamp
+    timestamp = timestamp.strftime("%Y%m%dT%H%M%S")
+    if name is not None and not _JOB_NAME_REGEX.match(name):
+        raise ValueError(f"The given `name`, '{name}', is not a valid safe name.")
+    return f"{name}-{timestamp}" if name else timestamp
+
+
+def _submit_scenario_job(
+    outcome_modifiers_scenario: str | None,
+    seir_modifiers_scenario: str | None,
+    name: str,
+    batch_system: BatchSystem,
+    inference_method: Literal["emcee"] | None,
+    config_out: Path,
+    job_name: str,
+    job_size: JobSize,
+    job_time_limit: JobTimeLimit,
+    job_resources: JobResources,
+    cluster: Cluster | None,
+    kwargs: dict[str, Any],
+    verbosity: int | None,
+    dry_run: bool,
+    now: datetime,
+) -> None:
+    """
+    Submit a job for a scenario.
+
+    Args:
+        outcome_modifiers_scenario: The outcome modifiers scenario to use.
+        seir_modifiers_scenario: The seir modifiers scenario to use.
+        name: The name of the config file used as a prefix for the job name.
+        batch_system: The batch system to submit the job to.
+        inference_method: The inference method being used.
+        config_out: The path to the config file to use.
+        job_name: The name of the job to submit.
+        job_size: The size of the job to submit.
+        job_time_limit: The time limit of the job to submit.
+        job_resources: The resources required for the job to submit.
+        cluster: The cluster information to use for submitting the job.
+        kwargs: Additional options provided to the submit job CLI as keyword arguments.
+        verbosity: A integer verbosity level to enable logging or `None` for no logging.
+        dry_run: A boolean indicating if this is a dry run or not, if set to `True` this
+            function will not actually submit/run a job.
+        now: The current UTC timestamp.
+    """
+    # Get logger
+    if verbosity is not None:
+        logger = get_script_logger(__name__, verbosity)
+        if outcome_modifiers_scenario is None:
+            logger.warning(
+                "The outcome modifiers scenario is `None`, may lead to "
+                "unintended consequences in output file/directory names."
+            )
+        if seir_modifiers_scenario is None:
+            logger.warning(
+                "The seir modifiers scenario is `None`, may lead to "
+                "unintended consequences in output file/directory names."
+            )
+
+    # Modify the job for the given scenario info
+    job_name += f"_{seir_modifiers_scenario}_{outcome_modifiers_scenario}"
+    prefix = f"{name}_{seir_modifiers_scenario}_{outcome_modifiers_scenario}"
+    if verbosity is not None:
+        logger.info(
+            "Preparing a job for outcome and seir modifiers scenarios "
+            "'%s' and '%s', respectively, with job name '%s'.",
+            outcome_modifiers_scenario,
+            seir_modifiers_scenario,
+            job_name,
+        )
+
+    # Generically useful template data, regardless of batch system
+    template_data = {
+        "cluster": None if cluster is None else cluster.model_dump(),
+        "conda_env": kwargs["conda_env"],
+        "config_path": config_out.absolute(),
+        "debug": kwargs["debug"],
+        "flepi_path": kwargs["flepi_path"].absolute(),
+        "inference_method": "" if inference_method is None else inference_method,
+        "job_name": job_name,
+        "jobs": job_size.jobs,
+        "outcome_modifiers_scenario": outcome_modifiers_scenario,
+        "nsamples": (
+            job_size.simulations if kwargs["samples"] is None else kwargs["samples"]
+        ),
+        "nslots": job_size.simulations,  # aka nwalkers
+        "prefix": prefix,
+        "project_path": kwargs["project_path"].absolute(),
+        "reset_chimerics": kwargs["reset_chimerics"],
+        "run_id": kwargs["run_id"],
+        "seir_modifiers_scenario": seir_modifiers_scenario,
+        "simulations": job_size.simulations,
+        "stoch_traj_flag": kwargs["stoch_traj_flag"],
+    }
+
+    # Branch on the specific batch system
+    if batch_system == BatchSystem.LOCAL:
+        # Construct the local execution
+        _local_template(
+            "inference_local.bash.j2",
+            None,
+            template_data,
+            verbosity,
+            dry_run,
+        )
+    elif batch_system == BatchSystem.SLURM:
+        # Cluster info
+        if verbosity is not None:
+            logger.info(
+                "Utilizing info for the '%s' cluster to construct this job", cluster.name
+            )
+            logger.debug(
+                "The full settings for cluster '%s' are %s",
+                cluster.name,
+                cluster.model_dump(),
+            )
+        # Construct the sbatch call
+        options = {
+            "chdir": kwargs["project_path"].absolute(),
+            "comment": f"Generated on {now:%c %Z} and submitted by {getuser()}.",
+            "cpus-per-task": job_resources.format_cpus(batch_system),
+            "job-name": job_name,
+            "mem": job_resources.format_memory(batch_system),
+            "nodes": job_resources.format_nodes(batch_system),
+            "ntasks-per-node": 1,
+            "time": job_time_limit.format(batch_system),
+        }
+        if kwargs["partition"] is not None:
+            options["partition"] = kwargs["partition"]
+        if kwargs["email"] is not None:
+            options["mail-type"] = "BEGIN,END"
+            options["mail-user"] = kwargs["email"]
+        if inference_method is None:
+            options["nodes"] = "1"
+            options["array"] = f"1-{job_size.jobs}"
+        _sbatch_template(
+            "inference_slurm.sbatch.j2",
+            None,
+            template_data,
+            "all",
+            options,
+            verbosity,
+            dry_run,
+        )
+
+
+@cli.command(
+    name="submit",
+    params=[config_files_argument]
+    + list(config_file_options.values())
+    + [
+        click.Option(
+            param_decls=["--simulations", "simulations"],
+            default=None,
+            type=click.IntRange(min=1),
+            help="The number of simulations per a job.",
+        ),
+        click.Option(
+            param_decls=["--blocks", "blocks"],
+            default=None,
+            type=click.IntRange(min=1),
+            help="The number of sequential blocks to run per a job.",
+        ),
+        click.Option(
+            param_decls=["--samples", "samples"],
+            default=None,
+            type=click.IntRange(min=1),
+            help="The number of samples to produce. Defaults to all samples.",
+        ),
+        click.Option(
+            param_decls=["--batch-system", "batch_system"],
+            default=None,
+            type=click.Choice(("aws", "local", "slurm"), case_sensitive=False),
+            help="The name of the batch system being used.",
+        ),
+        click.Option(
+            param_decls=["--aws", "aws"],
+            default=False,
+            type=bool,
+            is_flag=True,
+            help="A flag indicating this is being run on AWS.",
+        ),
+        click.Option(
+            param_decls=["--local", "local"],
+            default=False,
+            type=bool,
+            is_flag=True,
+            help="A flag indicating this is being run local.",
+        ),
+        click.Option(
+            param_decls=["--slurm", "slurm"],
+            default=False,
+            type=bool,
+            is_flag=True,
+            help="A flag indicating this is being run on slurm.",
+        ),
+        click.Option(
+            param_decls=["--flepi-path", "flepi_path"],
+            envvar="FLEPI_PATH",
+            type=click.Path(exists=True, path_type=Path),
+            required=True,
+            help="Path to the flepiMoP directory being used.",
+        ),
+        click.Option(
+            param_decls=["--project-path", "project_path"],
+            envvar="PROJECT_PATH",
+            type=click.Path(exists=True, path_type=Path),
+            required=True,
+            help="Path to the project directory being used.",
+        ),
+        click.Option(
+            param_decls=["--partition", "partition"],
+            type=str,
+            default=None,
+            help="The slurm partition to submit the job to.",
+        ),
+        click.Option(
+            param_decls=["--simulation-time", "simulation_time"],
+            type=DurationParamType(True),
+            default="3min",
+            help="The time limit per a simulation.",
+        ),
+        click.Option(
+            param_decls=["--initial-time", "initial_time"],
+            type=DurationParamType(True),
+            default="20min",
+            help="The initialization time limit.",
+        ),
+        click.Option(
+            param_decls=["--cluster", "cluster"],
+            type=str,
+            default=None,
+            help=(
+                "The name of the cluster this job is being launched on. "
+                "Only applicable to slurm submissions."
+            ),
+        ),
+        click.Option(
+            param_decls=["--conda-env", "conda_env"],
+            type=str,
+            default="flepimop-env",
+            help="The name of the conda environment being used for this batch run.",
+        ),
+        click.Option(
+            param_decls=["--debug", "debug"],
+            type=bool,
+            default=False,
+            is_flag=True,
+            help="Flag to enable debugging in batch submission scripts.",
+        ),
+        click.Option(
+            param_decls=["--config-out", "config_out"],
+            type=click.Path(path_type=Path),
+            default=None,
+            help=(
+                "The location to dump the final parsed config file. "
+                "If not provided a temporary file will be used."
+            ),
+        ),
+        click.Option(
+            param_decls=["--id", "--run-id", "run_id"],
+            envvar="FLEPI_RUN_INDEX",
+            type=str,
+            default=None,
+            help="Unique identifier for this run.",
+        ),
+        click.Option(
+            param_decls=["--email", "email"],
+            type=str,
+            default=None,
+            help="Optionally an email that can be notified on job begin and end.",
+        ),
+        click.Option(
+            param_decls=["--nodes", "nodes"],
+            type=click.IntRange(min=1),
+            default=None,
+            help="Override for the number of nodes to use.",
+        ),
+        click.Option(
+            param_decls=["--cpus", "cpus"],
+            type=click.IntRange(min=1),
+            default=None,
+            help="Override for the number of CPUs per node to use.",
+        ),
+        click.Option(
+            param_decls=["--memory", "memory"],
+            type=MemoryParamType("mb", as_int=True),
+            default=None,
+            help="Override for the amount of memory per node to use in MB.",
+        ),
+        click.Option(
+            param_decls=["--skip-manifest", "skip_manifest"],
+            type=bool,
+            default=False,
+            is_flag=True,
+            help="Flag to skip writing a 'manifest.json' file to the project path.",
+        ),
+        click.Option(
+            param_decls=[
+                "--reset-chimerics-on-global-accept/--no-reset-chimerics-on-global-accept",
+                "reset_chimerics",
+            ],
+            type=bool,
+            default=False,
+            help="Flag to reset chimerics on global accept.",
+        ),
+        click.Option(
+            param_decls=["--skip-checkout", "skip_checkout"],
+            type=bool,
+            default=False,
+            is_flag=True,
+            help="Flag to skip checking out a new branch in the project git directory.",
+        ),
+    ]
+    + list(verbosity_options.values()),
+)
+@click.pass_context
+def _click_submit(ctx: click.Context = mock_context, **kwargs: Any) -> None:
+    """
+    Submit batch inference jobs.
+
+    This CLI tool makes it a breeze to submit batch inference jobs. In general, this
+    tool does:
+
+    1. Determine information about the job such as the inference method, batch system,
+        job size/time limit, and resources.
+    2. Write metadata about the batch job to a 'manifest.json' file.
+    3. Loop over the outcome/seir scenario modifiers and generate/submit batch jobs for
+        each of those.
+    4. Checkout a new branch in the project directory to preserve the outputs.
+
+    To get a better understanding of this tool you can use the `--dry-run` flag which
+    will complete all of steps described above except for submitting the jobs. Or if you
+    would like to test run the batch scripts without submitting to slurm or AWS you can
+    use the `--local` flag which will run the "batch" job locally (only use for small
+    test jobs).
+
+    Here are some common examples to get started:
+
+    1. Assuming you are in your clone of the `HopkinsIDD/flepimop_sample` repository
+    this command will do a dry run of the sample inference configuration with two
+    populations.
+
+    \b
+    ```bash
+    $ flepimop submit --jobs 4 \\ # With legacy inference jobs refers to chains
+        --simulations 20 \\       # The number of iterations per a chain
+        --blocks 1 \\             # The number of consecutive blocks to run
+        --slurm \\                # Use slurm, shorthand for `--batch-system slurm`
+        --project-path $(pwd) \\  # Manually specify the project path
+        --email me@college.edu \\ # Use slurm's built-in email alerts for the job
+        --skip-checkout \\        # Do not create a new branch in the project repo
+        -vvv \\                   # Use the max verbosity
+        --dry-run \\              # Do not actually submit the job via `sbatch`.
+        config_sample_2pop_inference.yml
+    ```
+
+    2. Extending on example (1) let's make some small modifications to submit a "real"
+    job.
+
+    \b
+    ```bash
+    $ flepimop submit --jobs 10 \\               # See before
+        --simulations 400 \\                     # See before
+        --blocks 1 \\                            # See before
+        --slurm \\                               # See before
+        --partition dedicated_slurm_partition \\ # Submit to a particular slurm partition
+        --simulation-time 30s \\                 # Specify the time limit per simulation
+        --initial-time 5min \\                   # Specify the initial time limit
+        --conda-env custom-flepimop-env \\       # Specify a custom conda env to use
+        --cpus 4 \\                              # Use 4 CPUs per a job
+        -vvv \\                                  # Use the max verbosity
+        config_sample_2pop_inference.yml
+    ```
+    """
+    # Generic setup
+    now = datetime.now(timezone.utc)
+    logger = get_script_logger(__name__, kwargs["verbosity"])
+    log_cli_inputs(kwargs)
+    cfg = parse_config_files(config, ctx, **kwargs)
+
+    # Job name/run id
+    name = cfg["name"].get(str) if cfg["name"].exists() else None
+    job_name = _job_name(name, now)
+    logger.info("Assigning job name of '%s'", job_name)
+    if kwargs["run_id"] is None:
+        kwargs["run_id"] = run_id(now)
+    logger.info("Using a run id of '%s'", kwargs["run_id"])
+
+    # Determine inference method
+    inference_method = (
+        cfg["inference"]["method"].as_str()
+        if cfg["inference"].exists() and cfg["inference"]["method"].exists()
+        else None
+    )
+    inference_method = (
+        inference_method if inference_method is None else inference_method.lower()
+    )
+    if kwargs["reset_chimerics"] and inference_method is not None:
+        logger.warning(
+            "The inference method is '%s', which does not support "
+            "the reset chimerics on global accept flag.",
+            inference_method,
+        )
+
+    # Batch system
+    batch_system = BatchSystem.from_options(
+        kwargs["batch_system"], kwargs["aws"], kwargs["local"], kwargs["slurm"]
+    )
+    if batch_system == BatchSystem.AWS:
+        # Temporary limitation
+        raise NotImplementedError(
+            "The `flepimop submit` CLI does not support batch submission to AWS yet."
+        )
+    logger.info("Constructing a job to submit to %s", batch_system)
+    if batch_system != BatchSystem.SLURM and kwargs["email"] is not None:
+        logger.warning(
+            "The email option, given '%s', is only used when "
+            "the batch system is slurm, but is instead %s.",
+            kwargs["email"],
+            batch_system,
+        )
+    if (
+        batch_system == BatchSystem.LOCAL
+        and (cluster_name := _infer_cluster_from_fqdn(raise_error=False)) is not None
+    ):
+        logger.critical(
+            "The batch system is local but detected a cluster, '%s'. "
+            "This will likely result in a vague error.",
+            cluster_name,
+        )
+
+    # Job size
+    job_size = JobSize.from_jobs_simulations_blocks(
+        kwargs["jobs"],
+        kwargs["simulations"],
+        kwargs["blocks"],
+        inference_method,
+        batch_system,
+    )
+    logger.info("Preparing a job with size %s", job_size)
+    if inference_method == "emcee" and job_size.blocks != 1:
+        logger.warning(
+            "When using EMCEE for inference the job size blocks is ignored, given %u.",
+            job_size.blocks,
+        )
+
+    # Job time limit
+    job_time_limit = JobTimeLimit.from_per_simulation_time(
+        job_size, kwargs["simulation_time"], kwargs["initial_time"]
+    )
+    logger.info("Setting a total job time limit of %s minutes", job_time_limit.format())
+
+    # Job resources
+    job_resources = JobResources.from_presets(
+        job_size,
+        inference_method,
+        nodes=kwargs["nodes"],
+        cpus=kwargs["cpus"],
+        memory=kwargs["memory"],
+    )
+    logger.info("Requesting the resources %s for this job.", job_resources)
+
+    # Cluster info
+    cluster = (
+        None
+        if kwargs["cluster"] is None and batch_system != BatchSystem.SLURM
+        else get_cluster_info(kwargs["cluster"])
+    )
+
+    # Manifest
+    if kwargs["skip_manifest"]:
+        logger.debug("Skipped writing manifest metadata.")
+    else:
+        manifest = write_manifest(
+            job_name,
+            kwargs["flepi_path"],
+            kwargs["project_path"],
+            destination=kwargs["project_path"] / "manifest.json",
+        )
+        logger.info("Writing manifest metadata to '%s'", manifest.absolute())
+
+    # Config out
+    if (config_out := kwargs["config_out"]) is None:
+        config_out = kwargs["project_path"] / f"config_{job_name}.yml"
+    with config_out.open(mode="w") as f:
+        f.write(cfg.dump())
+    logger.info(
+        "Dumped the final config for this batch submission to %s", config_out.absolute()
+    )
+
+    # Outcome/seir modifier scenarios
+    outcome_modifiers_scenarios = (
+        cfg["outcome_modifiers"]["scenarios"].as_str_seq()
+        if cfg["outcome_modifiers"].exists()
+        and cfg["outcome_modifiers"]["scenarios"].exists()
+        else [None]
+    )
+    seir_modifiers_scenarios = (
+        cfg["seir_modifiers"]["scenarios"].as_str_seq()
+        if cfg["seir_modifiers"].exists() and cfg["seir_modifiers"]["scenarios"].exists()
+        else [None]
+    )
+
+    # Loop over the scenarios
+    for outcome_modifiers_scenario, seir_modifiers_scenario in product(
+        outcome_modifiers_scenarios, seir_modifiers_scenarios
+    ):
+        _submit_scenario_job(
+            outcome_modifiers_scenario,
+            seir_modifiers_scenario,
+            name,
+            batch_system,
+            inference_method,
+            config_out,
+            job_name,
+            job_size,
+            job_time_limit,
+            job_resources,
+            cluster,
+            kwargs,
+            kwargs["verbosity"],
+            kwargs["dry_run"],
+            now,
+        )
+
+    # Checkout a new branch to preserve run information
+    if kwargs["skip_checkout"]:
+        logger.debug("Skipped checking out a new branch to preserve run.")
+    else:
+        branch = f"run_{job_name}"
+        _git_checkout(kwargs["project_path"], branch)
+        logger.info(
+            "Checked out a new branch, '%s', in the project "
+            "repository to preserve run details.",
+            branch,
+        )
diff --git a/flepimop/gempyor_pkg/src/gempyor/cli.py b/flepimop/gempyor_pkg/src/gempyor/cli.py
index 8e0c0b44e..cf5149cc1 100644
--- a/flepimop/gempyor_pkg/src/gempyor/cli.py
+++ b/flepimop/gempyor_pkg/src/gempyor/cli.py
@@ -10,8 +10,8 @@
 from .utils import config
 
 # register the commands from the other modules
-from . import compartments
-from . import simulate
+from . import compartments, simulate, batch
+
 
 # Guidance for extending the CLI:
 # - to add a new small command to the CLI, add a new function with the @cli.command() decorator here (e.g. patch below)
diff --git a/flepimop/gempyor_pkg/src/gempyor/info.py b/flepimop/gempyor_pkg/src/gempyor/info.py
new file mode 100644
index 000000000..958b29168
--- /dev/null
+++ b/flepimop/gempyor_pkg/src/gempyor/info.py
@@ -0,0 +1,178 @@
+"""
+Retrieving static information from developer managed yaml files.
+
+Currently, it includes utilities for handling cluster-specific information, but it can 
+be extended to other categories as needed.
+
+Classes:
+    Module: Represents a software module with a name and optional version.
+    PathExport: Represents a path export with a path, prepend flag, and error handling.
+    Cluster: Represents a cluster with a name, list of modules, and list of path 
+        exports.
+
+Functions:
+    get_cluster_info: Retrieves cluster-specific information.
+
+Examples:
+    >>> from pprint import pprint
+    >>> from gempyor.info import get_cluster_info
+    >>> cluster_info = get_cluster_info("longleaf")
+    >>> cluster_info.name
+    'longleaf'
+    >>> pprint(cluster_info.modules)
+    [Module(name='gcc', version='9.1.0'),
+    Module(name='anaconda', version='2023.03'),
+    Module(name='git', version=None),
+    Module(name='aws', version=None)]
+"""
+
+__all__ = ["Cluster", "Module", "PathExport", "get_cluster_info"]
+
+
+import os
+from pathlib import Path
+import re
+from socket import getfqdn
+from typing import Pattern, TypeVar
+
+from pydantic import BaseModel
+import yaml
+
+
+class Module(BaseModel):
+    """
+    A model representing a module to load.
+
+    Attributes:
+        name: The name of the module to load.
+        version: The specific version of the module to load if there is one.
+
+    See Also:
+        [Lmod](https://lmod.readthedocs.io/en/latest/)
+    """
+
+    name: str
+    version: str | None = None
+
+
+class PathExport(BaseModel):
+    """
+    A model representing the export path configuration.
+
+    Attributes:
+        path: The file system path of the path to add to the `$PATH` environment
+            variable.
+        prepend: A flag indicating whether to prepend additional information to the
+            `$PATH` environment variable.
+        error_if_missing: A flag indicating whether to raise an error if the path is
+            missing.
+    """
+
+    path: Path
+    prepend: bool = True
+    error_if_missing: bool = False
+
+
+class Cluster(BaseModel):
+    """
+    A model representing a cluster configuration.
+
+    Attributes:
+        name: The name of the cluster.
+        modules: A list of modules associated with the cluster.
+        path_exports: A list of path exports for the cluster.
+    """
+
+    name: str
+    modules: list[Module] = []
+    path_exports: list[PathExport] = []
+
+
+_BASE_MODEL_TYPE = TypeVar("T", bound=BaseModel)
+
+
+_CLUSTER_FQDN_REGEXES: tuple[tuple[str, Pattern], ...] = (
+    ("longleaf", re.compile(r"^longleaf\-login[0-9]+\.its\.unc\.edu$")),
+    ("rockfish", re.compile(r"^login[0-9]+\.cm\.cluster$")),
+)
+
+
+def _get_info(
+    category: str, name: str, model: type[_BASE_MODEL_TYPE], flepi_path: os.PathLike | None
+) -> _BASE_MODEL_TYPE:
+    """
+    Get and parse an information yaml file.
+
+    This function is a light wrapper around reading and parsing yaml files located in
+    `$FLEPI_PATH/info`.
+
+    Args:
+        category: The category of info to get, corresponds to a subdirectory in
+            `$FLEPI_PATH/info`.
+        name: The name of the info to get, corresponds to the name of a yaml file and
+            is usually a human readable short name.
+        model: The pydantic class to parse the info file with, determines the return
+            type.
+        flepi_path: Either a path like determine the directory to look for the info
+            directory in or `None` to use the `FLEPI_PATH` environment variable.
+
+    Returns:
+        An instance of `model` with the contained info found and parsed.
+    """
+    flepi_path = Path(os.getenv("FLEPI_PATH") if flepi_path is None else flepi_path)
+    info = flepi_path / "info" / category / f"{name}.yml"
+    if not info.exists() or not info.is_file():
+        raise ValueError(
+            f"Was expecting an information yaml at {info.absolute()}, "
+            "but either does not exist or is not a file."
+        )
+    return model.model_validate(yaml.safe_load(info.read_text()))
+
+
+def get_cluster_info(name: str | None, flepi_path: os.PathLike | None = None) -> Cluster:
+    """
+    Get cluster specific info.
+
+    Args:
+        name: The name of the cluster to pull information for. Currently only 'longleaf'
+            and 'rockfish' are supported or `None` to infer from the FQDN.
+        flepi_path: Either a path like determine the directory to look for the info
+            directory in or `None` to use the `FLEPI_PATH` environment variable.
+
+    Returns:
+        An object containing the information about the `name` cluster.
+
+    Examples:
+        >>> from gempyor.info import get_cluster_info
+        >>> cluster_info = get_cluster_info("longleaf")
+        >>> cluster_info.name
+        'longleaf'
+    """
+    name = _infer_cluster_from_fqdn() if name is None else name
+    return _get_info("cluster", name, Cluster, flepi_path)
+
+
+def _infer_cluster_from_fqdn(raise_error: bool = True) -> str | None:
+    """
+    Infer the cluster name from the FQDN.
+
+    Args:
+        raise_error: A flag indicating whether to raise an error if the FQDN does not
+            match any of the expected regexes.
+
+    Returns:
+        The name of the cluster inferred from the FQDN.
+
+    Raises:
+        ValueError: If the value of `socket.getfqdn()` does not match an expected regex
+            and `raise_error` is `True`.
+    """
+    fqdn = getfqdn()
+    for cluster, regex in _CLUSTER_FQDN_REGEXES:
+        if regex.match(fqdn):
+            return cluster
+    if raise_error:
+        raise ValueError(
+            f"The fqdn, '{fqdn}', does not match any of the expected clusters."
+        )
+    return None
diff --git a/flepimop/gempyor_pkg/src/gempyor/logging.py b/flepimop/gempyor_pkg/src/gempyor/logging.py
new file mode 100644
index 000000000..cf31bafc3
--- /dev/null
+++ b/flepimop/gempyor_pkg/src/gempyor/logging.py
@@ -0,0 +1,169 @@
+"""
+Logging utilities for consistent script output.
+
+This module provides functionality for creating consistent outputs from CLI tools 
+provided by this package. Currently exported are:
+- `ClickHandler`: Custom logging handler specifically designed for CLI output using 
+    click.
+- `get_script_logger`: Factory for creating a logger instance with a consistent style
+    across CLI tools.
+"""
+
+__all__ = ["ClickHandler", "get_script_logger"]
+
+
+import logging
+import os
+import sys
+from typing import Any, IO
+
+import click
+
+
+DEFAULT_LOG_FORMAT = "%(asctime)s:%(levelname)s:%(name)s> %(message)s"
+
+
+class ClickHandler(logging.Handler):
+    """
+    Custom logging handler specifically for click based CLI tools.
+    """
+
+    _punctuation = (".", ",", "?", "!", ":")
+
+    def __init__(
+        self,
+        level: int | str = 0,
+        file: IO[Any] | None = None,
+        nl: bool = True,
+        err: bool = False,
+        color: bool | None = None,
+        punctuate: bool = True,
+    ) -> None:
+        """
+        Initialize an instance of the click handler.
+
+        Args:
+            level: The logging level to use for this handler.
+            file: The file to write to. Defaults to stdout.
+            nl: Print a newline after the message. Enabled by default.
+            err: Write to stderr instead of stdout.
+            color: Force showing or hiding colors and other styles. By default click
+                will remove color if the output does not look like an interactive
+                terminal.
+            punctuate: A boolean indicating if punctuation should be added to the end
+                of a log message provided if missing.
+
+        Notes:
+            For more details on the `file`, `nl`, `err`, and `color` args please refer
+            to [`click.echo`](https://click.palletsprojects.com/en/8.1.x/api/#click.echo).
+        """
+        super().__init__(level)
+        self._file = file
+        self._nl = nl
+        self._err = err
+        self._color = color
+        self._punctuate = punctuate
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """
+        Emit a given log record via `click.echo`
+
+        Args:
+            record: The log record to output.
+
+        See Also:
+            [`logging.Handler.emit`](https://docs.python.org/3/library/logging.html#logging.Handler.emit)
+        """
+        msg = self.format(record)
+        msg = f"{msg}." if self._punctuate and not msg.endswith(self._punctuation) else msg
+        click.echo(
+            message=msg, file=self._file, nl=self._nl, err=self._err, color=self._color
+        )
+
+
+def get_script_logger(
+    name: str,
+    verbosity: int,
+    handler: logging.Handler | None = None,
+    log_format: str = DEFAULT_LOG_FORMAT,
+) -> logging.Logger:
+    """
+    Create a logger for use in scripts.
+
+    Args:
+        name: The name to display in the log message, useful for locating the source
+            of logging messages. Almost always `__name__`.
+        verbosity: A non-negative integer for the verbosity level.
+        handler: An optional logging handler to use in creating the logger returned, or
+            `None` to just use the `ClickHandler`.
+        log_format: The format to use for logged messages. Passed directly to the `fmt`
+            argument of [logging.Formatter](https://docs.python.org/3/library/logging.html#logging.Formatter).
+
+    Returns:
+        An instance of `logging.Logger` that has the appropriate level set based on
+        `verbosity` and a custom handler for outputting for CLI tools.
+
+    Examples:
+        >>> from gempyor.logging import get_script_logger
+        >>> logger = get_script_logger(__name__, 3)
+        >>> logger.info("This is a log info message")
+        2024-10-29 16:07:20,272:INFO:__main__> This is a log info message.
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(_get_logging_level(verbosity))
+    handler = ClickHandler() if handler is None else handler
+    log_formatter = logging.Formatter(log_format)
+    for old_handler in logger.handlers:
+        logger.removeHandler(old_handler)
+    handler.setFormatter(log_formatter)
+    logger.addHandler(handler)
+    # pytest-dev/pytest#3697
+    logger.propagate = os.path.basename(sys.argv[0]) == "pytest" if sys.argv else False
+    return logger
+
+
+def _get_logging_level(verbosity: int) -> int:
+    """
+    An internal method to convert verbosity to a logging level.
+
+    Args:
+        verbosity: A non-negative integer for the verbosity level or level from
+            `logging` that will be returned as is.
+
+    Examples:
+        >>> _get_logging_level(0)
+        40
+        >>> _get_logging_level(1)
+        30
+        >>> _get_logging_level(2)
+        20
+        >>> _get_logging_level(3)
+        10
+        >>> _get_logging_level(4)
+        10
+        >>> import logging
+        >>> _get_logging_level(logging.ERROR) == logging.ERROR
+        True
+
+    Raises:
+        ValueError: If `verbosity` is less than zero.
+
+    Returns:
+        The log level from the `logging` module corresponding to the given `verbosity`.
+    """
+    if verbosity < 0:
+        raise ValueError(f"`verbosity` must be non-negative, was given '{verbosity}'.")
+    if verbosity in (
+        logging.DEBUG,
+        logging.INFO,
+        logging.WARNING,
+        logging.ERROR,
+        logging.CRITICAL,
+    ):
+        return verbosity
+    verbosity_to_logging_level = {
+        0: logging.ERROR,
+        1: logging.WARNING,
+        2: logging.INFO,
+    }
+    return verbosity_to_logging_level.get(verbosity, logging.DEBUG)
diff --git a/flepimop/gempyor_pkg/src/gempyor/shared_cli.py b/flepimop/gempyor_pkg/src/gempyor/shared_cli.py
index 3e5f0daea..4d613496e 100644
--- a/flepimop/gempyor_pkg/src/gempyor/shared_cli.py
+++ b/flepimop/gempyor_pkg/src/gempyor/shared_cli.py
@@ -3,18 +3,22 @@
 supported options for config file overrides, and custom click decorators.
 """
 
+__all__ = []
+
+
+from datetime import timedelta
+from math import ceil
 import multiprocessing
 import pathlib
-import warnings
-from typing import Callable, Any
 import re
+from typing import Any, Callable, Literal
+import warnings
 
 import click
 import confuse
 
-from .utils import config, as_list
-
-__all__ = []
+from .logging import get_script_logger
+from .utils import as_list, config
 
 
 @click.group()
@@ -123,6 +127,206 @@ def cli(ctx: click.Context) -> None:
     ),
 }
 
+verbosity_options = {
+    "verbosity": click.Option(
+        param_decls=["-v", "--verbose", "verbosity"],
+        count=True,
+        help="The verbosity level to use for this command.",
+    ),
+    "dry_run": click.Option(
+        param_decls=["--dry-run", "dry_run"],
+        type=bool,
+        default=False,
+        is_flag=True,
+        help="Should this command be run using dry run?",
+    ),
+}
+
+
+class DurationParamType(click.ParamType):
+    """
+    A custom Click parameter type for parsing duration strings into `timedelta` objects.
+
+    Attributes:
+        name: The name of the parameter type.
+
+    Examples:
+        >>> from gempyor.shared_cli import DurationParamType
+        >>> duration_param_type = DurationParamType(False)
+        >>> duration_param_type.convert("23min", None, None)
+        datetime.timedelta(seconds=1380)
+        >>> duration_param_type.convert("2.5hr", None, None)
+        datetime.timedelta(seconds=9000)
+        >>> duration_param_type.convert("-2", None, None)
+        datetime.timedelta(days=-1, seconds=86280)
+    """
+
+    name = "duration"
+    _abbreviations = {
+        "s": "seconds",
+        "sec": "seconds",
+        "secs": "seconds",
+        "second": "seconds",
+        "seconds": "seconds",
+        "m": "minutes",
+        "min": "minutes",
+        "mins": "minutes",
+        "minute": "minutes",
+        "minutes": "minutes",
+        "h": "hours",
+        "hr": "hours",
+        "hrs": "hours",
+        "hour": "hours",
+        "hours": "hours",
+        "d": "days",
+        "day": "days",
+        "days": "days",
+        "w": "weeks",
+        "week": "weeks",
+        "weeks": "weeks",
+    }
+
+    def __init__(
+        self,
+        nonnegative: bool,
+        default_unit: Literal["seconds", "minutes", "hours", "days", "weeks"] = "minutes",
+    ) -> None:
+        """
+        Initialize the instance based on parameter settings.
+
+        Args:
+            nonnegative: If `True` negative durations are not allowed.
+            default_unit: The default unit to use if no unit is specified in the input
+                string.
+        """
+        super().__init__()
+        self._nonnegative = nonnegative
+        self._duration_regex = re.compile(
+            rf"^((-)?([0-9]+)?(\.[0-9]+)?)({'|'.join(self._abbreviations.keys())})?$",
+            flags=re.IGNORECASE,
+        )
+        self._default_unit = default_unit
+
+    def convert(
+        self, value: Any, param: click.Parameter | None, ctx: click.Context | None
+    ) -> timedelta:
+        """
+        Converts a string representation of a duration into a `timedelta` object.
+
+        Args:
+            value: The value to convert, expected to be a string like representation of
+                a duration.
+            param: The Click parameter object for context in errors.
+            ctx: The Click context object for context in errors.
+
+        Returns:
+            The converted duration as a `timedelta` object.
+
+        Raises:
+            click.BadParameter: If the value is not a valid duration based on the
+                format.
+            click.BadParameter: If the duration is negative and the class was
+                initialized with `nonnegative` set to `True`.
+        """
+        value = str(value).strip()
+        if (m := self._duration_regex.match(value)) is None:
+            self.fail(f"{value!r} is not a valid duration", param, ctx)
+        number, posneg, _, _, unit = m.groups()
+        if self._nonnegative and posneg == "-":
+            self.fail(f"{value!r} is a negative duration", param, ctx)
+        kwargs = {}
+        kwargs[self._abbreviations.get(unit, self._default_unit)] = float(number)
+        return timedelta(**kwargs)
+
+
+class MemoryParamType(click.ParamType):
+    """
+    A custom Click parameter type for parsing duration strings into `timedelta` objects.
+
+    Attributes:
+        name: The name of the parameter type.
+
+    Examples:
+        >>> from gempyor.shared_cli import DurationParamType
+        >>> duration_param_type = DurationParamType(False)
+        >>> duration_param_type.convert("23min", None, None)
+        datetime.timedelta(seconds=1380)
+        >>> duration_param_type.convert("2.5hr", None, None)
+        datetime.timedelta(seconds=9000)
+        >>> duration_param_type.convert("-2", None, None)
+        datetime.timedelta(days=-1, seconds=86280)
+    """
+
+    name = "memory"
+    _units = {
+        "kb": 1024.0**1.0,
+        "k": 1024.0**1.0,
+        "mb": 1024.0**2.0,
+        "m": 1024.0**2.0,
+        "gb": 1024.0**3.0,
+        "g": 1024.0**3.0,
+        "t": 1024.0**4.0,
+        "tb": 1024.0**4.0,
+    }
+
+    def __init__(self, unit: str, as_int: bool = False) -> None:
+        """
+        Initialize the instance based on parameter settings.
+
+        Args:
+            unit: The output unit to use in the `convert` method.
+            as_int: if `True` the `convert` method returns an integer instead of a
+                float.
+
+        Raises:
+            ValueError: If `unit` is not a valid memory unit size.
+        """
+        super().__init__()
+        if (unit := unit.lower()) not in self._units.keys():
+            raise ValueError(
+                f"The `unit` given is not valid, given '{unit}' and "
+                f"must be one of: {', '.join(self._units.keys())}."
+            )
+        self._unit = unit
+        self._regex = re.compile(
+            rf"^(([0-9]+)?(\.[0-9]+)?)({'|'.join(self._units.keys())})?$",
+            flags=re.IGNORECASE,
+        )
+        self._as_int = as_int
+
+    def convert(
+        self, value: Any, param: click.Parameter | None, ctx: click.Context | None
+    ) -> float | int:
+        """
+        Converts a string representation of a memory size into a numeric.
+
+        Args:
+            value: The value to convert, expected to be a string like representation of
+                memory size.
+            param: The Click parameter object for context in errors.
+            ctx: The Click context object for context in errors.
+
+        Returns:
+            The converted memory size as a numeric. Specifically an integer if the
+            `as_int` attribute is `True` and float otherwise.
+
+        Raises:
+            click.BadParameter: If the value is not a valid memory size based on the
+                format.
+        """
+        value = str(value).strip()
+        if (m := self._regex.match(value)) is None:
+            self.fail(f"{value!r} is not a valid memory size.", param, ctx)
+        number, _, _, unit = m.groups()
+        unit = self._unit if unit is None else unit.lower()
+        if unit == self._unit:
+            result = float(number)
+        else:
+            result = (self._units.get(unit, self._unit) * float(number)) / (
+                self._units.get(self._unit)
+            )
+        return ceil(result) if self._as_int else result
+
 
 def click_helpstring(
     params: click.Parameter | list[click.Parameter],
@@ -265,3 +469,51 @@ def _parse_option(param: click.Parameter, value: Any) -> Any:
             cfg[option] = _parse_option(config_file_options[option], value)
 
     return cfg
+
+
+def log_cli_inputs(kwargs: dict[str, Any], verbosity: int | None = None) -> None:
+    """
+    Log CLI inputs for user debugging.
+
+    This function only logs debug messages so the verbosity has to be set quite high
+    to see the output of this function.
+
+    Args:
+        kwargs: The CLI arguments given as a dictionary of key word arguments.
+        verbosity: The verbosity level of the CLI tool being used or `None` to infer
+            from the given `kwargs`.
+
+    Examples:
+        >>> from gempyor.shared_cli import log_cli_inputs
+        >>> log_cli_inputs({"abc": 123, "def": True}, 3)
+        2024-11-05 09:27:58,884:DEBUG:gempyor.shared_cli> CLI was given 2 arguments:
+        2024-11-05 09:27:58,885:DEBUG:gempyor.shared_cli> abc = 123.
+        2024-11-05 09:27:58,885:DEBUG:gempyor.shared_cli> def = True.
+        >>> log_cli_inputs({"abc": 123, "def": True}, 2)
+        >>> from pathlib import Path
+        >>> kwargs = {
+        ...     "input_file": Path("config.in"),
+        ...     "stochastic": True,
+        ...     "cluster": "longleaf",
+        ...     "verbosity": 3,
+        ... }
+        >>> log_cli_inputs(kwargs)
+        2024-11-05 09:29:21,666:DEBUG:gempyor.shared_cli> CLI was given 4 arguments:
+        2024-11-05 09:29:21,667:DEBUG:gempyor.shared_cli> input_file = /Users/twillard/Desktop/GitHub/HopkinsIDD/flepiMoP/flepimop/gempyor_pkg/config.in.
+        2024-11-05 09:29:21,667:DEBUG:gempyor.shared_cli> stochastic = True.
+        2024-11-05 09:29:21,668:DEBUG:gempyor.shared_cli> cluster    = longleaf.
+        2024-11-05 09:29:21,668:DEBUG:gempyor.shared_cli> verbosity  = 3.
+    """
+    verbosity = kwargs.get("verbosity") if verbosity is None else verbosity
+    if verbosity is None:
+        return
+    logger = get_script_logger(__name__, verbosity)
+    longest_key = -1
+    total_keys = 0
+    for k, _ in kwargs.items():
+        longest_key = len(k) if len(k) > longest_key else longest_key
+        total_keys += 1
+    logger.debug("CLI was given %u arguments:", total_keys)
+    for k, v in kwargs.items():
+        v = v.absolute() if isinstance(v, pathlib.Path) else v
+        logger.debug("%s = %s", k.ljust(longest_key, " "), v)
diff --git a/flepimop/gempyor_pkg/src/gempyor/templates/__init__.py b/flepimop/gempyor_pkg/src/gempyor/templates/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/flepimop/gempyor_pkg/src/gempyor/templates/cluster_setup.bash.j2 b/flepimop/gempyor_pkg/src/gempyor/templates/cluster_setup.bash.j2
new file mode 100644
index 000000000..8d53fff5b
--- /dev/null
+++ b/flepimop/gempyor_pkg/src/gempyor/templates/cluster_setup.bash.j2
@@ -0,0 +1,25 @@
+# Purge/load modules
+module purge
+{%- for module in cluster.modules %}
+{%- if module.version is defined and module.version is not none %}
+module load {{ module.name }}/{{ module.version }}
+{%- else %}
+module load {{ module.name }}
+{%- endif %}
+{%- endfor %}
+{%- if cluster.path_exports|length %}
+
+# Path modifications
+{%- for path_export in cluster.path_exports %}
+if [ -r "{{ path_export.path }}" ]; then
+    {% if path_export.prepend -%}
+    export PATH={{ path_export.path }}:$PATH
+    {%- else -%}
+    export PATH=$PATH:{{ path_export.path }}
+    {%- endif %}
+elif [ "{{ path_export.error_if_missing }}" = "True" ]; then
+    echo "The path '{{ path_export.path }}' does not exist but is required."
+    exit 1
+fi
+{%- endfor %}
+{%- endif %}
\ No newline at end of file
diff --git a/flepimop/gempyor_pkg/src/gempyor/templates/conda_activate.bash.j2 b/flepimop/gempyor_pkg/src/gempyor/templates/conda_activate.bash.j2
new file mode 100644
index 000000000..7338f6b01
--- /dev/null
+++ b/flepimop/gempyor_pkg/src/gempyor/templates/conda_activate.bash.j2
@@ -0,0 +1,5 @@
+# Load conda env
+eval "$( conda shell.bash hook )"
+conda activate {{ conda_env }}
+WHICH_PYTHON=$( which python )
+WHICH_RSCRIPT=$( which Rscript )
\ No newline at end of file
diff --git a/flepimop/gempyor_pkg/src/gempyor/templates/inference_command.bash.j2 b/flepimop/gempyor_pkg/src/gempyor/templates/inference_command.bash.j2
new file mode 100644
index 000000000..8763df704
--- /dev/null
+++ b/flepimop/gempyor_pkg/src/gempyor/templates/inference_command.bash.j2
@@ -0,0 +1,28 @@
+# Run inference
+{%- if inference_method == 'emcee' %}
+flepimop-calibrate --config $CONFIG_PATH \
+    --project_path $PROJECT_PATH \
+    --nslots {{ nslots }} \
+    --niterations {{ simulations }} \
+    --nsamples {{ nsamples }} \
+    --jobs {{ jobs }} \
+    --id {{ run_id }} \
+    --prefix {{ prefix}} \
+    > $LOG_FILE 2>&1
+{%- else %}
+flepimop-inference-slot --config $CONFIG_PATH \
+    --run_id {{ run_id }} \
+    --seir_modifiers_scenarios $FLEPI_SEIR_SCENARIOS \
+    --outcome_modifiers_scenarios $FLEPI_OUTCOME_SCENARIOS \
+    --jobs 1 \
+    --iterations_per_slot {{ simulations }} \
+    --this_slot $FLEPI_SLOT_INDEX \
+    --this_block 1 \
+    --stoch_traj_flag $FLEPI_STOCHASTIC_RUN \
+    --flepi_path $FLEPI_PATH \
+    --python $WHICH_PYTHON \
+    --rpath $WHICH_RSCRIPT \
+    --is-interactive FALSE \
+    --reset_chimeric_on_accept $FLEPI_RESET_CHIMERICS \
+    > $LOG_FILE 2>&1
+{%- endif %}
\ No newline at end of file
diff --git a/flepimop/gempyor_pkg/src/gempyor/templates/inference_environment_variables.bash.j2 b/flepimop/gempyor_pkg/src/gempyor/templates/inference_environment_variables.bash.j2
new file mode 100644
index 000000000..611efee41
--- /dev/null
+++ b/flepimop/gempyor_pkg/src/gempyor/templates/inference_environment_variables.bash.j2
@@ -0,0 +1,14 @@
+# Set environment variables
+if [ -z "$SLURM_ARRAY_TASK_ID" ]; then
+    FLEPI_SLOT_INDEX="1"
+else
+    FLEPI_SLOT_INDEX=$SLURM_ARRAY_TASK_ID
+fi
+export FLEPI_PATH="{{ flepi_path }}"
+export PROJECT_PATH="{{ project_path }}"
+export CONFIG_PATH="{{ config_path }}"
+export FLEPI_STOCHASTIC_RUN="{{ stoch_traj_flag | string | upper }}"
+export FLEPI_OUTCOME_SCENARIOS="{{ outcome_modifiers_scenario }}"
+export FLEPI_SEIR_SCENARIOS="{{ seir_modifiers_scenario }}"
+export FLEPI_RESET_CHIMERICS="{{ reset_chimerics | string | upper }}"
+export LOG_FILE="out_{{ job_name }}_$FLEPI_SLOT_INDEX.out"
\ No newline at end of file
diff --git a/flepimop/gempyor_pkg/src/gempyor/templates/inference_local.bash.j2 b/flepimop/gempyor_pkg/src/gempyor/templates/inference_local.bash.j2
new file mode 100644
index 000000000..66e6ce6dc
--- /dev/null
+++ b/flepimop/gempyor_pkg/src/gempyor/templates/inference_local.bash.j2
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+{% include "inference_environment_variables.bash.j2" with context %}
+
+{%- if cluster is defined and cluster is not none %}
+{% include "cluster_setup.bash.j2" with context %}
+{%- endif %}
+
+cd $PROJECT_PATH
+
+{% include "conda_activate.bash.j2" with context %}
+
+{% include "inference_command.bash.j2" with context %}
diff --git a/flepimop/gempyor_pkg/src/gempyor/templates/inference_slurm.sbatch.j2 b/flepimop/gempyor_pkg/src/gempyor/templates/inference_slurm.sbatch.j2
new file mode 100644
index 000000000..1398a2f8b
--- /dev/null
+++ b/flepimop/gempyor_pkg/src/gempyor/templates/inference_slurm.sbatch.j2
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+{%- for opt in options %}
+#SBATCH {{ opt }}
+{%- endfor %}
+
+{% if debug -%}
+# Debugging
+set -x
+{%- endif %}
+
+{% include "inference_environment_variables.bash.j2" with context %}
+
+{% include "cluster_setup.bash.j2" with context %}
+
+{% include "conda_activate.bash.j2" with context %}
+
+{% include "inference_command.bash.j2" with context %}
diff --git a/flepimop/gempyor_pkg/src/gempyor/templates/test_template.j2 b/flepimop/gempyor_pkg/src/gempyor/templates/test_template.j2
new file mode 100644
index 000000000..c7a43bc1f
--- /dev/null
+++ b/flepimop/gempyor_pkg/src/gempyor/templates/test_template.j2
@@ -0,0 +1 @@
+Hello {{ name }}!
\ No newline at end of file
diff --git a/flepimop/gempyor_pkg/src/gempyor/utils.py b/flepimop/gempyor_pkg/src/gempyor/utils.py
index 377dcdee5..5b9b75fa1 100644
--- a/flepimop/gempyor_pkg/src/gempyor/utils.py
+++ b/flepimop/gempyor_pkg/src/gempyor/utils.py
@@ -1,9 +1,11 @@
+from collections.abc import Iterable
 import datetime
 import functools
 import logging
 import numbers
 import os
 from pathlib import Path
+from shlex import quote
 import shutil
 import subprocess
 import time
@@ -1040,3 +1042,129 @@ def move_file_at_local(name_map: dict[str, str]) -> None:
     for src, dst in name_map.items():
         os.path.makedirs(os.path.dirname(dst), exist_ok=True)
         shutil.copy(src, dst)
+
+
+def _shutil_which(
+    cmd: str,
+    mode: int = os.F_OK | os.X_OK,
+    path: str | bytes | os.PathLike | None = None,
+    check: bool = True,
+) -> str | None:
+    """
+    A thin wrapper around `shutil.which` with extra validation.
+
+    Args:
+        cmd: The name of the command to search for.
+        mode: The permission mask required of possible files.
+        path: A path describing the locations to search, or `None` to use
+            the PATH environment variable.
+        check: If `True` an `OSError` will be raised if a `cmd` is not found.
+            Similar in spirit to the `check` arg of `subprocess.run`.
+
+    Returns:
+        Either the full path to the `cmd` found, or `None` if `cmd` is not
+        found and `check` is `False`.
+
+    Raises:
+        OSError: If `cmd` is not found and `check` is `True`.
+
+    Examples:
+        >>> import os
+        >>> from shutil import which
+        >>> _shutil_which("python") == which("python")
+        True
+        >>> _shutil_which("does_not_exist", check=False)
+        >>> try:
+        ...     _shutil_which("does_not_exist", check=True)
+        ... except Exception as e:
+        ...     print(type(e))
+        ...     print(str(e).replace(os.environ.get("PATH"), "..."))
+        ...
+        <class 'OSError'>
+        Did not find 'does_not_exist' on path '...'.
+
+    See Also:
+        [`shutil.which`](https://docs.python.org/3/library/shutil.html#shutil.which)
+    """
+    result = shutil.which(cmd, mode=mode, path=path)
+    if check and result is None:
+        path = os.environ.get("PATH") if path is None else path
+        raise OSError(f"Did not find '{cmd}' on path '{path}'.")
+    return result
+
+
+def _git_head(repository: Path) -> str:
+    """
+    Get the sha commit has for the head of a git repository.
+
+    Args:
+        repository: A directory under version control with git to get the sha commit of.
+
+    Returns:
+        The sha commit of head for `repository`.
+
+    Examples:
+        >>> from pathlib import Path
+        >>> _git_head(Path("~/Desktop/GitHub/HopkinsIDD/flepiMoP"))
+        'efe896b1a5e4f8e33667c170cd5319d6ef1e3db5'
+    """
+    git_cmd = _shutil_which("git")
+    proc = subprocess.run(
+        [git_cmd, "rev-parse", "HEAD"],
+        cwd=repository.expanduser().absolute(),
+        capture_output=True,
+        check=True,
+    )
+    return proc.stdout.decode().strip()
+
+
+def _git_checkout(repository: Path, branch: str) -> None:
+    """
+    Checkout a new branch from a given git repository.
+
+    Args:
+        repository: A directory under version control with git to
+            checkout a new branch in.
+        branch: The name of the new branch to checkout.
+
+    Examples:
+        >>> from pathlib import Path
+        >>> _git_checkout(Path("~/Desktop/GitHub/HopkinsIDD/flepiMoP"), "my-new-branch")
+    """
+    git_cmd = _shutil_which("git")
+    subprocess.run(
+        [git_cmd, "checkout", "-b", branch],
+        cwd=repository.expanduser().absolute(),
+        check=True,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+
+def _format_cli_options(options: dict[str, Any]) -> list[str]:
+    """
+    Convert a dictionary of CLI options into a formatted list.
+
+    Args:
+        options: A dictionary where the keys correspond to the option name and the
+            values correspond to the option value. If the option name is one character
+            it's assumed to be a short name and prefixed with one dash. Values are
+            coerced to a string and then escaped for shell.
+
+    Returns:
+        A list of options that can be passed to
+        [`subprocess.run`](https://docs.python.org/3/library/subprocess.html#subprocess.run)
+        or similar functions.
+
+    Examples:
+        >>> from pathlib import Path
+        >>> _format_cli_options({"name": "foo bar fizz buzz"})
+        ["--name='foo bar fizz buzz'"]
+        >>> _format_cli_options({"o": Path("/path/to/output.log")})
+        ['-o=/path/to/output.log']
+        >>> _format_cli_options({"opt1": "```", "opt2": "$( echo 'Hello!')"})
+        ["--opt1='```'", '--opt2=\'$( echo \'"\'"\'Hello!\'"\'"\')\'']
+    """
+    return [
+        f"{'-' if len(k) == 1 else '--'}{k}={quote(str(v))}" for k, v in options.items()
+    ]
diff --git a/flepimop/gempyor_pkg/tests/_jinja/test__get_template.py b/flepimop/gempyor_pkg/tests/_jinja/test__get_template.py
new file mode 100644
index 000000000..a8eeeaaca
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/_jinja/test__get_template.py
@@ -0,0 +1,32 @@
+from typing import Any
+
+from jinja2 import Template
+from jinja2.exceptions import TemplateNotFound
+import pytest
+
+from gempyor._jinja import _get_template
+
+
+@pytest.mark.parametrize(
+    "name", (("template_does_not_exist.j2"), ("template_does_not_exist_again.j2"))
+)
+def test__get_template_template_not_found_error(name: str) -> None:
+    with pytest.raises(TemplateNotFound, match=name):
+        _get_template(name)
+
+
+@pytest.mark.parametrize(
+    ("name", "data", "output"),
+    (
+        ("test_template.j2", {"name": "John"}, "Hello John!"),
+        ("test_template.j2", {"name": "Jake"}, "Hello Jake!"),
+        ("test_template.j2", {"name": "Jane"}, "Hello Jane!"),
+    ),
+)
+def test__get_template_renders_correctly(
+    name: str, data: dict[str, Any], output: str
+) -> None:
+    template = _get_template(name)
+    assert isinstance(template, Template)
+    rendered_template = template.render(**data)
+    assert rendered_template == output
diff --git a/flepimop/gempyor_pkg/tests/_jinja/test__render_template.py b/flepimop/gempyor_pkg/tests/_jinja/test__render_template.py
new file mode 100644
index 000000000..3d76490b4
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/_jinja/test__render_template.py
@@ -0,0 +1,19 @@
+from typing import Any
+
+import pytest
+
+from gempyor._jinja import _render_template
+
+
+@pytest.mark.parametrize(
+    ("name", "data", "output"),
+    (
+        ("test_template.j2", {"name": "John"}, "Hello John!"),
+        ("test_template.j2", {"name": "Jake"}, "Hello Jake!"),
+        ("test_template.j2", {"name": "Jane"}, "Hello Jane!"),
+    ),
+)
+def test__render_template_renders_correctly(
+    name: str, data: dict[str, Any], output: str
+) -> None:
+    assert _render_template(name, data) == output
diff --git a/flepimop/gempyor_pkg/tests/_jinja/test__render_template_to_file.py b/flepimop/gempyor_pkg/tests/_jinja/test__render_template_to_file.py
new file mode 100644
index 000000000..330bd77b1
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/_jinja/test__render_template_to_file.py
@@ -0,0 +1,24 @@
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from gempyor._jinja import _render_template_to_file
+
+
+@pytest.mark.parametrize(
+    ("name", "data", "file", "output"),
+    (
+        ("test_template.j2", {"name": "John"}, Path("foo.txt"), "Hello John!"),
+        ("test_template.j2", {"name": "Jake"}, Path("bar.txt"), "Hello Jake!"),
+        ("test_template.j2", {"name": "Jane"}, Path("fizz.md"), "Hello Jane!"),
+    ),
+)
+def test__render_template_to_file_renders_correctly(
+    tmp_path: Path, name: str, data: dict[str, Any], file: Path, output: str
+) -> None:
+    if file.is_absolute():
+        raise ValueError("The `file` argument must be relative for unit testing.")
+    file = tmp_path / file
+    _render_template_to_file(name, data, file)
+    assert file.read_text() == output
diff --git a/flepimop/gempyor_pkg/tests/_jinja/test__render_template_to_temp_file.py b/flepimop/gempyor_pkg/tests/_jinja/test__render_template_to_temp_file.py
new file mode 100644
index 000000000..280214be4
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/_jinja/test__render_template_to_temp_file.py
@@ -0,0 +1,26 @@
+from typing import Any
+
+import pytest
+
+from gempyor._jinja import _render_template_to_temp_file
+
+
+@pytest.mark.parametrize(
+    ("name", "data", "suffix", "prefix", "output"),
+    (
+        ("test_template.j2", {"name": "John"}, None, None, "Hello John!"),
+        ("test_template.j2", {"name": "Jake"}, ".txt", None, "Hello Jake!"),
+        ("test_template.j2", {"name": "Jane"}, None, "abc_", "Hello Jane!"),
+        ("test_template.j2", {"name": "Job"}, ".dat", "def_", "Hello Job!"),
+    ),
+)
+def test__render_template_to_temp_file_renders_correctly(
+    name: str, data: dict[str, Any], suffix: str | None, prefix: str | None, output: str
+) -> None:
+    temp_file = _render_template_to_temp_file(name, data, suffix=suffix, prefix=prefix)
+    assert temp_file.exists()
+    if suffix:
+        assert temp_file.name.endswith(suffix)
+    if prefix:
+        assert temp_file.name.startswith(prefix)
+    assert temp_file.read_text(encoding="utf-8") == output
diff --git a/flepimop/gempyor_pkg/tests/batch/test__click_submit.py b/flepimop/gempyor_pkg/tests/batch/test__click_submit.py
new file mode 100644
index 000000000..993c0a8c1
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/batch/test__click_submit.py
@@ -0,0 +1,41 @@
+import os
+from pathlib import Path
+from typing import Any
+
+from click.testing import CliRunner
+import pytest
+import yaml
+
+from gempyor.batch import _click_submit
+
+
+def test_batch_system_aws_not_implemented_error(tmp_path: Path) -> None:
+    config_file = tmp_path / "config.yml"
+    with config_file.open(mode="w") as f:
+        yaml.dump({"name": "foobar", "inference": {"method": "emcee"}}, f)
+
+    runner = CliRunner()
+    result = runner.invoke(
+        _click_submit,
+        [
+            "--aws",
+            "--simulations",
+            "1",
+            "--jobs",
+            "1",
+            "--blocks",
+            "1",
+            "--flepi-path",
+            str(tmp_path.absolute()),
+            "--project-path",
+            str(tmp_path.absolute()),
+            str(config_file.absolute()),
+        ],
+    )
+
+    assert result.exit_code == 1
+    assert isinstance(result.exception, NotImplementedError)
+    assert (
+        str(result.exception)
+        == "The `flepimop submit` CLI does not support batch submission to AWS yet."
+    )
diff --git a/flepimop/gempyor_pkg/tests/batch/test__job_name.py b/flepimop/gempyor_pkg/tests/batch/test__job_name.py
new file mode 100644
index 000000000..bd08a9452
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/batch/test__job_name.py
@@ -0,0 +1,37 @@
+from datetime import datetime, timedelta, timezone
+import re
+
+import pytest
+
+from gempyor.batch import _job_name
+
+
+VALID_JOB_NAME = re.compile(
+    r"^([a-z]{1}([a-z0-9\_\-]+)?\-)?[0-9]{8}T[0-9]{6}$", flags=re.IGNORECASE
+)
+
+
+@pytest.mark.parametrize("name", ("123", "_abc", "", "abc!@#"))
+def test_invalid_name_value_error(name: str) -> None:
+    with pytest.raises(
+        ValueError, match=f"^The given `name`, '{name}', is not a valid safe name.$"
+    ):
+        _job_name(name, None)
+
+
+@pytest.mark.parametrize("name", (None, "abc", "flu_usa", "covid-19"))
+@pytest.mark.parametrize(
+    "timestamp",
+    (
+        None,
+        datetime(2024, 1, 1, tzinfo=timezone.utc),
+        datetime(2025, 1, 2, 3, 4, 5, tzinfo=timezone(timedelta(hours=3))),
+    ),
+)
+def test_output_validation(name: str | None, timestamp: datetime | None) -> None:
+    job_name = _job_name(name, timestamp)
+    if name is not None:
+        assert job_name.startswith(name)
+    if timestamp is not None:
+        assert job_name.endswith(timestamp.strftime("%Y%m%dT%H%M%S"))
+    assert VALID_JOB_NAME.match(job_name)
diff --git a/flepimop/gempyor_pkg/tests/batch/test__local.py b/flepimop/gempyor_pkg/tests/batch/test__local.py
new file mode 100644
index 000000000..4e034af51
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/batch/test__local.py
@@ -0,0 +1,76 @@
+import logging
+from pathlib import Path
+from unittest.mock import patch
+from stat import S_IXUSR
+import subprocess
+
+import pytest
+
+from gempyor.batch import _local
+
+
+def sample_script(directory: Path, executable: bool) -> Path:
+    script = directory / "example"
+    script.write_text("#!/usr/bin/env bash\necho 'Hello local!'")
+    if executable:
+        script.chmod(script.stat().st_mode | S_IXUSR)
+    return script
+
+
+def test_script_does_not_exist_or_is_not_file_value_error(tmp_path: Path) -> None:
+    script = tmp_path / "does_not_exist"
+    with pytest.raises(
+        ValueError,
+        match=f"^The script '{script.absolute()}' either does not exist or is not a file.$",
+    ):
+        _local(script, None, True)
+
+    directory = tmp_path / "not_a_file"
+    directory.mkdir(parents=True, exist_ok=True)
+    with pytest.raises(
+        ValueError,
+        match=(
+            f"^The script '{directory.absolute()}' either does not exist or is not a file.$"
+        ),
+    ):
+        _local(directory, None, True)
+
+
+@pytest.mark.parametrize("executable", (True, False))
+@pytest.mark.parametrize("verbosity", (None, logging.DEBUG, logging.INFO, logging.WARNING))
+@pytest.mark.parametrize("dry_run", (True, False))
+def test_output_validation(
+    caplog: pytest.LogCaptureFixture,
+    tmp_path: Path,
+    executable: bool,
+    verbosity: int,
+    dry_run: bool,
+) -> None:
+    script = sample_script(tmp_path, executable)
+
+    def subprocess_run_wraps(args, **kwargs):
+        if args[0] == str(script.absolute()):
+            return subprocess.CompletedProcess(
+                args=args, returncode=0, stdout=b"Hello local\n", stderr=b""
+            )
+        return subprocess.run(args, **kwargs)
+
+    with patch(
+        "gempyor.batch.subprocess.run", wraps=subprocess_run_wraps
+    ) as subprocess_run_patch:
+        assert _local(script, verbosity, dry_run) is None
+
+        if dry_run:
+            subprocess_run_patch.assert_not_called()
+        else:
+            subprocess_run_patch.assert_called_once()
+
+        log_messages_by_level = {
+            hash((logging.DEBUG, True)): 2,
+            hash((logging.DEBUG, False)): 3,
+            hash((logging.INFO, True)): 1,
+            hash((logging.INFO, False)): 1,
+        }
+        assert len(caplog.records) == log_messages_by_level.get(
+            hash((verbosity, dry_run)), 0
+        ) + (1 if not executable and verbosity is not None else 0)
diff --git a/flepimop/gempyor_pkg/tests/batch/test__sbatch.py b/flepimop/gempyor_pkg/tests/batch/test__sbatch.py
new file mode 100644
index 000000000..1c69d73d2
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/batch/test__sbatch.py
@@ -0,0 +1,136 @@
+import logging
+import os
+from pathlib import Path
+from unittest.mock import patch
+import subprocess
+from typing import Any, Literal
+
+import pytest
+
+from gempyor.batch import _sbatch
+from gempyor.logging import _get_logging_level
+from gempyor.utils import _shutil_which
+
+
+@pytest.fixture
+def sample_sbatch_script(tmp_path: Path) -> Path:
+    script = tmp_path / "example.sbatch"
+    script.write_text("#!/usr/bin/env bash\necho 'Hello sbatch!'")
+    return script
+
+
+def test_export_option_causes_value_error(sample_sbatch_script: Path) -> None:
+    with pytest.raises(
+        ValueError,
+        match="^Found 'export' in `options`, please use `environment_variables` instead.$",
+    ):
+        _sbatch(sample_sbatch_script, {}, {"export": "VAR1=1,VAR2=abc"}, None, True)
+
+
+@pytest.mark.parametrize(
+    ("environment_variables", "expected_export"),
+    (
+        ({}, None),
+        ({"ENV_VAR": "true"}, "ENV_VAR=true"),
+        ({"VAR1": 1, "VAR2": "abc", "VAR3": True}, "VAR1=1,VAR2=abc,VAR3=True"),
+        (
+            {"NEEDS_ESCAPING": "`", "ALSO_ESCAPED": "a b c"},
+            "NEEDS_ESCAPING='`',ALSO_ESCAPED='a b c'",
+        ),
+        ("all", "ALL"),
+        ("nil", "NIL"),
+        ("none", "NONE"),
+    ),
+)
+@pytest.mark.parametrize(
+    ("options", "expected_options"),
+    (
+        ({}, None),
+        ({"time": "1:00:00", "mem": "2GB"}, "--time=1:00:00 --mem=2GB"),
+        (
+            {"output": Path("/abc/def/ghi.log"), "ntasks": 2},
+            "--output=/abc/def/ghi.log --ntasks=2",
+        ),
+        (
+            {"J": "My Job Name", "e": "/path/to/error.log"},
+            "-J='My Job Name' -e=/path/to/error.log",
+        ),
+    ),
+)
+@pytest.mark.parametrize("verbosity", (None, logging.DEBUG, logging.INFO, logging.WARNING))
+@pytest.mark.parametrize("dry_run", (True, False))
+def test_output_validation(
+    caplog: pytest.LogCaptureFixture,
+    sample_sbatch_script: Path,
+    environment_variables: dict[str, Any] | Literal["all", "nil", "none"],
+    expected_export: str | None,
+    options: dict[str, Any],
+    expected_options: str | None,
+    verbosity: int | None,
+    dry_run: bool,
+) -> None:
+    def shutil_which_wraps(
+        cmd: str,
+        mode: int = os.F_OK | os.X_OK,
+        path: str | bytes | os.PathLike | None = None,
+        check: bool = True,
+    ) -> str | None:
+        return (
+            "sbatch"
+            if cmd == "sbatch"
+            else _shutil_which(cmd, mode=mode, path=path, check=check)
+        )
+
+    def subprocess_run_wraps(args, **kwargs):
+        if os.path.basename(args[0]) == "sbatch":
+            return subprocess.CompletedProcess(
+                args=args, returncode=0, stdout=b"Submitted batch job 999\n", stderr=b""
+            )
+        return subprocess.run(args, **kwargs)
+
+    with patch(
+        "gempyor.batch._shutil_which", wraps=shutil_which_wraps
+    ) as shutil_which_patch:
+        with patch(
+            "gempyor.batch.subprocess.run", wraps=subprocess_run_wraps
+        ) as subprocess_run_patch:
+            assert (
+                _sbatch(
+                    sample_sbatch_script,
+                    environment_variables,
+                    options,
+                    verbosity,
+                    dry_run,
+                )
+                is None
+            )
+            shutil_which_patch.assert_called_once_with("sbatch")
+
+            if dry_run:
+                subprocess_run_patch.assert_not_called()
+            else:
+                subprocess_run_patch.assert_called_once()
+
+            if verbosity is None:
+                assert len(caplog.records) == 0
+            else:
+                log_messages_by_level = {
+                    hash((logging.DEBUG, True)): 2,
+                    hash((logging.DEBUG, False)): 3,
+                    hash((logging.INFO, True)): 1,
+                    hash((logging.INFO, False)): 1,
+                }
+                assert len(caplog.records) == log_messages_by_level.get(
+                    hash((_get_logging_level(verbosity), dry_run)), 0
+                )
+
+            if not dry_run:
+                args: list[str] = subprocess_run_patch.call_args.args[0]
+                assert len(args) == 2 + len(options) + min(len(environment_variables), 1)
+                assert Path(args[-1]) == sample_sbatch_script
+                if environment_variables:
+                    assert args[1].startswith("--export=")
+                    assert args[1][9:] == expected_export
+                if options:
+                    start_index = 2 if environment_variables else 1
+                    assert " ".join(args[start_index:-1]) == expected_options
diff --git a/flepimop/gempyor_pkg/tests/batch/test_batch_system_class.py b/flepimop/gempyor_pkg/tests/batch/test_batch_system_class.py
new file mode 100644
index 000000000..fe60b5a52
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/batch/test_batch_system_class.py
@@ -0,0 +1,69 @@
+from typing import Literal
+
+import pytest
+
+from gempyor.batch import BatchSystem
+
+
+@pytest.mark.parametrize(
+    ("aws", "local", "slurm"),
+    ((True, True, False), (False, True, True), (True, False, True), (True, True, True)),
+)
+def test_multiple_flags_value_error(aws: bool, local: bool, slurm: bool) -> None:
+    with pytest.raises(
+        ValueError,
+        match=(
+            f"^There were {sum((aws, local, slurm))} boolean "
+            "flags given, expected either 0 or 1.$"
+        ),
+    ):
+        BatchSystem.from_options(None, aws, local, slurm)
+
+
+@pytest.mark.parametrize(
+    ("batch_system", "aws", "local", "slurm"),
+    (
+        ("aws", False, True, False),
+        ("aws", False, False, True),
+        ("slurm", True, False, False),
+        ("slurm", False, True, False),
+        ("local", True, False, False),
+        ("local", False, False, True),
+    ),
+)
+def test_batch_system_flag_mismatch_value_error(
+    batch_system: Literal["aws", "local", "slurm"], aws: bool, local: bool, slurm: bool
+) -> None:
+    name = next(n for n, f in zip(("aws", "local", "slurm"), (aws, local, slurm)) if f)
+    with pytest.raises(
+        ValueError,
+        match=(
+            "^Conflicting batch systems given. The batch system name "
+            f"is '{batch_system}' and the flags indicate '{name}'.$"
+        ),
+    ):
+        BatchSystem.from_options(batch_system, aws, local, slurm)
+
+
+@pytest.mark.parametrize(
+    ("batch_system", "aws", "local", "slurm", "expected"),
+    (
+        (None, True, False, False, BatchSystem.AWS),
+        ("aws", False, False, False, BatchSystem.AWS),
+        ("aws", True, False, False, BatchSystem.AWS),
+        (None, False, True, False, BatchSystem.LOCAL),
+        ("local", False, False, False, BatchSystem.LOCAL),
+        ("local", False, True, False, BatchSystem.LOCAL),
+        (None, False, False, True, BatchSystem.SLURM),
+        ("slurm", False, False, False, BatchSystem.SLURM),
+        ("slurm", False, False, True, BatchSystem.SLURM),
+    ),
+)
+def test_output_validation(
+    batch_system: Literal["aws", "local", "slurm"] | None,
+    aws: bool,
+    local: bool,
+    slurm: bool,
+    expected: Literal["aws", "local", "slurm"],
+) -> None:
+    assert BatchSystem.from_options(batch_system, aws, local, slurm) == expected
diff --git a/flepimop/gempyor_pkg/tests/batch/test_job_resources_class.py b/flepimop/gempyor_pkg/tests/batch/test_job_resources_class.py
new file mode 100644
index 000000000..c5abeb040
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/batch/test_job_resources_class.py
@@ -0,0 +1,99 @@
+from typing import Literal
+
+import pytest
+
+from gempyor.batch import BatchSystem, JobResources, JobSize
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    (
+        {"nodes": 0, "cpus": 1, "memory": 1},
+        {"nodes": 1, "cpus": 0, "memory": 1},
+        {"nodes": 1, "cpus": 1, "memory": 0},
+        {"nodes": 0, "cpus": 0, "memory": 1},
+        {"nodes": 1, "cpus": 0, "memory": 0},
+        {"nodes": 0, "cpus": 1, "memory": 0},
+        {"nodes": 0, "cpus": 0, "memory": 0},
+    ),
+)
+def test_less_than_one_value_error(
+    kwargs: dict[Literal["nodes", "cpus", "memory"], int]
+) -> None:
+    param = next(k for k, v in kwargs.items() if v < 1)
+    with pytest.raises(
+        ValueError,
+        match=(
+            f"^The '{param}' attribute must be greater than 0, "
+            f"but instead was given '{kwargs.get(param)}'.$"
+        ),
+    ):
+        JobResources(**kwargs)
+
+
+@pytest.mark.parametrize("nodes", (1, 2, 4, 8))
+@pytest.mark.parametrize("cpus", (1, 2, 4, 8))
+@pytest.mark.parametrize("memory", (1024, 2 * 1024, 4 * 1024, 8 * 1024))
+def test_instance_attributes(nodes: int, cpus: int, memory: int) -> None:
+    job_resources = JobResources(nodes=nodes, cpus=cpus, memory=memory)
+    assert job_resources.total_cpus >= cpus
+    assert job_resources.total_memory >= memory
+    assert job_resources.total_resources() == (nodes, nodes * cpus, nodes * memory)
+
+
+@pytest.mark.parametrize("nodes", (1, 2, 4, 8))
+@pytest.mark.parametrize("cpus", (1, 2, 4, 8))
+@pytest.mark.parametrize("memory", (1024, 2 * 1024, 4 * 1024, 8 * 1024))
+@pytest.mark.parametrize(
+    "batch_system", (BatchSystem.AWS, BatchSystem.LOCAL, BatchSystem.SLURM, None)
+)
+def test_formatting(
+    nodes: int, cpus: int, memory: int, batch_system: BatchSystem | None
+) -> None:
+    job_resources = JobResources(nodes=nodes, cpus=cpus, memory=memory)
+
+    formatted_nodes = job_resources.format_nodes(batch_system)
+    assert isinstance(formatted_nodes, str)
+    assert str(nodes) in formatted_nodes
+
+    formatted_cpus = job_resources.format_cpus(batch_system)
+    assert isinstance(formatted_cpus, str)
+    assert str(cpus) in formatted_cpus
+
+    formatted_memory = job_resources.format_memory(batch_system)
+    assert isinstance(formatted_memory, str)
+    assert str(memory) in formatted_memory
+
+
+@pytest.mark.parametrize("jobs", (1, 4, 16, 32))
+@pytest.mark.parametrize("simulations", (250, 4 * 250, 16 * 250, 32 * 250))
+@pytest.mark.parametrize("blocks", (1, 4, 16, 32))
+@pytest.mark.parametrize("inference_method", ("emcee", None))
+def test_from_presets_for_select_inputs(
+    jobs: int, simulations: int, blocks: int, inference_method: Literal["emcee"] | None
+) -> None:
+    job_size = JobSize(jobs=jobs, simulations=simulations, blocks=blocks)
+    job_resources = JobResources.from_presets(job_size, inference_method)
+    if inference_method == "emcee":
+        assert job_resources.nodes == 1
+        assert job_resources.cpus % 2 == 0
+        assert job_resources.memory % (2 * 1024) == 0
+    else:
+        assert job_resources.cpus == 2
+        assert job_resources.memory == 2 * 1024
+
+
+@pytest.mark.parametrize("inference_method", ("emcee", None))
+@pytest.mark.parametrize("nodes", (1, 2, 4, 8))
+@pytest.mark.parametrize("cpus", (1, 2, 4, 8))
+@pytest.mark.parametrize("memory", (1024, 2 * 1024, 4 * 1024, 8 * 1024))
+def test_from_presets_overrides(
+    inference_method: Literal["emcee"] | None, nodes: int, cpus: int, memory: int
+) -> None:
+    job_size = JobSize(jobs=1, simulations=1, blocks=1)
+    job_resources = JobResources.from_presets(
+        job_size, inference_method, nodes=nodes, cpus=cpus, memory=memory
+    )
+    assert job_resources.nodes == nodes
+    assert job_resources.cpus == cpus
+    assert job_resources.memory == memory
diff --git a/flepimop/gempyor_pkg/tests/batch/test_job_size_class.py b/flepimop/gempyor_pkg/tests/batch/test_job_size_class.py
new file mode 100644
index 000000000..738aaea85
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/batch/test_job_size_class.py
@@ -0,0 +1,75 @@
+from itertools import product
+from typing import Generator, Literal
+
+import pytest
+
+from gempyor.batch import BatchSystem, JobSize
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    (
+        {"jobs": 0, "simulations": 1, "blocks": 1},
+        {"jobs": 1, "simulations": 0, "blocks": 1},
+        {"jobs": 1, "simulations": 1, "blocks": 0},
+        {"jobs": 0, "simulations": 0, "blocks": 1},
+        {"jobs": 1, "simulations": 0, "blocks": 0},
+        {"jobs": 0, "simulations": 1, "blocks": 0},
+        {"jobs": 0, "simulations": 0, "blocks": 0},
+    ),
+)
+def test_less_than_one_value_error(
+    kwargs: dict[Literal["jobs", "simulations", "blocks"], int]
+) -> None:
+    param = next(k for k, v in kwargs.items() if v < 1)
+    with pytest.raises(
+        ValueError,
+        match=(
+            f"^The '{param}' attribute must be greater than 0, "
+            f"but instead was given '{kwargs.get(param)}'.$"
+        ),
+    ):
+        JobSize(**kwargs)
+
+
+def generate_from_jobs_simulations_blocks(
+    *args: int | None,
+) -> Generator[tuple[int | None, ...], None, None]:
+    for combo in product(args, repeat=3):
+        yield combo
+
+
+@pytest.mark.parametrize("combo", generate_from_jobs_simulations_blocks(1, 5, 10))
+def test_from_jobs_simulations_blocks_output(combo: tuple[int, ...]) -> None:
+    jobs, simulations, blocks = combo
+    for inference_method in (None, ""):
+        for batch_system in (None, BatchSystem.AWS, BatchSystem.LOCAL, BatchSystem.SLURM):
+            job_size = JobSize.from_jobs_simulations_blocks(
+                jobs, simulations, blocks, inference_method, batch_system
+            )
+            assert job_size.jobs >= 1
+            assert job_size.simulations >= simulations
+            assert job_size.blocks >= 1
+
+
+@pytest.mark.parametrize(
+    ("jobs", "simulations", "blocks", "inference_method", "batch_system", "expected"),
+    (
+        (4, 32, 8, None, None, JobSize(jobs=4, simulations=32, blocks=8)),
+        (4, 32, 8, None, BatchSystem.LOCAL, JobSize(jobs=1, simulations=10, blocks=1)),
+        (4, 4, 1, "emcee", BatchSystem.LOCAL, JobSize(jobs=1, simulations=4, blocks=1)),
+        (4, 16, 8, "emcee", None, JobSize(jobs=4, simulations=8 * 16, blocks=1)),
+    ),
+)
+def test_from_jobs_simulations_blocks_exact_results_for_select_inputs(
+    jobs: int | None,
+    simulations: int | None,
+    blocks: int | None,
+    inference_method: Literal["emcee"] | None,
+    batch_system: BatchSystem,
+    expected: JobSize,
+) -> None:
+    job_size = JobSize.from_jobs_simulations_blocks(
+        jobs, simulations, blocks, inference_method, batch_system
+    )
+    assert job_size == expected
diff --git a/flepimop/gempyor_pkg/tests/batch/test_job_time_limit_class.py b/flepimop/gempyor_pkg/tests/batch/test_job_time_limit_class.py
new file mode 100644
index 000000000..fddfb7ec3
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/batch/test_job_time_limit_class.py
@@ -0,0 +1,124 @@
+from datetime import timedelta
+import re
+from typing import Literal
+
+import pytest
+
+from gempyor.batch import BatchSystem, JobSize, JobTimeLimit
+
+
+NONPOSITIVE_TIMEDELTAS = (timedelta(), timedelta(hours=-1.0), timedelta(days=-3.0))
+
+
+@pytest.mark.parametrize("time_limit", NONPOSITIVE_TIMEDELTAS)
+def test_time_limit_non_positive_value_error(time_limit: timedelta) -> None:
+    with pytest.raises(
+        ValueError,
+        match=(
+            r"^The \`time\_limit\` attribute has [0-9\,\-]+ seconds\, "
+            r"which is less than or equal to 0\.$"
+        ),
+    ):
+        JobTimeLimit(time_limit=time_limit)
+
+
+@pytest.mark.parametrize(
+    "time_limit",
+    (
+        timedelta(hours=1),
+        timedelta(hours=2, minutes=34, seconds=56),
+        timedelta(days=1, seconds=3),
+        timedelta(minutes=12345),
+    ),
+)
+@pytest.mark.parametrize(
+    "batch_system", (None, BatchSystem.AWS, BatchSystem.LOCAL, BatchSystem.SLURM)
+)
+def test_format_output_validation(
+    time_limit: timedelta, batch_system: BatchSystem | None
+) -> None:
+    job_time_limit = JobTimeLimit(time_limit=time_limit)
+    formatted_time_limit = job_time_limit.format(batch_system=batch_system)
+    assert isinstance(formatted_time_limit, str)
+    if batch_system == BatchSystem.SLURM:
+        assert re.match(r"^[0-9]+\:[0-9]{2}\:[0-9]{2}$", formatted_time_limit)
+    else:
+        assert formatted_time_limit.isdigit()
+
+
+@pytest.mark.parametrize(
+    ("time_limit", "batch_system", "expected"),
+    (
+        (timedelta(hours=1), None, "60"),
+        (timedelta(seconds=20), None, "1"),
+        (timedelta(days=2, hours=3, minutes=45), None, "3105"),
+        (timedelta(hours=1), BatchSystem.SLURM, "1:00:00"),
+        (timedelta(seconds=20), BatchSystem.SLURM, "0:00:20"),
+        (timedelta(days=1, hours=2, minutes=34, seconds=5), BatchSystem.SLURM, "26:34:05"),
+    ),
+)
+def test_format_exact_results(
+    time_limit: timedelta, batch_system: BatchSystem | None, expected: str
+) -> None:
+    job_time_limit = JobTimeLimit(time_limit=time_limit)
+    assert job_time_limit.format(batch_system=batch_system) == expected
+
+
+@pytest.mark.parametrize("time_per_simulation", NONPOSITIVE_TIMEDELTAS)
+def test_from_per_simulation_time_per_simulation_nonpositive_value_error(
+    time_per_simulation: timedelta,
+) -> None:
+    job_size = JobSize(jobs=1, simulations=1, blocks=1)
+    with pytest.raises(
+        ValueError,
+        match=(
+            r"^The \`time\_per\_simulation\` is \'[0-9\,\-]+\' seconds\, "
+            r"which is less than or equal to 0\.$"
+        ),
+    ):
+        JobTimeLimit.from_per_simulation_time(
+            job_size, time_per_simulation, timedelta(minutes=10)
+        )
+
+
+@pytest.mark.parametrize("initial_time", NONPOSITIVE_TIMEDELTAS)
+def test_from_per_simulation_initial_time_nonpositive_value_error(
+    initial_time: timedelta,
+) -> None:
+    job_size = JobSize(jobs=1, simulations=1, blocks=1)
+    with pytest.raises(
+        ValueError,
+        match=(
+            r"^The \`initial\_time\` is \'[0-9\,\-]+\' seconds\, "
+            r"which is less than or equal to 0\.$"
+        ),
+    ):
+        JobTimeLimit.from_per_simulation_time(job_size, timedelta(minutes=10), initial_time)
+
+
+@pytest.mark.parametrize(
+    "job_size",
+    (
+        JobSize(jobs=1, simulations=10, blocks=1),
+        JobSize(jobs=10, simulations=25, blocks=15),
+    ),
+)
+@pytest.mark.parametrize(
+    "time_per_simulation",
+    (timedelta(minutes=5), timedelta(seconds=120), timedelta(hours=1.5)),
+)
+@pytest.mark.parametrize(
+    "initial_time", (timedelta(minutes=10), timedelta(seconds=30), timedelta(hours=2))
+)
+def test_from_per_simulation_time(
+    job_size: JobSize, time_per_simulation: timedelta, initial_time: timedelta
+) -> None:
+    job_time_limit = JobTimeLimit.from_per_simulation_time(
+        job_size, time_per_simulation, initial_time
+    )
+    assert job_time_limit.time_limit >= initial_time
+
+    double_job_time_limit = JobTimeLimit.from_per_simulation_time(
+        job_size, 2 * time_per_simulation, initial_time
+    )
+    assert double_job_time_limit > job_time_limit
diff --git a/flepimop/gempyor_pkg/tests/batch/test_write_manifest.py b/flepimop/gempyor_pkg/tests/batch/test_write_manifest.py
new file mode 100644
index 000000000..69234d0bc
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/batch/test_write_manifest.py
@@ -0,0 +1,74 @@
+import hashlib
+import json
+from pathlib import Path
+from unittest.mock import patch
+from typing import Any
+
+import pytest
+
+from gempyor.batch import write_manifest
+from gempyor.utils import _git_head
+
+
+@pytest.mark.parametrize("job_name", ("my job name", "flu scenario"))
+@pytest.mark.parametrize(
+    "flepi_path", (Path("/path/to/flepiMoP"), Path("flepiMoP"), Path("~/flepiMoP"))
+)
+@pytest.mark.parametrize(
+    "project_path", (Path("/path/to/project"), Path("project"), Path("~/project"))
+)
+@pytest.mark.parametrize(
+    "destination",
+    (
+        None,
+        Path("manifest.json"),
+        Path("/absolute/manifest.json"),
+        Path("not_manifest.json"),
+    ),
+)
+@pytest.mark.parametrize(
+    "additional_meta",
+    ({}, {"var1": 1, "var2": "abc", "other": 3.14, "bool": True, "null": None}),
+)
+def test_output_validation(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    job_name: str,
+    flepi_path: Path,
+    project_path: Path,
+    destination: Path | None,
+    additional_meta: dict[str, Any],
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    if isinstance(destination, Path) and destination.is_absolute():
+        destination = tmp_path / destination.name
+
+    def git_head_wraps(repository: Path) -> str:
+        return (
+            hashlib.sha1(str(repository).encode()).hexdigest()
+            if repository in [flepi_path, project_path]
+            else _git_head(repository)
+        )
+
+    with patch("gempyor.batch._git_head", wraps=git_head_wraps) as git_head_patch:
+        manifest_file = write_manifest(
+            job_name, flepi_path, project_path, destination=destination, **additional_meta
+        )
+        assert (
+            manifest_file == Path("manifest.json").absolute()
+            if destination is None
+            else destination
+        )
+        with manifest_file.open(encoding="utf-8") as f:
+            manifest = json.load(f)
+
+        assert "cmd" in manifest and isinstance(manifest["cmd"], str)
+        del manifest["cmd"]
+        assert manifest == {
+            **additional_meta,
+            **{
+                "job_name": job_name,
+                "data_sha": hashlib.sha1(str(project_path).encode()).hexdigest(),
+                "flepimop_sha": hashlib.sha1(str(flepi_path).encode()).hexdigest(),
+            },
+        }
diff --git a/flepimop/gempyor_pkg/tests/info/test__get_info.py b/flepimop/gempyor_pkg/tests/info/test__get_info.py
new file mode 100644
index 000000000..910c1bbe4
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/info/test__get_info.py
@@ -0,0 +1,56 @@
+from pathlib import Path
+
+from pydantic import BaseModel
+import pytest
+import yaml
+
+from gempyor.info import _get_info
+
+
+class NameOnly(BaseModel):
+    name: str
+
+
+@pytest.fixture
+def create_mock_info_directory(tmp_path: Path) -> Path:
+    for file, contents in (
+        ("abc/def.yml", {"name": "Foobar"}),
+        ("abc/ghi.yml", {"name": "Fizzbuzz"}),
+    ):
+        file = tmp_path / "info" / file
+        file.parent.mkdir(parents=True, exist_ok=True)
+        with file.open(mode="w") as f:
+            yaml.dump(contents, f)
+    return tmp_path.absolute()
+
+
+def test_file_does_not_exist_value_error(
+    monkeypatch: pytest.MonkeyPatch, create_mock_info_directory: Path
+) -> None:
+    monkeypatch.setenv("FLEPI_PATH", str(create_mock_info_directory.parent))
+    with pytest.raises(ValueError):
+        _get_info("does_not", "exist", object, None)
+
+
+@pytest.mark.parametrize(
+    ("category", "name", "model"), (("abc", "def", NameOnly), ("abc", "ghi", NameOnly))
+)
+def test_output_validation(
+    monkeypatch: pytest.MonkeyPatch,
+    create_mock_info_directory: Path,
+    category: str,
+    name: str,
+    model: type[BaseModel],
+) -> None:
+    monkeypatch.setenv("FLEPI_PATH", str(create_mock_info_directory))
+    results = []
+    for flepi_path in (
+        None,
+        create_mock_info_directory,
+        str(create_mock_info_directory),
+    ):
+        info = _get_info(category, name, model, flepi_path)
+        assert isinstance(info, model)
+        results.append(info)
+    for i in range(len(results) - 1):
+        assert results[i] == results[i + 1]
diff --git a/flepimop/gempyor_pkg/tests/info/test__infer_cluster_from_fqdn.py b/flepimop/gempyor_pkg/tests/info/test__infer_cluster_from_fqdn.py
new file mode 100644
index 000000000..0502cdf9f
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/info/test__infer_cluster_from_fqdn.py
@@ -0,0 +1,46 @@
+from unittest.mock import patch
+
+import pytest
+
+from gempyor.info import _infer_cluster_from_fqdn
+
+
+@pytest.mark.parametrize("fqdn", ("new.cluster.com", "unsupported.cluster"))
+def test_no_matching_fqdn_found_value_error(fqdn: str) -> None:
+    def socket_fqdn_wraps() -> str:
+        return fqdn
+
+    with patch("gempyor.info.getfqdn", wraps=socket_fqdn_wraps) as socket_fqdn_patch:
+        with pytest.raises(
+            ValueError,
+            match=f"^The fqdn, '{fqdn}', does not match any of the expected clusters.$",
+        ):
+            _infer_cluster_from_fqdn()
+        socket_fqdn_patch.assert_called_once()
+
+
+@pytest.mark.parametrize(
+    ("fqdn", "raise_error", "expected"),
+    (
+        ("login01.cm.cluster", True, "rockfish"),
+        ("login01.cm.cluster", False, "rockfish"),
+        ("login3.cm.cluster", True, "rockfish"),
+        ("login3.cm.cluster", False, "rockfish"),
+        ("longleaf-login1.its.unc.edu", True, "longleaf"),
+        ("longleaf-login1.its.unc.edu", False, "longleaf"),
+        ("longleaf-login07.its.unc.edu", True, "longleaf"),
+        ("longleaf-login07.its.unc.edu", False, "longleaf"),
+        ("longleaf-login07.its.unc.edu", True, "longleaf"),
+        ("longleaf-login07.its.unc.edu", False, "longleaf"),
+        ("epid-iss-MacBook-Pro.local", False, None),
+    ),
+)
+def test_exact_results_for_select_values(
+    fqdn: str, raise_error: bool, expected: str
+) -> None:
+    def socket_fqdn_wraps() -> str:
+        return fqdn
+
+    with patch("gempyor.info.getfqdn", wraps=socket_fqdn_wraps) as socket_fqdn_patch:
+        assert _infer_cluster_from_fqdn(raise_error=raise_error) == expected
+        socket_fqdn_patch.assert_called_once()
diff --git a/flepimop/gempyor_pkg/tests/info/test_get_cluster_info.py b/flepimop/gempyor_pkg/tests/info/test_get_cluster_info.py
new file mode 100644
index 000000000..66fcd9836
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/info/test_get_cluster_info.py
@@ -0,0 +1,33 @@
+import os
+from unittest.mock import patch
+
+import pytest
+
+from gempyor.info import Cluster, get_cluster_info
+
+
+@pytest.mark.parametrize("name", ("longleaf", "rockfish"))
+@pytest.mark.skipif(
+    os.getenv("FLEPI_PATH") is None,
+    reason="The $FLEPI_PATH environment variable is not set.",
+)
+def test_exact_results_given_cluster_name(name: str) -> None:
+    cluster = get_cluster_info(name)
+    assert isinstance(cluster, Cluster)
+
+
+@pytest.mark.parametrize("name", ("longleaf", "rockfish"))
+@pytest.mark.skipif(
+    os.getenv("FLEPI_PATH") is None,
+    reason="The $FLEPI_PATH environment variable is not set.",
+)
+def test_exact_results_when_inferred_from_fqdn(name: str) -> None:
+    def infer_cluster_from_fqdn_wraps() -> str:
+        return name
+
+    with patch(
+        "gempyor.info._infer_cluster_from_fqdn", wraps=infer_cluster_from_fqdn_wraps
+    ) as infer_cluster_from_fqdn_patch:
+        cluster = get_cluster_info(None)
+        assert isinstance(cluster, Cluster)
+        infer_cluster_from_fqdn_patch.assert_called_once()
diff --git a/flepimop/gempyor_pkg/tests/logging/test__get_logging_level.py b/flepimop/gempyor_pkg/tests/logging/test__get_logging_level.py
new file mode 100644
index 000000000..67480442c
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/logging/test__get_logging_level.py
@@ -0,0 +1,32 @@
+import logging
+
+import pytest
+
+from gempyor.logging import _get_logging_level
+
+
+@pytest.mark.parametrize("verbosity", (-1, -100))
+def test__get_logging_level_negative_verbosity_value_error(verbosity: int) -> None:
+    with pytest.raises(
+        ValueError, match=f"`verbosity` must be non-negative, was given '{verbosity}'."
+    ):
+        _get_logging_level(verbosity)
+
+
+@pytest.mark.parametrize(
+    ("verbosity", "expected_level"),
+    (
+        (logging.ERROR, logging.ERROR),
+        (logging.WARNING, logging.WARNING),
+        (logging.INFO, logging.INFO),
+        (logging.DEBUG, logging.DEBUG),
+        (0, logging.ERROR),
+        (1, logging.WARNING),
+        (2, logging.INFO),
+        (3, logging.DEBUG),
+        (4, logging.DEBUG),
+        (5, logging.DEBUG),
+    ),
+)
+def test__get_logging_level_output_validation(verbosity: int, expected_level: int) -> None:
+    assert _get_logging_level(verbosity) == expected_level
diff --git a/flepimop/gempyor_pkg/tests/logging/test_click_handler_class.py b/flepimop/gempyor_pkg/tests/logging/test_click_handler_class.py
new file mode 100644
index 000000000..983acba8a
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/logging/test_click_handler_class.py
@@ -0,0 +1,71 @@
+import io
+import logging
+from typing import Any, IO
+
+import pytest
+
+from gempyor.logging import ClickHandler
+
+
+@pytest.mark.parametrize(
+    "level",
+    (logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL),
+)
+@pytest.mark.parametrize("file", (None, io.StringIO))
+@pytest.mark.parametrize("nl", (True, False))
+@pytest.mark.parametrize("err", (False, True))
+@pytest.mark.parametrize("color", (None, False))
+@pytest.mark.parametrize("punctuate", (True, False))
+def test_click_handler_init(
+    level: int | str,
+    file: IO[Any] | None,
+    nl: bool,
+    err: bool,
+    color: bool | None,
+    punctuate: bool,
+) -> None:
+    handler = ClickHandler(
+        level=level, file=file, nl=nl, err=err, color=color, punctuate=punctuate
+    )
+    assert handler.level == level
+    assert handler._file == file
+    assert handler._nl == nl
+    assert handler._err == err
+    assert handler._color == color
+    assert handler._punctuate == punctuate
+
+
+@pytest.mark.parametrize("punctuate", (True, False))
+@pytest.mark.parametrize(
+    "msg",
+    (
+        "This is a message",
+        "Another message.",
+        "Start to a list:",
+        "Middle of a sentence,",
+        "Oh-no!",
+        "Question?",
+    ),
+)
+def test_click_handler_punctuation_formatting(punctuate: bool, msg: str) -> None:
+    buffer = io.StringIO()
+    handler = ClickHandler(level=logging.DEBUG, file=buffer, punctuate=punctuate)
+    log_record = logging.LogRecord(
+        name="",
+        level=logging.DEBUG,
+        pathname="",
+        lineno=1,
+        msg=msg,
+        args=None,
+        exc_info=None,
+    )
+    handler.emit(log_record)
+    buffer.seek(0)
+    handler_msg = buffer.getvalue()
+    if not punctuate:
+        assert handler_msg == msg + "\n"
+    else:
+        assert (
+            handler_msg
+            == (msg if msg.endswith(ClickHandler._punctuation) else f"{msg}.") + "\n"
+        )
diff --git a/flepimop/gempyor_pkg/tests/logging/test_get_script_logger.py b/flepimop/gempyor_pkg/tests/logging/test_get_script_logger.py
new file mode 100644
index 000000000..b96e69cb7
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/logging/test_get_script_logger.py
@@ -0,0 +1,67 @@
+import logging
+import random
+import string
+
+import pytest
+
+from gempyor.logging import _get_logging_level, get_script_logger, DEFAULT_LOG_FORMAT
+
+
+@pytest.mark.parametrize("name", ("foobar", "fizzbuzz"))
+@pytest.mark.parametrize(
+    "verbosity",
+    (
+        0,
+        1,
+        2,
+        3,
+        4,
+        logging.CRITICAL,
+        logging.ERROR,
+        logging.WARNING,
+        logging.INFO,
+        logging.DEBUG,
+    ),
+)
+@pytest.mark.parametrize("handler", (None, logging.StreamHandler()))
+@pytest.mark.parametrize("log_format", (None, "%(message)s"))
+def test_get_script_logger(
+    caplog: pytest.LogCaptureFixture,
+    name: str,
+    verbosity: int,
+    handler: logging.Handler | None,
+    log_format: str | None,
+) -> None:
+    caplog.set_level(logging.DEBUG, logger=name)
+
+    if log_format is None:
+        logger = get_script_logger(name, verbosity, handler=handler)
+    else:
+        logger = get_script_logger(name, verbosity, handler=handler, log_format=log_format)
+
+    assert isinstance(logger, logging.Logger)
+    assert logger.name == name
+    assert logger.level == _get_logging_level(verbosity)
+    if handler is not None:
+        assert len(logger.handlers) == 1
+        assert logger.handlers[0] == handler
+    assert logger.handlers[0].formatter._fmt == (
+        log_format if log_format else DEFAULT_LOG_FORMAT
+    )
+
+    i = 0
+    for val, lvl in [
+        (10, "debug"),
+        (20, "info"),
+        (30, "warning"),
+        (40, "error"),
+        (50, "critical"),
+    ]:
+        msg = "".join(random.choice(string.ascii_letters) for _ in range(20))
+        getattr(logger, lvl)(msg)
+        if val < _get_logging_level(verbosity):
+            assert len(caplog.records) == i
+            continue
+        assert caplog.records[i].levelno == val
+        assert caplog.records[i].message == msg
+        i += 1
diff --git a/flepimop/gempyor_pkg/tests/shared_cli/test_duration_param_type_class.py b/flepimop/gempyor_pkg/tests/shared_cli/test_duration_param_type_class.py
new file mode 100644
index 000000000..cfeffb146
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/shared_cli/test_duration_param_type_class.py
@@ -0,0 +1,40 @@
+from datetime import timedelta
+from typing import Any
+
+from click.exceptions import BadParameter
+import pytest
+
+from gempyor.shared_cli import DurationParamType
+
+
+@pytest.mark.parametrize("nonnegative", (True, False))
+@pytest.mark.parametrize("value", ("abc", "$12.34", "12..3", "12years", "12.a2"))
+def test_invalid_duration_bad_parameter(nonnegative: bool, value: Any) -> None:
+    duration = DurationParamType(nonnegative=nonnegative)
+    with pytest.raises(BadParameter, match="^'.*' is not a valid duration$"):
+        duration.convert(value, None, None)
+
+
+@pytest.mark.parametrize("value", ("-1", "-123", "-99.45", "-.9"))
+def test_negative_duration_bad_parameter(value: Any) -> None:
+    duration = DurationParamType(nonnegative=True)
+    with pytest.raises(BadParameter, match="^'.*' is a negative duration$"):
+        duration.convert(value, None, None)
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    (
+        ("1", timedelta(minutes=1)),
+        ("2s", timedelta(seconds=2)),
+        ("3hrs", timedelta(hours=3)),
+        ("-4min", timedelta(minutes=-4)),
+        ("-5d", timedelta(days=-5)),
+        ("12.3", timedelta(minutes=12.3)),
+        ("-45.6h", timedelta(hours=-45.6)),
+        ("-.1w", timedelta(weeks=-0.1)),
+    ),
+)
+def test_exact_results_for_select_inputs(value: Any, expected: timedelta) -> None:
+    duration = DurationParamType(nonnegative=False)
+    assert duration.convert(value, None, None) == expected
diff --git a/flepimop/gempyor_pkg/tests/shared_cli/test_log_cli_inputs.py b/flepimop/gempyor_pkg/tests/shared_cli/test_log_cli_inputs.py
new file mode 100644
index 000000000..1693a5733
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/shared_cli/test_log_cli_inputs.py
@@ -0,0 +1,34 @@
+import logging
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from gempyor.logging import _get_logging_level
+from gempyor.shared_cli import log_cli_inputs
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    (
+        {"abc": 123},
+        {"abc": 123, "verbosity": 3},
+        {"str": "foobar", "int": 123, "float": 3.14, "bool": True},
+        {"str": "foobar", "int": 123, "float": 3.14, "bool": True, "verbosity": 3},
+        {"file_path": Path("fizzbuzz.log")},
+        {"file_path": Path("fizzbuzz.log"), "verbosity": 3},
+    ),
+)
+@pytest.mark.parametrize("verbosity", (None, 0, 1, 2, 3, logging.DEBUG, logging.INFO))
+def test_number_of_messages(
+    caplog: pytest.LogCaptureFixture, kwargs: dict[str, Any], verbosity: int | None
+) -> None:
+    log_cli_inputs(kwargs, verbosity=verbosity)
+    assert len(caplog.records) == (
+        len(kwargs) + 1
+        if _get_logging_level(
+            kwargs.get("verbosity", 0) if verbosity is None else verbosity
+        )
+        <= logging.DEBUG
+        else 0
+    )
diff --git a/flepimop/gempyor_pkg/tests/shared_cli/test_memory_param_type_class.py b/flepimop/gempyor_pkg/tests/shared_cli/test_memory_param_type_class.py
new file mode 100644
index 000000000..53c3558ce
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/shared_cli/test_memory_param_type_class.py
@@ -0,0 +1,70 @@
+import random
+from typing import Any
+
+from click.exceptions import BadParameter
+import pytest
+
+from gempyor.shared_cli import MemoryParamType
+
+
+@pytest.mark.parametrize("unit", ("Nope", "NO CHANCE", "wrong", "bb"))
+def test_invalid_unit_value_error(unit: str) -> None:
+    with pytest.raises(
+        ValueError,
+        match=(
+            "^The `unit` given is not valid, given "
+            f"'{unit.lower()}' and must be one of:.*.$"
+        ),
+    ):
+        MemoryParamType(unit)
+
+
+@pytest.mark.parametrize("value", ("1..2MB", "3.4cb", "56.abc", "-1GB"))
+def test_invalid_value_bad_parameter(value: Any) -> None:
+    memory = MemoryParamType("mb")
+    with pytest.raises(BadParameter, match="^.* is not a valid memory size.$"):
+        memory.convert(value, None, None)
+
+
+@pytest.mark.parametrize("unit", MemoryParamType._units.keys())
+@pytest.mark.parametrize("as_int", (True, False))
+@pytest.mark.parametrize(
+    "number",
+    [random.randint(1, 1000) for _ in range(3)]  # int
+    + [random.random() for _ in range(3)]  # float without numbers left of decimal
+    + [
+        random.randint(1, 25) + random.random() for _ in range(3)
+    ],  # float with numbers left of the decimal
+)
+def test_convert_acts_as_identity(unit: str, as_int: bool, number: int | float) -> None:
+    memory = MemoryParamType(unit, as_int=as_int)
+    for u in (unit, unit.upper()):
+        result = memory.convert(f"{number}{u}".lstrip("0"), None, None)
+        assert isinstance(result, int if as_int else float)
+        assert abs(result - number) <= 1 if as_int else result == number
+
+
+@pytest.mark.parametrize(
+    ("unit", "as_int", "value", "expected"),
+    (
+        ("gb", False, "1.2gb", 1.2),
+        ("gb", True, "1.2gb", 2),
+        ("kb", False, "1mb", 1024.0),
+        ("kb", True, "1mb", 1024),
+        ("gb", False, "30mb", 30.0 / 1024.0),
+        ("gb", True, "30mb", 1),
+        ("kb", False, "2tb", 2.0 * (1024.0**3.0)),
+        ("kb", True, "2tb", 2147483648),
+        ("mb", False, "0.1gb", 0.1 * 1024.0),
+        ("mb", True, "0.1gb", 103),
+        ("gb", False, "4", 4.0),
+        ("gb", True, "4", 4),
+        ("mb", False, "1234.56", 1234.56),
+        ("mb", True, "1234.56", 1235),
+    ),
+)
+def test_exact_results_for_select_inputs(
+    unit: str, as_int: bool, value: Any, expected: float | int
+) -> None:
+    memory = MemoryParamType(unit, as_int=as_int)
+    assert memory.convert(value, None, None) == expected
diff --git a/flepimop/gempyor_pkg/tests/templates/test_cluster_setup_bash.py b/flepimop/gempyor_pkg/tests/templates/test_cluster_setup_bash.py
new file mode 100644
index 000000000..90e1e4cc2
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/templates/test_cluster_setup_bash.py
@@ -0,0 +1,104 @@
+import os
+from typing import Any
+
+import pytest
+
+from gempyor._jinja import _render_template
+from gempyor.info import Cluster, Module, PathExport, get_cluster_info
+
+
+@pytest.mark.parametrize("cluster", (None, "longleaf", "rockfish"))
+@pytest.mark.skipif(
+    os.getenv("FLEPI_PATH") is None,
+    reason="The $FLEPI_PATH environment variable is not set.",
+)
+def test_output_validation(cluster: str | None) -> None:
+    cluster = cluster if cluster is None else get_cluster_info(cluster).model_dump()
+    rendered_template = _render_template("cluster_setup.bash.j2", {"cluster": cluster})
+    lines = rendered_template.split("\n")
+    assert "module purge" in lines
+    assert len(lines) == 2 if cluster is None else len(lines) > 2
+
+
+@pytest.mark.parametrize(
+    ("cluster", "expected"),
+    (
+        (
+            Cluster(name="foobar").model_dump(),
+            [
+                "# Purge/load modules",
+                "module purge",
+            ],
+        ),
+        (
+            Cluster(name="foo", modules=[Module(name="fizz")]).model_dump(),
+            [
+                "# Purge/load modules",
+                "module purge",
+                "module load fizz",
+            ],
+        ),
+        (
+            Cluster(
+                name="bar", modules=[Module(name="buzz", version="12.34")]
+            ).model_dump(),
+            [
+                "# Purge/load modules",
+                "module purge",
+                "module load buzz/12.34",
+            ],
+        ),
+        (
+            Cluster(
+                name="fizz", path_exports=[PathExport(path="/path/to/custom/bin")]
+            ).model_dump(),
+            [
+                "# Purge/load modules",
+                "module purge",
+                "",
+                "# Path modifications",
+                'if [ -r "/path/to/custom/bin" ]; then',
+                "    export PATH=/path/to/custom/bin:$PATH",
+                'elif [ "False" = "True" ]; then',
+                "    echo \"The path '/path/to/custom/bin' does not exist but is required.\"",
+                "    exit 1",
+                "fi",
+            ],
+        ),
+        (
+            Cluster(
+                name="new_cluster",
+                modules=[Module(name="abc", version="123"), Module(name="def")],
+                path_exports=[
+                    PathExport(path="~/helpful/bin", prepend=False),
+                    PathExport(path="~/required/bin", error_if_missing=True),
+                ],
+            ).model_dump(),
+            [
+                "# Purge/load modules",
+                "module purge",
+                "module load abc/123",
+                "module load def",
+                "",
+                "# Path modifications",
+                'if [ -r "~/helpful/bin" ]; then',
+                "    export PATH=$PATH:~/helpful/bin",
+                'elif [ "False" = "True" ]; then',
+                "    echo \"The path '~/helpful/bin' does not exist but is required.\"",
+                "    exit 1",
+                "fi",
+                'if [ -r "~/required/bin" ]; then',
+                "    export PATH=~/required/bin:$PATH",
+                'elif [ "True" = "True" ]; then',
+                "    echo \"The path '~/required/bin' does not exist but is required.\"",
+                "    exit 1",
+                "fi",
+            ],
+        ),
+    ),
+)
+def test_exact_results_for_select_inputs(
+    cluster: dict[str, Any], expected: list[str]
+) -> None:
+    lines = _render_template("cluster_setup.bash.j2", {"cluster": cluster}).split("\n")
+    assert lines == expected
diff --git a/flepimop/gempyor_pkg/tests/templates/test_conda_activate_bash.py b/flepimop/gempyor_pkg/tests/templates/test_conda_activate_bash.py
new file mode 100644
index 000000000..a72b01682
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/templates/test_conda_activate_bash.py
@@ -0,0 +1,33 @@
+import pytest
+
+from gempyor._jinja import _render_template
+
+
+@pytest.mark.parametrize(
+    ("conda_env", "expected"),
+    (
+        (
+            "flepimop-env",
+            [
+                "# Load conda env",
+                'eval "$( conda shell.bash hook )"',
+                "conda activate flepimop-env",
+                "WHICH_PYTHON=$( which python )",
+                "WHICH_RSCRIPT=$( which Rscript )",
+            ],
+        ),
+        (
+            "/path/to/conda/env",
+            [
+                "# Load conda env",
+                'eval "$( conda shell.bash hook )"',
+                "conda activate /path/to/conda/env",
+                "WHICH_PYTHON=$( which python )",
+                "WHICH_RSCRIPT=$( which Rscript )",
+            ],
+        ),
+    ),
+)
+def test_exact_results_for_select_inputs(conda_env: str, expected: list[str]) -> None:
+    lines = _render_template("conda_activate.bash.j2", {"conda_env": conda_env}).split("\n")
+    assert lines == expected
diff --git a/flepimop/gempyor_pkg/tests/templates/test_inference_environment_variables.py b/flepimop/gempyor_pkg/tests/templates/test_inference_environment_variables.py
new file mode 100644
index 000000000..61afebe28
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/templates/test_inference_environment_variables.py
@@ -0,0 +1,81 @@
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from gempyor._jinja import _render_template
+
+
+@pytest.mark.parametrize(
+    ("template_data", "expected"),
+    (
+        (
+            {
+                "config_path": "/home/foobar/project/config.yml",
+                "flepi_path": "/home/foobar/flepiMoP",
+                "job_name": "sample_2pop-20240101T0000_None_None",
+                "outcome_modifiers_scenario": None,
+                "project_path": "/home/foobar/project",
+                "reset_chimerics": False,
+                "seir_modifiers_scenario": None,
+                "stoch_traj_flag": True,
+            },
+            [
+                "# Set environment variables",
+                'if [ -z "$SLURM_ARRAY_TASK_ID" ]; then',
+                '    FLEPI_SLOT_INDEX="1"',
+                "else",
+                "    FLEPI_SLOT_INDEX=$SLURM_ARRAY_TASK_ID",
+                "fi",
+                'export FLEPI_PATH="/home/foobar/flepiMoP"',
+                'export PROJECT_PATH="/home/foobar/project"',
+                'export CONFIG_PATH="/home/foobar/project/config.yml"',
+                'export FLEPI_STOCHASTIC_RUN="TRUE"',
+                'export FLEPI_OUTCOME_SCENARIOS="None"',
+                'export FLEPI_SEIR_SCENARIOS="None"',
+                'export FLEPI_RESET_CHIMERICS="FALSE"',
+                "export LOG_FILE="
+                '"out_sample_2pop-20240101T0000_None_None_$FLEPI_SLOT_INDEX.out"',
+            ],
+        ),
+        (
+            {
+                "config_path": Path(
+                    "/users/f/o/foobar/flepimop_sample/config_sample_2pop_inference.yml"
+                ),
+                "flepi_path": Path("/users/f/o/foobar/flepiMoP"),
+                "job_name": "sample_2pop-20240101T0000_Ro_all_test_limits",
+                "outcome_modifiers_scenario": "test_limits",
+                "project_path": Path("/users/f/o/foobar/flepimop_sample"),
+                "reset_chimerics": True,
+                "seir_modifiers_scenario": "Ro_all",
+                "stoch_traj_flag": False,
+            },
+            [
+                "# Set environment variables",
+                'if [ -z "$SLURM_ARRAY_TASK_ID" ]; then',
+                '    FLEPI_SLOT_INDEX="1"',
+                "else",
+                "    FLEPI_SLOT_INDEX=$SLURM_ARRAY_TASK_ID",
+                "fi",
+                'export FLEPI_PATH="/users/f/o/foobar/flepiMoP"',
+                'export PROJECT_PATH="/users/f/o/foobar/flepimop_sample"',
+                "export CONFIG_PATH="
+                '"/users/f/o/foobar/flepimop_sample/config_sample_2pop_inference.yml"',
+                'export FLEPI_STOCHASTIC_RUN="FALSE"',
+                'export FLEPI_OUTCOME_SCENARIOS="test_limits"',
+                'export FLEPI_SEIR_SCENARIOS="Ro_all"',
+                'export FLEPI_RESET_CHIMERICS="TRUE"',
+                "export LOG_FILE="
+                '"out_sample_2pop-20240101T0000_Ro_all_test_limits_$FLEPI_SLOT_INDEX.out"',
+            ],
+        ),
+    ),
+)
+def test_exact_results_for_select_inputs(
+    template_data: dict[str, Any], expected: list[str]
+) -> None:
+    lines = _render_template(
+        "inference_environment_variables.bash.j2", template_data
+    ).split("\n")
+    assert lines == expected
diff --git a/flepimop/gempyor_pkg/tests/utils/test__format_cli_options.py b/flepimop/gempyor_pkg/tests/utils/test__format_cli_options.py
new file mode 100644
index 000000000..3c7df10d3
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/utils/test__format_cli_options.py
@@ -0,0 +1,26 @@
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from gempyor.utils import _format_cli_options
+
+
+@pytest.mark.parametrize(
+    ("options", "formatted_options"),
+    (
+        ({"name": "foo bar fizz buzz"}, ["--name='foo bar fizz buzz'"]),
+        ({"o": Path("/path/to/output.log")}, ["-o=/path/to/output.log"]),
+        (
+            {"opt1": "```", "opt2": "$( echo 'Hello!')"},
+            ["--opt1='```'", "--opt2='$( echo '\"'\"'Hello!'\"'\"')'"],
+        ),
+        (
+            {"start": datetime(2024, 1, 1, 12, 34, 56), "J": "rm -rf ~"},
+            ["--start='2024-01-01 12:34:56'", "-J='rm -rf ~'"],
+        ),
+    ),
+)
+def test_output_validation(options: dict[str, Any], formatted_options: list[str]) -> None:
+    assert _format_cli_options(options) == formatted_options
diff --git a/flepimop/gempyor_pkg/tests/utils/test__git_head.py b/flepimop/gempyor_pkg/tests/utils/test__git_head.py
new file mode 100644
index 000000000..5005bf86e
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/utils/test__git_head.py
@@ -0,0 +1,52 @@
+import os
+from pathlib import Path
+from unittest.mock import patch
+import subprocess
+
+import pytest
+
+from gempyor.utils import _git_head, _shutil_which
+
+
+@pytest.mark.parametrize(
+    "repository",
+    (Path("/mock/repository"), Path("relative/repository/path"), Path("~/repo")),
+)
+@pytest.mark.parametrize(
+    "sha",
+    (
+        "59fe36d13fe34b6c1fb5c92bf8c53b83bd3ba593",
+        "bba583acf3c4b17ab3241288bff4bcad271a807c",
+    ),
+)
+def test_output_validation(repository: Path, sha: str) -> None:
+    def shutil_which_wraps(
+        cmd: str,
+        mode: int = os.F_OK | os.X_OK,
+        path: str | bytes | os.PathLike | None = None,
+        check: bool = True,
+    ) -> str | None:
+        return (
+            "git" if cmd == "git" else _shutil_which(cmd, mode=mode, path=path, check=check)
+        )
+
+    def subprocess_run_wraps(args, **kwargs):
+        if os.path.basename(args[0]) == "git":
+            return subprocess.CompletedProcess(
+                args=args, returncode=0, stdout=f"{sha}\n".encode(), stderr=b""
+            )
+        return subprocess.run(args, **kwargs)
+
+    with patch(
+        "gempyor.utils._shutil_which", wraps=shutil_which_wraps
+    ) as shutil_which_patch:
+        with patch(
+            "gempyor.batch.subprocess.run", wraps=subprocess_run_wraps
+        ) as subprocess_run_patch:
+            assert _git_head(repository) == sha
+            shutil_which_patch.assert_called_once_with("git")
+            subprocess_run_patch.assert_called_once()
+            args = subprocess_run_patch.call_args.args[0]
+            assert args == ["git", "rev-parse", "HEAD"]
+            kwargs = subprocess_run_patch.call_args.kwargs
+            assert kwargs["cwd"] == repository.expanduser().absolute()
diff --git a/flepimop/gempyor_pkg/tests/utils/test__shutil_which.py b/flepimop/gempyor_pkg/tests/utils/test__shutil_which.py
new file mode 100644
index 000000000..19cfafce7
--- /dev/null
+++ b/flepimop/gempyor_pkg/tests/utils/test__shutil_which.py
@@ -0,0 +1,41 @@
+import os
+from pathlib import Path
+from shutil import which
+
+import pytest
+
+from gempyor.utils import _shutil_which
+
+
+@pytest.fixture
+def custom_path_setup(tmp_path: Path) -> str:
+    path_spec = set()
+    files = (
+        Path("abc"),
+        Path("bin/def"),
+        Path("bin/ghi"),
+        Path("bin/jkl"),
+        Path("dir1/dir2/xyz"),
+    )
+    for file in files:
+        file = tmp_path / file
+        file.parent.mkdir(parents=True, exist_ok=True)
+        file.write_text("#!/usr/bin/env bash\necho 'Hello!'")
+        file.chmod(0o755)
+        path_spec.add(str(file.parent.absolute()))
+    return os.pathsep.join(path_spec)
+
+
+@pytest.mark.parametrize("cmd", ("abc", "def", "ghi", "jkl", "xyz"))
+def test_matches_python_stdlib_in_basic_case(custom_path_setup: str, cmd: str) -> None:
+    assert _shutil_which(cmd, path=custom_path_setup, check=False) == which(
+        cmd, path=custom_path_setup
+    )
+
+
+def test_oserror_when_check_and_cmd_not_found(custom_path_setup: Path) -> None:
+    cmd = "does_not_exist"
+    with pytest.raises(
+        OSError, match=f"^Did not find '{cmd}' on path '{custom_path_setup}'.$"
+    ):
+        _shutil_which(cmd, path=custom_path_setup, check=True)
diff --git a/info/cluster/longleaf.yml b/info/cluster/longleaf.yml
new file mode 100644
index 000000000..edfa0e378
--- /dev/null
+++ b/info/cluster/longleaf.yml
@@ -0,0 +1,8 @@
+name: longleaf
+modules:
+  - name: gcc
+    version: 9.1.0
+  - name: anaconda
+    version: "2023.03"
+  - name: git
+  - name: aws
diff --git a/info/cluster/rockfish.yml b/info/cluster/rockfish.yml
new file mode 100644
index 000000000..2a7dc90ef
--- /dev/null
+++ b/info/cluster/rockfish.yml
@@ -0,0 +1,11 @@
+name: rockfish
+modules:
+  - name: gcc
+    version: 9.3.0
+  - name: anaconda
+    version: "2020.07"
+  - name: git
+    version: 2.42.0
+  - name: slurm
+path_exports:
+  - path: ~/aws-cli/bin
diff --git a/info/cluster/schema.yml b/info/cluster/schema.yml
new file mode 100644
index 000000000..75aef81b0
--- /dev/null
+++ b/info/cluster/schema.yml
@@ -0,0 +1,42 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: https://example.com/product.schema.json
+title: Cluster
+description: A generic description of an HPC cluster and its properties.
+type: object
+required:
+  - name
+properties:
+  name:
+    description: A short hand human readable unique name.
+    type: string
+  modules:
+    description: The modules to load when setting up this cluster.
+    type: array
+    items:
+      type: object
+      required:
+        - name
+      properties:
+        name:
+          description: The name of the module.
+          type: string
+        version:
+          description: The preferred version of the module if there is one.
+          type: string
+  path_exports:
+    description: Modifications to the $PATH environment variable in cluster setup.
+    type: array
+    items:
+      type: object
+      required:
+        - path
+      properties:
+        path:
+          description: The path to add to the $PATH environment variable.
+          type: string
+        prepend:
+          description: If true the path will prepended and appended if false.
+          type: boolean
+        error_if_missing:
+          description: If true an error will be thrown if the path is missing and if false will be ignored if missing.
+          type: boolean