diff --git a/README.md b/README.md
index 7462a11..9da768b 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@ It was developed for imaging data from (clear-tissue) [flamingo microscopes](htt
 In addition to the analysis functionality, CochleaNet implements data pre-processing to convert data from flamingo microscopes into a format compatible with [BigStitcher](https://imagej.net/plugins/bigstitcher/) and to export image data and segmentation results to [ome.zarr](https://www.nature.com/articles/s41592-021-01326-w) and [MoBIE](https://mobie.github.io/).
 This functionality is applicable to any imaging data from flamingo microscopes, not only clear-tissue data or cochleae. We aim to also extend the segmentation and analysis functionality to other kinds of samples imaged in the flamingo in the future.
 
-For installation and usage instructions, check out [the documentation](https://computational-cell-analytics.github.io/cochlea-net/). For more details on the underlying methodology check out [our preprint](TODO).
+For installation and usage instructions, check out [the documentation](https://computational-cell-analytics.github.io/cochlea-net/). For more details on the underlying methodology check out [our preprint](https://doi.org/10.1101/2025.11.16.688700).
 
 <!---
 The `flamingo_tools` library implements functionality for:
diff --git a/development/check_uploaded_models.py b/development/check_uploaded_models.py
new file mode 100644
index 0000000..eb18262
--- /dev/null
+++ b/development/check_uploaded_models.py
@@ -0,0 +1,98 @@
+import os
+import subprocess
+from shutil import copyfile
+
+import imageio.v3 as imageio
+import napari
+import pandas as pd
+import zarr
+from flamingo_tools.test_data import _sample_registry
+
+view = True
+data_dict = {
+    "SGN": "PV",
+    "IHC": "VGlut3",
+    "SGN-lowres": "PV-lowres",
+    "IHC-lowres": "MYO-lowres",
+    "Synapses": "CTBP2",
+}
+
+
+def check_segmentation_model(model_name, checkpoint_path=None):
+    output_folder = f"result_{model_name}"
+    os.makedirs(output_folder, exist_ok=True)
+    input_path = os.path.join(output_folder, f"{model_name}.tif")
+    if not os.path.exists(input_path):
+        data_path = _sample_registry().fetch(data_dict[model_name])
+        copyfile(data_path, input_path)
+
+    output_path = os.path.join(output_folder, "segmentation.zarr")
+    if not os.path.exists(output_path):
+        cmd = ["flamingo_tools.run_segmentation", "-i", input_path, "-o", output_folder, "-m", model_name]
+        if checkpoint_path is not None:
+            cmd.extend(["-c", checkpoint_path])
+        subprocess.run(cmd)
+
+    if view:
+        segmentation = zarr.open(output_path)["segmentation"][:]
+        image = imageio.imread(input_path)
+        v = napari.Viewer()
+        v.add_image(image)
+        v.add_labels(segmentation, name=f"{model_name}-segmentation")
+        napari.run()
+
+
+def check_detection_model():
+    model_name = "Synapses"
+    output_folder = f"result_{model_name}"
+    os.makedirs(output_folder, exist_ok=True)
+    input_path = os.path.join(output_folder, f"{model_name}.tif")
+    if not os.path.exists(input_path):
+        data_path = _sample_registry().fetch(data_dict[model_name])
+        copyfile(data_path, input_path)
+
+    output_path = os.path.join(output_folder, "synapse_detection.tsv")
+    if not os.path.exists(output_path):
+        subprocess.run(
+            ["flamingo_tools.run_detection", "-i", input_path, "-o", output_folder, "-m", model_name]
+        )
+
+    if view:
+        prediction = pd.read_csv(output_path, sep="\t")[["z", "y", "x"]]
+        image = imageio.imread(input_path)
+        v = napari.Viewer()
+        v.add_image(image)
+        v.add_points(prediction)
+        napari.run()
+
+
+def main():
+    # SGN segmentation:
+    # - Prediction works well on the CPU.
+    # - Prediction works well on the GPU.
+    # check_segmentation_model("SGN")
+
+    # IHC segmentation:
+    # - Prediction works well on the CPU.
+    # - Prediction works well on the GPU.
+    # check_segmentation_model("IHC")
+
+    # TODO: Update model.
+    # SGN segmentation (lowres):
+    # - Prediction does not work well on the CPU.
+    # - Prediction does not work well on the GPU.
+    check_segmentation_model("SGN-lowres", checkpoint_path="SGN-lowres.pt")
+
+    # IHC segmentation (lowres):
+    # - Prediction works well on the CPU.
+    # - Prediction works well on the GPU.
+    # check_segmentation_model("IHC-lowres")
+
+    # Synapse detection:
+    # - Prediction works well on the CPU.
+    # - Prediction works well on the GPU.
+    # check_detection_model()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/development/export_models.py b/development/export_models.py
new file mode 100644
index 0000000..69a62ec
--- /dev/null
+++ b/development/export_models.py
@@ -0,0 +1,44 @@
+import torch
+from torch_em.util import load_model
+
+
+def export_sgn():
+    path = "/mnt/vast-nhr/projects/nim00007/data/moser/cochlea-lightsheet/trained_models/SGN/v2_cochlea_distance_unet_SGN_supervised_2025-05-27"  # noqa
+    model = load_model(path, device="cpu")
+    torch.save(model, "SGN.pt")
+
+
+def export_ihc():
+    path = "/mnt/vast-nhr/projects/nim00007/data/moser/cochlea-lightsheet/trained_models/IHC/v4_cochlea_distance_unet_IHC_supervised_2025-07-14"  # noqa
+    model = load_model(path, device="cpu")
+    torch.save(model, "IHC.pt")
+
+
+def export_synapses():
+    path = "/mnt/vast-nhr/projects/nim00007/data/moser/cochlea-lightsheet/trained_models/Synapses/synapse_detection_model_v3.pt"  # noqa
+    model = torch.load(path, map_location="cpu", weights_only=False)
+    torch.save(model, "Synapses.pt")
+
+
+def export_sgn_lowres():
+    path = "/mnt/vast-nhr/projects/nim00007/data/moser/cochlea-lightsheet/trained_models/SGN/cochlea_distance_unet_sgn-low-res-v4"  # noqa
+    model = load_model(path, device="cpu")
+    torch.save(model, "SGN-lowres.pt")
+
+
+def export_ihc_lowres():
+    path = "/mnt/vast-nhr/projects/nim00007/data/moser/cochlea-lightsheet/trained_models/IHC/cochlea_distance_unet_ihc-lowres-v3"  # noqa
+    model = load_model(path, device="cpu")
+    torch.save(model, "IHC-lowres.pt")
+
+
+def main():
+    # export_sgn()
+    # export_ihc()
+    # export_synapses()
+    export_sgn_lowres()
+    # export_ihc_lowres()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/doc/documentation.md b/doc/documentation.md
index 93be49c..5e38789 100644
--- a/doc/documentation.md
+++ b/doc/documentation.md
@@ -1,6 +1,6 @@
 # CochleaNet
 
-CochleaNet is a software tool for the analysis of cochleae imaged in light-sheet microscopy.
+CochleaNet is a tool for the analysis of cochleae imaged in light-sheet microscopy.
 Its main components are:
 - A deep neural network for segmenting spiral ganglion neurons (SGNs) from parvalbumin (PV) staining.
 - A deep neural network for segmenting inner hair cells (IHCs) from VGlut3 staining.
@@ -12,11 +12,12 @@ In addition, it contains functionality for data pre-processing and different kin
 - Analyzing SGN subtypes (based on additional fluorescent staining).
 - Visualizing segmentation results and derived analyses in [MoBIE](https://mobie.github.io/).
 
-The networks and analysis methods were primarily developed for high-resolution isotropic data from a [custom light-sheet microscope](https://www.biorxiv.org/content/10.1101/2025.02.21.639411v2.abstract).
-The networks will work best on the respective fluorescent stains they were trained on, but will work on similar stains. For example, we have successfully applied the network for SGN segmentation on a calretinin (CR) stain and the network for IHC segmentation on a myosin7a stain. 
+The networks and analysis methods were primarily developed for high-resolution isotropic data from a [custom light-sheet microscope](https://www.nature.com/articles/s41587-025-02882-8).
+The networks work best for the respective fluorescent stains they were trained on, but will work for similar stains.
+For example, we have successfully applied the network for SGN segmentation on a calretinin (CR) stain and the network for IHC segmentation on a Myosin VII A stain. 
 In addition, CochleaNet provides networks for the segmentation of SGNs and IHCs in anisotropic data from a [commercial light-sheet microscope](https://www.miltenyibiotec.com/DE-en/products/macs-imaging-and-spatial-biology/ultramicroscope-platform.html).
 
-For more information on CochleaNet, check out our [preprint](TODO).
+For more information on CochleaNet, check out our [preprint](https://doi.org/10.1101/2025.11.16.688700).
 
 ## Installation
 
@@ -54,20 +55,20 @@ CochleaNet can be used via:
 - The [command line interface](#command-line-interface): enables data conversion, model prediction, and selected analysis workflows for large image data.
 - The [python library](#python-library): implements CochleaNet's functionality and can be used to implement flexible prediction and data analysis workflows for large image data. 
 
-**Note: the napari plugin was not optimized for processing large data. For processing large image data use the CLI or python library.**
+**Note: the napari plugin was not optimized for processing large data. Please use the CLI or python library for processing large data.**
 
 ### Napari Plugin
 
-The napari plugin for segmentation (SGNs and IHCS) and detection (ribbon synapses) is available under `Plugins->CochleaNet->Segmentation/Detection` in napari:
+The plugins for segmentation (SGNs and IHCS) and detection (ribbon synapses) is available under `Plugins->CochleaNet->Segmentation/Detection` in napari:
 
-The segmentation plugin offers the choice of different models under `Select Model:` (see [Available Models](#available-models) for details). `Image data` enables to choose which image data (layer) the model is applied to. The segmentation is started by clicking the `Run Segmentation` button. After the segmentation has finished, a new segmentation layer with the result (here `IHC`) will be added:
+The segmentation plugin offers the choice of different models under `Select Model:` (see [Available Models](#available-models) for details). `Image data` enables the choice which image data (napari layer) the model is applied to.
+The segmentation is started by clicking the `Run Segmentation` button. After the segmentation has finished, a new segmentation layer with the result (here `IHC`) will be added:
 
-The detection model works similarly. It currently provides the model for synapse detection. The predictions are added as point layer (``):
+The detection model works similarly. It currently provides the model for synapse detection. The predictions are added as a point layer (``):
 
-TODO Video.
-For more information on how to use napari, check out the tutorials at [www.napari.org](TODO).
+For more information on how to use napari, check out the tutorials at [www.napari.org](https://napari.org/stable/).
 
-**To use the napari plugin you have to install `napari` and `pyqt` in your environment.** See [installation](#installation) for details.
+**To use the napari plugin you have to install `napari` and `pyqt` in your environment. See [installation](#installation) for details.**
 
 ### Command Line Interface
 
diff --git a/doc/img/cochlea-net-plugin-detection.png b/doc/img/cochlea-net-plugin-detection.png
new file mode 100644
index 0000000..21da28b
Binary files /dev/null and b/doc/img/cochlea-net-plugin-detection.png differ
diff --git a/doc/img/cochlea-net-plugin-segmentation.png b/doc/img/cochlea-net-plugin-segmentation.png
new file mode 100644
index 0000000..f5fc3c4
Binary files /dev/null and b/doc/img/cochlea-net-plugin-segmentation.png differ
diff --git a/doc/img/cochlea-net-plugin-selection.png b/doc/img/cochlea-net-plugin-selection.png
new file mode 100644
index 0000000..53808ac
Binary files /dev/null and b/doc/img/cochlea-net-plugin-selection.png differ
diff --git a/flamingo_tools/model_utils.py b/flamingo_tools/model_utils.py
index e1cd13c..32363e4 100644
--- a/flamingo_tools/model_utils.py
+++ b/flamingo_tools/model_utils.py
@@ -59,14 +59,14 @@ def get_model_registry() -> None:
     """
     registry = {
         "SGN": "3058690b49015d6210a8e8414eb341c34189fee660b8fac438f1fdc41bdfff98",
-        "IHC": "89afbcca08ed302aa6dfbaba5bf2530fc13339c05a604b6f2551d97cf5f12774",
+        "IHC": "752dab7995b076ec4b8526b0539d1b33ade5de9251aaf6863d9bd8cc9cd036b6",
         "Synapses": "2a42712b056f082b4794f15cf41b15678aab0bec1acc922ff9f0dc76abe6747e",
         "SGN-lowres": "6accba4b4c65158fccf25623dcd0fb3b14203305d033a0d443a307114ec5dd8c",
         "IHC-lowres": "537f1d4afc5a582771b87adeccadfa5635e1defd13636702363992188ef5bdbd",
     }
     urls = {
         "SGN": "https://owncloud.gwdg.de/index.php/s/NZ2vv7hxX1imITG/download",
-        "IHC": "https://owncloud.gwdg.de/index.php/s/GBBJkPQFraz1ZzU/download",
+        "IHC": "https://owncloud.gwdg.de/index.php/s/wB7d2MjV5LRTP06/download",
         "Synapses": "https://owncloud.gwdg.de/index.php/s/A9W5NmOeBxiyZgY/download",
         "SGN-lowres": "https://owncloud.gwdg.de/index.php/s/8hwZjBVzkuYhHLm/download",
         "IHC-lowres": "https://owncloud.gwdg.de/index.php/s/EhnV4brhpvFbSsy/download",
@@ -148,12 +148,10 @@ def get_default_tiling() -> Dict[str, Dict[str, int]]:
         tiling = {"tile": tile, "halo": halo}
         print(f"Determined tile size for MPS: {tiling}")
 
-    # I am not sure what is reasonable on a cpu. For now choosing very small tiling.
-    # (This will not work well on a CPU in any case.)
     else:
         tiling = {
-            "tile": {"x": 96, "y": 96, "z": 16},
-            "halo": {"x": 16, "y": 16, "z": 8},
+            "tile": {"x": 64, "y": 64, "z": 64},
+            "halo": {"x": 32, "y": 32, "z": 16},
         }
         print(f"Determining default tiling for CPU: {tiling}")
 
diff --git a/flamingo_tools/segmentation/cli.py b/flamingo_tools/segmentation/cli.py
new file mode 100644
index 0000000..3dd445b
--- /dev/null
+++ b/flamingo_tools/segmentation/cli.py
@@ -0,0 +1,192 @@
+"""private
+"""
+import argparse
+
+from .unet_prediction import run_unet_prediction
+from .synapse_detection import marker_detection
+from ..model_utils import get_model_path
+
+
+def _get_model_path(model_type, checkpoint_path=None):
+    if checkpoint_path is None:
+        model_path = get_model_path(model_type)
+    else:
+        model_path = checkpoint_path
+    return model_path
+
+
+def _parse_kwargs(extra_kwargs, **default_kwargs):
+    def _convert_argval(value):
+        # The values for the parsed arguments need to be in the expected input structure as provided.
+        # i.e. integers and floats should be in their original types.
+        try:
+            return int(value)
+        except ValueError:
+            return float(value)
+
+    extra_kwargs = {
+        extra_kwargs[i].lstrip("--"): _convert_argval(extra_kwargs[i + 1]) for i in range(0, len(extra_kwargs), 2)
+    }
+
+    known_kwargs, unknown_kwargs = {}, {}
+    for name, val in extra_kwargs.items():
+        if name in default_kwargs:
+            known_kwargs[name] = val
+        else:
+            unknown_kwargs[name] = val
+
+    missing_default_kwargs = {name: val for name, val in default_kwargs.items() if name not in known_kwargs}
+    if unknown_kwargs:
+        raise ValueError(
+            f"The following options are not supported: {list(unknown_kwargs.keys())}."
+            f"Did you mean any of the following additional options: {list(missing_default_kwargs.keys())}?"
+        )
+
+    known_kwargs.update(missing_default_kwargs)
+    return known_kwargs
+
+
+def _parse_segmentation_kwargs(extra_kwargs, model_type):
+    if model_type.startswith("SGN"):
+        default_kwargs = {
+            "center_distance_threshold": 0.4,
+            "boundary_distance_threshold": 0.5,
+            "fg_threshold": 0.5,
+            "distance_smoothing": 0.0,
+            "seg_class": "sgn_low" if model_type == "SGN-lowres" else "sgn",
+        }
+    else:
+        assert model_type.startswith("IHC")
+        default_kwargs = {
+            "center_distance_threshold": 0.5,
+            "boundary_distance_threshold": 0.6,
+            "fg_threshold": 0.5,
+            "distance_smoothing": 0.6,
+            "seg_class": "ihc",
+        }
+
+    kwargs = _parse_kwargs(extra_kwargs, **default_kwargs)
+    return kwargs
+
+
+def run_segmentation():
+    """private
+    """
+    segmentation_models = ["SGN", "IHC", "SGN-lowres", "IHC-lowres"]
+
+    parser = argparse.ArgumentParser(
+        description="Segment individual cells in volumetric light microscopy data. "
+        "This function supports the segmentation of SGNs and IHCs, at high- and low-resolution. "
+        "Which model to use is specified with the argument '--model_type' ('-m'). "
+        "It also supports custom models via the (optional) argument '--checkpoint_path' ('-c'). "
+    )
+    parser.add_argument(
+        "-i", "--input_path", required=True,
+        help="The path to the input data. Supports .tif, .zarr, .h5 or .n5 files. "
+        "Zarr, HDF5 or N5 files also require the 'input_key' argument."
+    )
+    parser.add_argument(
+        "-k", "--input_key",
+        help="The key to the input data. This refers to an internal data path for Zarr, HDF5 or N5 data."
+    )
+    parser.add_argument(
+        "-o", "--output_folder", required=True,
+        help="The output folder where the segmentation result and intermediates are stored. "
+        "The segmentation result is stored in the file 'segmentation.zarr' under the key 'segmentation'."
+    )
+    parser.add_argument(
+        "-m", "--model_type", required=True,
+        help=f"The model to use for segmentation. One of {segmentation_models}.",
+    )
+    parser.add_argument(
+        "-c", "--checkpoint_path",
+        help="Path to the checkpoint of a customly fine-tuned model (optional).",
+    )
+    parser.add_argument(
+        "--min_size", type=int, default=250,
+        help="The minimum size of cells in the resulting segmentation.",
+    )
+    parser.add_argument(
+        "--disable_masking", action="store_true",
+        help="Whether to disable intensity-based masking. By default, "
+        "segmentation is only applied for parts of the data with foreground signal."
+    )
+    args, extra_kwargs = parser.parse_known_args()
+
+    if args.model_type not in segmentation_models:
+        raise ValueError(f"Unknown model: {args.model_type}. Choose one of {segmentation_models}.")
+    segmentation_kwargs = _parse_segmentation_kwargs(extra_kwargs, args.model_type)
+
+    model_path = _get_model_path(args.model_type, args.checkpoint_path)
+    run_unet_prediction(
+        input_path=args.input_path, input_key=args.input_key,
+        output_folder=args.output_folder, model_path=model_path,
+        min_size=args.min_size, use_mask=args.disable_masking,
+        **segmentation_kwargs,
+    )
+
+
+def run_detection():
+    """private
+    """
+    detection_models = ["Synapses"]
+
+    parser = argparse.ArgumentParser(
+        description="Detect spot intensity signals in volumetric light microscopy data. "
+        "This function supports the detection of synapses in high-resolution light-microscopy data. "
+        "It also supports custom models via the (optional) argument '--checkpoint_path' ('-c'). "
+    )
+    parser.add_argument(
+        "-i", "--input_path", required=True,
+        help="The path to the input data. Supports .tif, .zarr, .h5 or .n5 files."
+        "Zarr, HDF5 or N5 files also require the 'input_key' argument."
+    )
+    parser.add_argument(
+        "-k", "--input_key",
+        help="The key to the input data. This refers to an internal data path for Zarr, HDF5 or N5 data."
+    )
+    parser.add_argument(
+        "-o", "--output_folder", required=True,
+        help="The output folder where the detectio result and intermediates are stored. "
+        "The result is stored in the file 'synapse_detection.tsv'. "
+        "In case detections are assigned to segmentation masks and filtered (via '--mask_path' and '--mask_key'), "
+        "the corresponding results are stored in 'synapse_detection_filtered.tsv'."
+
+    )
+    parser.add_argument(
+        "-m", "--model_type", default="Synapses",
+        help=f"The model to use for detection. One of {detection_models}.",
+    )
+    parser.add_argument(
+        "-c", "--checkpoint_path",
+        help="Path to the checkpoint of a customly fine-tuned model (optional).",
+    )
+    parser.add_argument(
+        "--mask_path",
+        help="Path to a segmentation mask to use for assigning and filtering the detected synapses (optional). "
+        "If given, each detected synapse will be assigned to the closest object in the segmentation and "
+        "synapses that are more distant than 'max_distance' will be removed from the result."
+    )
+    parser.add_argument(
+        "--mask_key",
+        help="The key to the mask data. Refers to an internal data path, see '--input_key' ('-k') for details."
+    )
+    parser.add_argument(
+        "--max_distance", type=float, default=2.0,
+        help="The maximal distance (in microns) for matching synapses to segmented cells. "
+        "Synapses with a larger distance will be filtered from the result."
+    )
+    parser.add_argument(
+        "--resolution", type=float, default=0.38, help="The resolution of the data (in microns)."
+    )
+    args = parser.parse_args()
+    if args.model_type not in detection_models:
+        raise ValueError(f"Unknown model: {args.model_type}. Choose one of {detection_models}.")
+
+    model_path = _get_model_path(args.model_type, args.checkpoint_path)
+    marker_detection(
+        input_path=args.input_path, input_key=args.input_key,
+        output_folder=args.output_folder, model_path=model_path,
+        mask_path=args.mask_path, mask_input_key=args.mask_key,
+        max_distance=args.max_distance, resolution=args.resolution,
+    )
diff --git a/flamingo_tools/segmentation/synapse_detection.py b/flamingo_tools/segmentation/synapse_detection.py
index 4a12e8d..a209c1c 100644
--- a/flamingo_tools/segmentation/synapse_detection.py
+++ b/flamingo_tools/segmentation/synapse_detection.py
@@ -119,10 +119,10 @@ def run_prediction(
 def marker_detection(
     input_path: str,
     input_key: str,
-    mask_path: str,
+    mask_path: Optional[str],
     output_folder: str,
     model_path: str,
-    mask_input_key: str = "s4",
+    mask_input_key: Optional[str] = "s4",
     max_distance: float = 20,
     resolution: float = 0.38,
 ):
@@ -143,13 +143,12 @@ def marker_detection(
     # Best approach: load IHC segmentation at a low scale level, binarize it,
     # dilate it and use this as mask. It can be mapped back to the full resolution
     # with `elf.wrapper.ResizedVolume`.
-
     skip_masking = False
 
     mask_preprocess_key = "mask"
     output_file = os.path.join(output_folder, "mask.zarr")
 
-    if os.path.exists(output_file) and mask_preprocess_key in zarr.open(output_file, "r"):
+    if mask_path is None or (os.path.exists(output_file) and mask_preprocess_key in zarr.open(output_file, "r")):
         skip_masking = True
 
     if not skip_masking:
@@ -162,11 +161,6 @@ def marker_detection(
             f_out.create_dataset(mask_preprocess_key, data=arr_bin, compression="gzip")
 
     # 2.) Run inference and detection of maxima.
-    # This can be taken from 'scripts/synapse_marker_detection/run_prediction.py'
-    # (And the run prediction script should then be refactored).
-
-    block_shape = (64, 256, 256)
-    halo = (16, 64, 64)
 
     # Skip existing prediction, which is saved in output_folder/predictions.zarr
     skip_prediction = False
@@ -183,11 +177,12 @@ def marker_detection(
     if not skip_prediction:
         prediction_impl(
             input_path, input_key, output_folder, model_path,
-            scale=None, block_shape=block_shape, halo=halo,
-            apply_postprocessing=False, output_channels=1,
+            scale=None, apply_postprocessing=False, output_channels=1,
+            block_shape=None, halo=None,
         )
 
     if not os.path.exists(detection_path):
+        block_shape = (64, 256, 256)
         input_ = zarr.open(output_path, "r")[prediction_key]
         detections = find_local_maxima(
             input_, block_shape=block_shape, min_distance=2, threshold_abs=0.5, verbose=True, n_threads=16,
@@ -200,25 +195,25 @@ def marker_detection(
         detections.to_csv(detection_path, index=False, sep="\t")
 
     else:
-        with open(detection_path, 'r') as f:
+        with open(detection_path, "r") as f:
             detections = pd.read_csv(f, sep="\t")
 
     # 3.) Map the detections to IHC and filter them based on a distance criterion.
     # Use the function 'map_and_filter_detections' from above.
-    input_ = read_image_data(mask_path, input_key)
-
-    detections_filtered = map_and_filter_detections(
-        segmentation=input_,
-        detections=detections,
-        max_distance=max_distance,
-        resolution=resolution,
-    )
+    if mask_path is not None:
+        input_ = read_image_data(mask_path, input_key)
+        detections_filtered = map_and_filter_detections(
+            segmentation=input_,
+            detections=detections,
+            max_distance=max_distance,
+            resolution=resolution,
+        )
 
-    # 4.) Add the filtered detections to MoBIE.
-    # IMPORTANT scale the coordinates with the resolution here.
-    detections_filtered["distance_to_ihc"] *= resolution
-    detections_filtered["x"] *= resolution
-    detections_filtered["y"] *= resolution
-    detections_filtered["z"] *= resolution
-    detection_path = os.path.join(output_folder, "synapse_detection_filtered.tsv")
-    detections_filtered.to_csv(detection_path, index=False, sep="\t")
+        # 4.) Add the filtered detections to MoBIE.
+        # IMPORTANT scale the coordinates with the resolution here.
+        detections_filtered["distance_to_ihc"] *= resolution
+        detections_filtered["x"] *= resolution
+        detections_filtered["y"] *= resolution
+        detections_filtered["z"] *= resolution
+        detection_path = os.path.join(output_folder, "synapse_detection_filtered.tsv")
+        detections_filtered.to_csv(detection_path, index=False, sep="\t")
diff --git a/flamingo_tools/segmentation/unet_prediction.py b/flamingo_tools/segmentation/unet_prediction.py
index 19bd4c5..d00db73 100644
--- a/flamingo_tools/segmentation/unet_prediction.py
+++ b/flamingo_tools/segmentation/unet_prediction.py
@@ -55,6 +55,21 @@ def ndim(self):
         return self._volume.ndim - 1
 
 
+def _get_device_and_tiling(block_shape, halo, input_):
+    have_cuda = torch.cuda.is_available()
+    if block_shape is None:
+        block_shape = (128, 128, 128) if have_cuda else getattr(input_, "chunks", (64, 64, 64))
+    if halo is None:
+        halo = (16, 32, 32)
+    if have_cuda:
+        print("Predict with GPU")
+        gpu_ids = [0]
+    else:
+        print("Predict with CPU")
+        gpu_ids = ["cpu"]
+    return gpu_ids, block_shape, halo
+
+
 def prediction_impl(
     input_path,
     input_key,
@@ -109,19 +124,6 @@ def prediction_impl(
         input_ = ResizedVolume(input_, shape=new_shape, order=3)
         image_mask = ResizedVolume(image_mask, new_shape, order=0)
 
-    have_cuda = torch.cuda.is_available()
-
-    if block_shape is None:
-        block_shape = (128, 128, 128) if have_cuda else input_.chunks
-    if halo is None:
-        halo = (16, 32, 32)
-    if have_cuda:
-        print("Predict with GPU")
-        gpu_ids = [0]
-    else:
-        print("Predict with CPU")
-        gpu_ids = ["cpu"]
-
     if mean is None or std is None:
         # Compute the global mean and standard deviation.
         n_threads = min(16, mp.cpu_count())
@@ -147,6 +149,9 @@ def postprocess(x):
     else:
         postprocess = None if output_channels > 1 else lambda x: x.squeeze()
 
+    gpu_ids, block_shape, halo = _get_device_and_tiling(block_shape, halo, input_)
+    shape = input_.shape
+    ndim = len(shape)
     if output_channels > 1:
         output_shape = (output_channels,) + input_.shape
         output_chunks = (1,) + block_shape
@@ -154,9 +159,6 @@ def postprocess(x):
         output_shape = input_.shape
         output_chunks = block_shape
 
-    shape = input_.shape
-    ndim = len(shape)
-
     blocking = nt.blocking([0] * ndim, shape, block_shape)
     n_blocks = blocking.numberOfBlocks
     if prediction_instances != 1:
diff --git a/setup.py b/setup.py
index 4480d02..82d4222 100644
--- a/setup.py
+++ b/setup.py
@@ -10,7 +10,10 @@
     license="MIT",
     entry_points={
         "console_scripts": [
-            "convert_flamingo = flamingo_tools.data_conversion:convert_lightsheet_to_bdv_cli"
+            "flamingo_tools.convert_data = flamingo_tools.data_conversion:convert_lightsheet_to_bdv_cli",
+            "flamingo_tools.run_segmentation = flamingo_tools.segmentation.cli:run_segmentation",
+            "flamingo_tools.run_detection = flamingo_tools.segmentation.cli:run_detection",
+            # TODO: MoBIE conversion, tonotopic mapping
         ],
         "napari.manifest": [
             "cochlea_net = flamingo_tools:napari.yaml",
diff --git a/test/test_cli.py b/test/test_cli.py
index 445a064..3cb3ec1 100644
--- a/test/test_cli.py
+++ b/test/test_cli.py
@@ -1,4 +1,5 @@
 import os
+import platform
 import unittest
 from shutil import rmtree
 
@@ -7,6 +8,7 @@
 from subprocess import run
 
 
+@unittest.skipIf(platform.system() == "Windows", "CLI tests fail on windows.")
 class TestCLI(unittest.TestCase):
     folder = "./tmp"
 
@@ -19,9 +21,9 @@ def setUp(self):
     def tearDown(self):
         rmtree(self.folder)
 
-    def test_convert_flamingo(self):
+    def test_convert_data(self):
         out_path = os.path.join(self.folder, "converted_data.n5")
-        cmd = ["convert_flamingo", "-i", self.folder, "-o", out_path, "--metadata_pattern", ""]
+        cmd = ["flamingo_tools.convert_data", "-i", self.folder, "-o", out_path, "--metadata_pattern", ""]
         run(cmd)
 
         self.assertTrue(os.path.exists(out_path))
diff --git a/test/test_segmentation/test_cli.py b/test/test_segmentation/test_cli.py
new file mode 100644
index 0000000..b850226
--- /dev/null
+++ b/test/test_segmentation/test_cli.py
@@ -0,0 +1,54 @@
+import os
+import platform
+import subprocess
+import tempfile
+import unittest
+
+import imageio.v3 as imageio
+import numpy as np
+import z5py
+
+
+@unittest.skipIf(platform.system() == "Windows", "CLI tests fail on windows.")
+class TestSegmentationCLI(unittest.TestCase):
+    shape = (64, 128, 128)
+
+    def _create_data(self, tmp_dir):
+        data = np.random.randint(0, 255, size=self.shape)
+        path = os.path.join(tmp_dir, "data.tif")
+        imageio.imwrite(path, data)
+        return path
+
+    def test_run_segmentation(self):
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            data_path = self._create_data(tmp_dir)
+            output_folder = os.path.join(tmp_dir, "output")
+
+            subprocess.run([
+                "flamingo_tools.run_segmentation",
+                "-i", data_path, "-o", output_folder, "-m", "SGN", "--min_size", "0"
+            ])
+
+            expected_path = os.path.join(output_folder, "segmentation.zarr")
+            expected_key = "segmentation"
+
+            self.assertTrue(os.path.exists(expected_path))
+            with z5py.File(expected_path, "r") as f:
+                self.assertTrue(expected_key in f)
+                self.assertEqual(f[expected_key].shape, self.shape)
+
+    def test_run_detection(self):
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            data_path = self._create_data(tmp_dir)
+            output_folder = os.path.join(tmp_dir, "output")
+
+            subprocess.run([
+                "flamingo_tools.run_detection", "-i", data_path, "-o", output_folder
+            ])
+
+            expected_path = os.path.join(output_folder, "synapse_detection.tsv")
+            self.assertTrue(os.path.exists(expected_path))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_validation.py b/test/test_validation.py
index 4bf67fd..37dc241 100644
--- a/test/test_validation.py
+++ b/test/test_validation.py
@@ -30,7 +30,7 @@ def test_compute_scores_for_annotated_slice_2d(self):
 
         properties = ("label", "centroid")
         annotations = regionprops_table(segmentation, properties=properties)
-        annotations = pd.DataFrame(annotations).rename(columns={"centroid-0": "axis-0", "centroid-1": "axis-1"})
+        annotations = pd.DataFrame(annotations).rename(columns={"centroid-0": "axis-1", "centroid-1": "axis-2"})
         annotations = annotations.drop(columns="label")
 
         result = compute_scores_for_annotated_slice(segmentation, annotations)