diff --git a/CHANGELOG.md b/CHANGELOG.md
index 220209251b6..99238cb93a9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## Unreleased
 
+### Added
+
+- LI-COR Odyssey Classic (model 9120) infrared imaging system at `pylabrobot.li_cor.odyssey`
+- `Scanning`, `ImageRetrieval`, and `InstrumentStatus` capabilities at `pylabrobot.capabilities.scanning.*`
+- `DeviceCard` class and `HasDeviceCard` mixin at `pylabrobot.device_card` for instrument identity / provenance metadata (model-base + per-instance two-tier cards)
+
 ## 0.2.1
 
 ### Added
diff --git a/mypy.ini b/mypy.ini
index 614e3886553..a6ac770eddb 100644
--- a/mypy.ini
+++ b/mypy.ini
@@ -21,3 +21,6 @@ ignore_missing_imports = True
 
 [mypy-opentrons_shared_data.*]
 ignore_missing_imports = True
+
+[mypy-aiohttp.*]
+ignore_missing_imports = True
diff --git a/pylabrobot/capabilities/scanning/__init__.py b/pylabrobot/capabilities/scanning/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/pylabrobot/capabilities/scanning/image_retrieval/__init__.py b/pylabrobot/capabilities/scanning/image_retrieval/__init__.py
new file mode 100644
index 00000000000..3a7d56f2a7e
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/image_retrieval/__init__.py
@@ -0,0 +1,2 @@
+from .backend import ImageRetrievalBackend, ImageRetrievalError
+from .image_retrieval import ImageRetrieval
diff --git a/pylabrobot/capabilities/scanning/image_retrieval/backend.py b/pylabrobot/capabilities/scanning/image_retrieval/backend.py
new file mode 100644
index 00000000000..f6f82ae01ac
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/image_retrieval/backend.py
@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from typing import List
+
+from pylabrobot.capabilities.capability import CapabilityBackend
+
+
+class ImageRetrievalError(Exception):
+  """Capability-generic exception for image retrieval failures."""
+
+
+class ImageRetrievalBackend(CapabilityBackend, metaclass=ABCMeta):
+  """Abstract backend for the image retrieval capability.
+
+  Lists and downloads previously-acquired scans from instrument
+  storage. Independent of the scanning capability — scans persist
+  after the session that produced them, and lab users often retrieve
+  images they did not acquire themselves.
+  """
+
+  @abstractmethod
+  async def list_groups(self) -> List[str]:
+    """Return the names of scan groups available on the instrument."""
+
+  @abstractmethod
+  async def list_scans(self, group: str) -> List[str]:
+    """Return scan names within ``group``."""
+
+  @abstractmethod
+  async def download(self, group: str, scan_name: str) -> bytes:
+    """Download all channels for a scan, concatenated.
+
+    Vendors with multi-channel scans (e.g. Odyssey 700 / 800 nm) may
+    expose a ``download_channel`` extension on the concrete backend.
+    """
diff --git a/pylabrobot/capabilities/scanning/image_retrieval/image_retrieval.py b/pylabrobot/capabilities/scanning/image_retrieval/image_retrieval.py
new file mode 100644
index 00000000000..848c7a9935c
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/image_retrieval/image_retrieval.py
@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import logging
+from typing import List
+
+from pylabrobot.capabilities.capability import Capability, need_capability_ready
+
+from .backend import ImageRetrievalBackend
+
+logger = logging.getLogger(__name__)
+
+
+class ImageRetrieval(Capability):
+  """Image retrieval capability — list and download saved scans."""
+
+  def __init__(self, backend: ImageRetrievalBackend):
+    super().__init__(backend=backend)
+    self.backend: ImageRetrievalBackend = backend
+
+  @need_capability_ready
+  async def list_groups(self) -> List[str]:
+    """Return the names of scan groups available on the instrument."""
+    return await self.backend.list_groups()
+
+  @need_capability_ready
+  async def list_scans(self, group: str) -> List[str]:
+    """Return scan names within ``group``."""
+    return await self.backend.list_scans(group)
+
+  @need_capability_ready
+  async def download(self, group: str, scan_name: str) -> bytes:
+    """Download all channels for a scan, concatenated."""
+    return await self.backend.download(group, scan_name)
diff --git a/pylabrobot/capabilities/scanning/image_retrieval/image_retrieval_tests.py b/pylabrobot/capabilities/scanning/image_retrieval/image_retrieval_tests.py
new file mode 100644
index 00000000000..daa46153f69
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/image_retrieval/image_retrieval_tests.py
@@ -0,0 +1,64 @@
+"""Tests for ImageRetrieval."""
+
+import unittest
+from typing import Dict, List
+
+from pylabrobot.capabilities.scanning.image_retrieval.backend import (
+  ImageRetrievalBackend,
+)
+from pylabrobot.capabilities.scanning.image_retrieval.image_retrieval import (
+  ImageRetrieval,
+)
+
+
+class InMemoryImageRetrievalBackend(ImageRetrievalBackend):
+  """Backend that serves a pre-loaded in-memory store."""
+
+  def __init__(self, store: Dict[str, Dict[str, bytes]]):
+    self._store = store
+
+  async def list_groups(self) -> List[str]:
+    return list(self._store.keys())
+
+  async def list_scans(self, group: str) -> List[str]:
+    return list(self._store.get(group, {}).keys())
+
+  async def download(self, group: str, scan_name: str) -> bytes:
+    return self._store[group][scan_name]
+
+
+class TestImageRetrieval(unittest.IsolatedAsyncioTestCase):
+  async def asyncSetUp(self):
+    self.store = {
+      "odyssey": {"scan_a": b"AAAA", "scan_b": b"BBBB"},
+      "public": {"shared": b"CCCC"},
+    }
+    self.backend = InMemoryImageRetrievalBackend(self.store)
+    self.cap = ImageRetrieval(backend=self.backend)
+    await self.cap._on_setup()
+
+  async def test_list_groups(self):
+    self.assertEqual(sorted(await self.cap.list_groups()), ["odyssey", "public"])
+
+  async def test_list_scans(self):
+    self.assertEqual(
+      sorted(await self.cap.list_scans("odyssey")),
+      ["scan_a", "scan_b"],
+    )
+    self.assertEqual(await self.cap.list_scans("missing"), [])
+
+  async def test_download(self):
+    self.assertEqual(await self.cap.download("odyssey", "scan_a"), b"AAAA")
+    self.assertEqual(await self.cap.download("public", "shared"), b"CCCC")
+
+  async def test_methods_require_setup(self):
+    backend = InMemoryImageRetrievalBackend({})
+    cap = ImageRetrieval(backend=backend)
+    with self.assertRaises(RuntimeError):
+      await cap.list_groups()
+    with self.assertRaises(RuntimeError):
+      await cap.download("g", "s")
+
+
+if __name__ == "__main__":
+  unittest.main()
diff --git a/pylabrobot/capabilities/scanning/instrument_status/__init__.py b/pylabrobot/capabilities/scanning/instrument_status/__init__.py
new file mode 100644
index 00000000000..f17ef263cbc
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/instrument_status/__init__.py
@@ -0,0 +1,3 @@
+from .backend import InstrumentStatusBackend, InstrumentStatusError
+from .instrument_status import InstrumentStatus
+from .standard import InstrumentStatusReading
diff --git a/pylabrobot/capabilities/scanning/instrument_status/backend.py b/pylabrobot/capabilities/scanning/instrument_status/backend.py
new file mode 100644
index 00000000000..254ed6ca970
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/instrument_status/backend.py
@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+
+from pylabrobot.capabilities.capability import CapabilityBackend
+
+from .standard import InstrumentStatusReading
+
+
+class InstrumentStatusError(Exception):
+  """Capability-generic exception for instrument status read failures."""
+
+
+class InstrumentStatusBackend(CapabilityBackend, metaclass=ABCMeta):
+  """Abstract backend for instrument status polling."""
+
+  @abstractmethod
+  async def read_status(self) -> InstrumentStatusReading:
+    """Return the current instrument status snapshot."""
diff --git a/pylabrobot/capabilities/scanning/instrument_status/instrument_status.py b/pylabrobot/capabilities/scanning/instrument_status/instrument_status.py
new file mode 100644
index 00000000000..f3535874272
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/instrument_status/instrument_status.py
@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import logging
+
+from pylabrobot.capabilities.capability import Capability, need_capability_ready
+
+from .backend import InstrumentStatusBackend
+from .standard import InstrumentStatusReading
+
+logger = logging.getLogger(__name__)
+
+
+class InstrumentStatus(Capability):
+  """Instrument status capability — poll the device's state machine."""
+
+  def __init__(self, backend: InstrumentStatusBackend):
+    super().__init__(backend=backend)
+    self.backend: InstrumentStatusBackend = backend
+
+  @need_capability_ready
+  async def read_status(self) -> InstrumentStatusReading:
+    """Return the current instrument status snapshot."""
+    return await self.backend.read_status()
diff --git a/pylabrobot/capabilities/scanning/instrument_status/instrument_status_tests.py b/pylabrobot/capabilities/scanning/instrument_status/instrument_status_tests.py
new file mode 100644
index 00000000000..cb9403c4ff4
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/instrument_status/instrument_status_tests.py
@@ -0,0 +1,63 @@
+"""Tests for InstrumentStatus."""
+
+import unittest
+
+from pylabrobot.capabilities.scanning.instrument_status.backend import (
+  InstrumentStatusBackend,
+)
+from pylabrobot.capabilities.scanning.instrument_status.instrument_status import (
+  InstrumentStatus,
+)
+from pylabrobot.capabilities.scanning.instrument_status.standard import (
+  InstrumentStatusReading,
+)
+
+
+class StubInstrumentStatusBackend(InstrumentStatusBackend):
+  """Backend that returns a fixed reading and counts calls."""
+
+  def __init__(self, reading: InstrumentStatusReading):
+    self.reading = reading
+    self.call_count = 0
+
+  async def read_status(self) -> InstrumentStatusReading:
+    self.call_count += 1
+    return self.reading
+
+
+class TestInstrumentStatus(unittest.IsolatedAsyncioTestCase):
+  async def asyncSetUp(self):
+    self.reading = InstrumentStatusReading(
+      state="Scanning",
+      current_user="alice",
+      progress=37.5,
+      time_remaining="2 minutes",
+      lid_open=False,
+    )
+    self.backend = StubInstrumentStatusBackend(self.reading)
+    self.cap = InstrumentStatus(backend=self.backend)
+    await self.cap._on_setup()
+
+  async def test_read_status_returns_backend_reading(self):
+    result = await self.cap.read_status()
+    self.assertIs(result, self.reading)
+    self.assertEqual(self.backend.call_count, 1)
+
+  async def test_read_status_passes_through_fields(self):
+    result = await self.cap.read_status()
+    self.assertEqual(result.state, "Scanning")
+    self.assertEqual(result.current_user, "alice")
+    self.assertEqual(result.progress, 37.5)
+    self.assertEqual(result.time_remaining, "2 minutes")
+    self.assertFalse(result.lid_open)
+
+  async def test_read_status_requires_setup(self):
+    backend = StubInstrumentStatusBackend(self.reading)
+    cap = InstrumentStatus(backend=backend)
+    with self.assertRaises(RuntimeError):
+      await cap.read_status()
+    self.assertEqual(backend.call_count, 0)
+
+
+if __name__ == "__main__":
+  unittest.main()
diff --git a/pylabrobot/capabilities/scanning/instrument_status/standard.py b/pylabrobot/capabilities/scanning/instrument_status/standard.py
new file mode 100644
index 00000000000..c99a95aa6ad
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/instrument_status/standard.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class InstrumentStatusReading:
+  """Generic instrument status snapshot.
+
+  Vendor backends populate the fields they have a value for; missing
+  fields keep their defaults.
+  """
+
+  state: str
+  current_user: str = ""
+  progress: float = 0.0
+  time_remaining: str = ""
+  lid_open: bool = False
diff --git a/pylabrobot/capabilities/scanning/scanning/__init__.py b/pylabrobot/capabilities/scanning/scanning/__init__.py
new file mode 100644
index 00000000000..74cea53ccfa
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/scanning/__init__.py
@@ -0,0 +1,2 @@
+from .backend import ScanningBackend, ScanningError
+from .scanning import Scanning
diff --git a/pylabrobot/capabilities/scanning/scanning/backend.py b/pylabrobot/capabilities/scanning/scanning/backend.py
new file mode 100644
index 00000000000..b55d7ebd021
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/scanning/backend.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from typing import Optional
+
+from pylabrobot.capabilities.capability import CapabilityBackend
+from pylabrobot.serializer import SerializableMixin
+
+
+class ScanningError(Exception):
+  """Capability-generic exception for scanning failures.
+
+  Vendor backends should raise a subclass that ALSO inherits from the
+  vendor's driver-level exception, so callers can catch on either axis
+  (capability-generic or vendor-specific).
+  """
+
+
+class ScanningBackend(CapabilityBackend, metaclass=ABCMeta):
+  """Abstract backend for the scanning capability.
+
+  Concrete backends configure and control flatbed-style fluorescence
+  / luminescence scans. The capability does not assume a plate or
+  well grid — Odyssey-style flatbed imagers and gel docs fit;
+  plate-aware microscopy belongs under :class:`Microscopy`.
+  """
+
+  @abstractmethod
+  async def configure(self, backend_params: Optional[SerializableMixin] = None) -> None:
+    """Set up the next scan with vendor-specific parameters."""
+
+  @abstractmethod
+  async def start(self) -> None:
+    """Begin acquisition. Backend must be configured first."""
+
+  @abstractmethod
+  async def stop(self) -> None:
+    """Graceful stop — finish current line, save partial output."""
+
+  @abstractmethod
+  async def pause(self) -> None:
+    """Pause acquisition. Resume by calling :meth:`start` again."""
+
+  @abstractmethod
+  async def cancel(self) -> None:
+    """Abort acquisition and discard any partial output."""
diff --git a/pylabrobot/capabilities/scanning/scanning/scanning.py b/pylabrobot/capabilities/scanning/scanning/scanning.py
new file mode 100644
index 00000000000..dde012bbeee
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/scanning/scanning.py
@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from pylabrobot.capabilities.capability import Capability, need_capability_ready
+from pylabrobot.serializer import SerializableMixin
+
+from .backend import ScanningBackend
+
+logger = logging.getLogger(__name__)
+
+
+class Scanning(Capability):
+  """Flatbed scanning capability — fluorescence / luminescence imager control."""
+
+  def __init__(self, backend: ScanningBackend):
+    super().__init__(backend=backend)
+    self.backend: ScanningBackend = backend
+
+  @need_capability_ready
+  async def configure(self, backend_params: Optional[SerializableMixin] = None) -> None:
+    """Set up the next scan with vendor-specific parameters."""
+    await self.backend.configure(backend_params=backend_params)
+
+  @need_capability_ready
+  async def start(self) -> None:
+    """Begin acquisition."""
+    await self.backend.start()
+
+  @need_capability_ready
+  async def stop(self) -> None:
+    """Graceful stop — finish current line, save partial output."""
+    await self.backend.stop()
+
+  @need_capability_ready
+  async def pause(self) -> None:
+    """Pause acquisition. Resume by calling :meth:`start` again."""
+    await self.backend.pause()
+
+  @need_capability_ready
+  async def cancel(self) -> None:
+    """Abort acquisition and discard any partial output."""
+    await self.backend.cancel()
diff --git a/pylabrobot/capabilities/scanning/scanning/scanning_tests.py b/pylabrobot/capabilities/scanning/scanning/scanning_tests.py
new file mode 100644
index 00000000000..1951af30cb1
--- /dev/null
+++ b/pylabrobot/capabilities/scanning/scanning/scanning_tests.py
@@ -0,0 +1,71 @@
+"""Tests for Scanning."""
+
+import unittest
+from typing import List, Optional, Tuple
+
+from pylabrobot.capabilities.scanning.scanning.backend import ScanningBackend
+from pylabrobot.capabilities.scanning.scanning.scanning import Scanning
+from pylabrobot.serializer import SerializableMixin
+
+
+class RecordingScanningBackend(ScanningBackend):
+  """Backend that records every call so tests can assert on the sequence."""
+
+  def __init__(self):
+    self.calls: List[Tuple[str, Optional[SerializableMixin]]] = []
+
+  async def configure(self, backend_params: Optional[SerializableMixin] = None) -> None:
+    self.calls.append(("configure", backend_params))
+
+  async def start(self) -> None:
+    self.calls.append(("start", None))
+
+  async def stop(self) -> None:
+    self.calls.append(("stop", None))
+
+  async def pause(self) -> None:
+    self.calls.append(("pause", None))
+
+  async def cancel(self) -> None:
+    self.calls.append(("cancel", None))
+
+
+class TestScanning(unittest.IsolatedAsyncioTestCase):
+  async def asyncSetUp(self):
+    self.backend = RecordingScanningBackend()
+    self.cap = Scanning(backend=self.backend)
+    await self.cap._on_setup()
+
+  async def test_configure_forwards_params(self):
+    sentinel = object()
+    await self.cap.configure(backend_params=sentinel)  # type: ignore[arg-type]
+    self.assertEqual(self.backend.calls, [("configure", sentinel)])
+
+  async def test_full_verb_sequence(self):
+    await self.cap.configure()
+    await self.cap.start()
+    await self.cap.pause()
+    await self.cap.cancel()
+    await self.cap.stop()
+    self.assertEqual(
+      [name for name, _ in self.backend.calls],
+      ["configure", "start", "pause", "cancel", "stop"],
+    )
+
+  async def test_setup_finished_flag(self):
+    self.assertTrue(self.cap.setup_finished)
+    await self.cap._on_stop()
+    self.assertFalse(self.cap.setup_finished)
+
+  async def test_methods_require_setup(self):
+    backend = RecordingScanningBackend()
+    cap = Scanning(backend=backend)
+    with self.assertRaises(RuntimeError):
+      await cap.start()
+    with self.assertRaises(RuntimeError):
+      await cap.configure()
+    self.assertEqual(backend.calls, [])
+
+
+if __name__ == "__main__":
+  unittest.main()
diff --git a/pylabrobot/device_card.py b/pylabrobot/device_card.py
new file mode 100644
index 00000000000..0846de924e1
--- /dev/null
+++ b/pylabrobot/device_card.py
@@ -0,0 +1,165 @@
+"""DeviceCard — machine-readable device description.
+
+A :class:`DeviceCard` is a metadata bag attached to a :class:`Device`.
+It carries:
+
+- **Identity** — persistent identifier (e.g. PIDInst Handle URI),
+  landing page, friendly name. Empty in the model-base card; each
+  deployment populates it with its own unit's identity.
+- **Capability specs** — operating ranges, supported settings, and
+  feature flags pulled from the operator's manual. Lets UIs and
+  validators reason about what a unit can actually do.
+- **Connection metadata** — protocol, port, auth method, discovery
+  mechanism. Configuration the model defines once, used by every
+  deployment.
+
+Two-tier design::
+
+    base = ODYSSEY_CLASSIC_BASE                 # ships with the device package
+    instance = DeviceCard.instance(identity={   # per-deployment
+        "pid": "http://hdl.handle.net/21.11157/psf97-zv353",
+        "landing_page": "https://b2inst.gwdg.de/records/psf97-zv353",
+        "name": "Odyssey, Lab 3 (WUR HAP)",
+    })
+    card = base.merge(instance)                 # effective deployed card
+
+Devices that carry a card declare the :class:`HasDeviceCard` mixin so
+the attribute is discoverable via type checks. Tooling that consumes
+identity (TIFF tagging, provenance writers, dataset registration) can
+duck-type ``hasattr(device, "card")`` or rely on the mixin.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class DeviceCard:
+  """Machine-readable device description with merge and introspection.
+
+  Fields:
+    name: Friendly model name (e.g. "Odyssey Classic").
+    vendor: Vendor name (e.g. "LI-COR Biosciences").
+    model: Model number / SKU (e.g. "9120").
+    capabilities: Per-capability spec sheet — keys are capability
+      names (``"scanning"``, ``"image_retrieval"``), values are dicts
+      of features / specs / ranges.
+    connection: Connection metadata (protocol, port, auth, network).
+    identity: Per-unit identity — PID, landing page, friendly name.
+      Empty in the model-base card; populated at the instance layer.
+  """
+
+  name: str = ""
+  vendor: str = ""
+  model: str = ""
+  capabilities: dict[str, dict[str, Any]] = field(default_factory=dict)
+  connection: dict[str, Any] = field(default_factory=dict)
+  identity: dict[str, Any] = field(default_factory=dict)
+
+  @classmethod
+  def instance(cls, **kwargs: Any) -> "DeviceCard":
+    """Build a partial card for instance-level overrides.
+
+    Use when populating per-deployment identity (PID, landing page) or
+    overriding a model-base spec for a non-standard unit.
+    """
+    return cls(**kwargs)
+
+  def merge(self, other: "DeviceCard") -> "DeviceCard":
+    """Deep-merge ``other`` on top of ``self``. Returns a new card.
+
+    Merge rules:
+      - Scalar fields (name, vendor, model): ``other`` wins if non-empty.
+      - capabilities: per-capability shallow merge; ``other`` keys
+        override; new capabilities from ``other`` are added.
+      - connection, identity: shallow dict merge, ``other`` wins on key
+        collision.
+
+    Neither input is mutated.
+    """
+    merged_caps = copy.deepcopy(self.capabilities)
+    for cap_name, cap_data in other.capabilities.items():
+      if cap_name in merged_caps:
+        merged_caps[cap_name].update(cap_data)
+      else:
+        merged_caps[cap_name] = copy.deepcopy(cap_data)
+
+    return DeviceCard(
+      name=other.name or self.name,
+      vendor=other.vendor or self.vendor,
+      model=other.model or self.model,
+      capabilities=merged_caps,
+      connection={**self.connection, **other.connection},
+      identity={**self.identity, **other.identity},
+    )
+
+  def has(self, capability: str) -> bool:
+    """Return True if the card declares ``capability``."""
+    return capability in self.capabilities
+
+  def get(self, capability: str, key: str, default: Any = None) -> Any:
+    """Return a single feature / spec value for ``capability``."""
+    return self.capabilities.get(capability, {}).get(key, default)
+
+  def features(self, capability: str) -> dict[str, bool]:
+    """Return all boolean feature flags for ``capability``."""
+    cap = self.capabilities.get(capability, {})
+    return {k: v for k, v in cap.items() if isinstance(v, bool)}
+
+  def specs(self, capability: str) -> dict[str, Any]:
+    """Return all non-boolean specs for ``capability``."""
+    cap = self.capabilities.get(capability, {})
+    return {k: v for k, v in cap.items() if not isinstance(v, bool)}
+
+  def to_dict(self) -> dict:
+    """Serialize to a JSON-compatible dictionary."""
+    return {
+      "name": self.name,
+      "vendor": self.vendor,
+      "model": self.model,
+      "capabilities": copy.deepcopy(self.capabilities),
+      "connection": copy.deepcopy(self.connection),
+      "identity": copy.deepcopy(self.identity),
+    }
+
+  @classmethod
+  def from_dict(cls, data: dict) -> "DeviceCard":
+    """Reconstruct from a dictionary (e.g. loaded from JSON)."""
+    return cls(
+      name=data.get("name", ""),
+      vendor=data.get("vendor", ""),
+      model=data.get("model", ""),
+      capabilities=data.get("capabilities", {}),
+      connection=data.get("connection", {}),
+      identity=data.get("identity", {}),
+    )
+
+  def to_json(self, indent: int = 2) -> str:
+    """Serialize to JSON string."""
+    return json.dumps(self.to_dict(), indent=indent)
+
+  @classmethod
+  def from_json(cls, json_str: str) -> "DeviceCard":
+    """Reconstruct from JSON string."""
+    return cls.from_dict(json.loads(json_str))
+
+
+class HasDeviceCard:
+  """Mixin for devices that carry a :class:`DeviceCard`.
+
+  Devices that want a card declare this mixin and assign ``self.card``
+  in their constructor. The mixin makes the attribute discoverable
+  via type checks::
+
+      if isinstance(device, HasDeviceCard):
+        embed_identity(device.card.identity)
+
+  Same shape as :class:`pylabrobot.capabilities.loading_tray.HasLoadingTray`
+  — a Device-attribute marker mixin, not a Backend mixin.
+  """
+
+  card: DeviceCard
diff --git a/pylabrobot/li_cor/__init__.py b/pylabrobot/li_cor/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/pylabrobot/li_cor/odyssey/__init__.py b/pylabrobot/li_cor/odyssey/__init__.py
new file mode 100644
index 00000000000..634362a5d2c
--- /dev/null
+++ b/pylabrobot/li_cor/odyssey/__init__.py
@@ -0,0 +1,61 @@
+"""LI-COR Odyssey Classic — public API."""
+
+from pylabrobot.li_cor.odyssey.chatterbox import (
+  OdysseyChatterboxDriver,
+  OdysseyImageRetrievalChatterboxBackend,
+  OdysseyInstrumentStatusChatterboxBackend,
+  OdysseyScanningChatterboxBackend,
+)
+from pylabrobot.li_cor.odyssey.device_card import ODYSSEY_CLASSIC_BASE
+from pylabrobot.li_cor.odyssey.driver import OdysseyDriver
+from pylabrobot.li_cor.odyssey.errors import (
+  OdysseyError,
+  OdysseyImageError,
+  OdysseyScanError,
+  OdysseyStatusError,
+)
+from pylabrobot.li_cor.odyssey.image_retrieval_backend import (
+  OdysseyImageRetrievalBackend,
+)
+from pylabrobot.li_cor.odyssey.instrument_status_backend import (
+  OdysseyInstrumentStatusBackend,
+  OdysseyState,
+  normalize_state,
+)
+from pylabrobot.li_cor.odyssey.odyssey import OdysseyClassic
+from pylabrobot.li_cor.odyssey.scanning_backend import (
+  DEFAULT_GROUP,
+  OdysseyScanningBackend,
+  OdysseyScanningParams,
+  StopResult,
+)
+from pylabrobot.li_cor.odyssey.tagging import (
+  DEFAULT_SOFTWARE_TAG,
+  build_identity_description,
+  tag_tiff_with_identity,
+)
+
+__all__ = [
+  "OdysseyClassic",
+  "OdysseyDriver",
+  "OdysseyScanningParams",
+  "ODYSSEY_CLASSIC_BASE",
+  "OdysseyScanningBackend",
+  "OdysseyImageRetrievalBackend",
+  "OdysseyInstrumentStatusBackend",
+  "OdysseyChatterboxDriver",
+  "OdysseyScanningChatterboxBackend",
+  "OdysseyImageRetrievalChatterboxBackend",
+  "OdysseyInstrumentStatusChatterboxBackend",
+  "OdysseyError",
+  "OdysseyScanError",
+  "OdysseyImageError",
+  "OdysseyStatusError",
+  "OdysseyState",
+  "normalize_state",
+  "StopResult",
+  "DEFAULT_GROUP",
+  "DEFAULT_SOFTWARE_TAG",
+  "build_identity_description",
+  "tag_tiff_with_identity",
+]
diff --git a/pylabrobot/li_cor/odyssey/chatterbox.py b/pylabrobot/li_cor/odyssey/chatterbox.py
new file mode 100644
index 00000000000..9b18ae13169
--- /dev/null
+++ b/pylabrobot/li_cor/odyssey/chatterbox.py
@@ -0,0 +1,205 @@
+"""Chatterbox path for the Odyssey Classic — no instrument required.
+
+Three backend-tier chatterbox classes (one per capability) share an
+:class:`_OdysseyChatterboxState` object that simulates the
+instrument's state machine and stored scans. A minimal
+:class:`OdysseyChatterboxDriver` overrides ``setup`` / ``stop`` to
+no-ops; it exists only because :class:`pylabrobot.device.Device`
+requires a :class:`Driver` instance — the chatterbox backends do
+not call it.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import List, Optional
+
+from pylabrobot.capabilities.capability import BackendParams
+from pylabrobot.capabilities.scanning.image_retrieval import ImageRetrievalBackend
+from pylabrobot.capabilities.scanning.instrument_status import (
+  InstrumentStatusBackend,
+  InstrumentStatusReading,
+)
+from pylabrobot.capabilities.scanning.scanning import ScanningBackend
+from pylabrobot.device import Driver
+from pylabrobot.serializer import SerializableMixin
+
+from .driver import OdysseyDriver
+from .instrument_status_backend import OdysseyState
+from .scanning_backend import DEFAULT_GROUP, OdysseyScanningParams
+
+logger = logging.getLogger(__name__)
+
+
+class _OdysseyChatterboxState:
+  """Shared mutable state for the three chatterbox backends."""
+
+  def __init__(self) -> None:
+    self.scanner_state: OdysseyState = "Idle"
+    self.progress: float = 0.0
+    self.lid_open: bool = False
+    self.current_user: str = ""
+    self.current_scan_name: str = ""
+    self.current_group: str = ""
+    self.configured: bool = False
+    self.stop_was_partial: bool = False
+    # Pre-seed the default working group so the chatterbox mirrors
+    # the lab instrument's name space.
+    self.scans: dict[str, dict[str, bytes]] = {
+      DEFAULT_GROUP: {
+        "test_scan": b"CHATTERBOX_TIFF_DATA_700nm",
+      },
+    }
+
+
+class OdysseyChatterboxDriver(OdysseyDriver):
+  """No-op driver for chatterbox runs.
+
+  Bypasses the OdysseyDriver constructor's credential check and
+  overrides ``setup`` / ``stop`` so a Device can be wired with this
+  driver + chatterbox backends without contacting any instrument.
+  """
+
+  def __init__(self) -> None:
+    # Skip OdysseyDriver.__init__ — it requires real credentials.
+    # Call Driver.__init__ directly for instance-set registration.
+    Driver.__init__(self)
+    self._host = "chatterbox"
+    self._port = 0
+    self._timeout_seconds = 0.0
+    self._username = ""
+    self._password = ""
+    self._base_url = ""
+    self._auth = None
+    self._timeout = None
+    self._session = None
+
+  async def setup(self, backend_params: Optional[BackendParams] = None) -> None:
+    return None
+
+  async def stop(self) -> None:
+    return None
+
+  def serialize(self) -> dict:
+    return {"type": self.__class__.__name__}
+
+
+class OdysseyScanningChatterboxBackend(ScanningBackend):
+  """Chatterbox scanning backend — drives state with simulated progress."""
+
+  def __init__(self, state: _OdysseyChatterboxState) -> None:
+    super().__init__()
+    self._state = state
+
+  async def configure(self, backend_params: Optional[SerializableMixin] = None) -> None:
+    params = (
+      backend_params
+      if isinstance(backend_params, OdysseyScanningParams)
+      else OdysseyScanningParams()
+    )
+    self._state.configured = True
+    self._state.current_scan_name = params.name
+    self._state.current_group = params.group
+    self._state.scanner_state = "Configured"
+    self._state.stop_was_partial = False
+    logger.info("Chatterbox configured scan: %s", params.name)
+
+  async def start(self) -> None:
+    if not self._state.configured:
+      raise RuntimeError("Chatterbox scan not configured")
+    self._state.scanner_state = "Scanning"
+    self._state.progress = 0.0
+    for i in range(0, 101, 10):
+      if self._state.scanner_state != "Scanning":
+        return
+      self._state.progress = float(i)
+      await asyncio.sleep(0.05)
+    self._state.scanner_state = "Completed"
+    self._state.progress = 100.0
+    self._save_scan(partial=False)
+    self._state.configured = False
+
+  async def stop(self) -> None:
+    """Graceful stop — write a partial TIFF, transition to Stopped."""
+    if self._state.scanner_state == "Scanning":
+      self._save_scan(partial=True)
+      self._state.stop_was_partial = True
+    self._state.scanner_state = "Stopped"
+    self._state.configured = False
+
+  async def pause(self) -> None:
+    self._state.scanner_state = "Paused"
+
+  async def cancel(self) -> None:
+    self._state.scanner_state = "Idle"
+    self._state.progress = 0.0
+    self._state.configured = False
+    self._state.stop_was_partial = False
+
+  @property
+  def current_scan(self) -> tuple[str, str]:
+    """Return ``(group, name)`` for the most recently configured scan."""
+    return self._state.current_group, self._state.current_scan_name
+
+  def _save_scan(self, partial: bool) -> None:
+    group = self._state.current_group or DEFAULT_GROUP
+    name = self._state.current_scan_name or "scan"
+    if group not in self._state.scans:
+      self._state.scans[group] = {}
+    payload = b"CHATTERBOX_PARTIAL_TIFF_DATA" if partial else b"CHATTERBOX_TIFF_DATA"
+    self._state.scans[group][name] = payload
+
+
+class OdysseyImageRetrievalChatterboxBackend(ImageRetrievalBackend):
+  """Chatterbox image retrieval — reads from the shared state."""
+
+  def __init__(self, state: _OdysseyChatterboxState) -> None:
+    super().__init__()
+    self._state = state
+
+  async def list_groups(self) -> List[str]:
+    return list(self._state.scans.keys())
+
+  async def list_scans(self, group: str) -> List[str]:
+    return list(self._state.scans.get(group, {}).keys())
+
+  async def download(self, group: str, scan_name: str) -> bytes:
+    scans = self._state.scans.get(group, {})
+    if scan_name not in scans:
+      raise FileNotFoundError(f"Scan '{scan_name}' not found in group '{group}'")
+    return scans[scan_name]
+
+  async def download_channel(self, group: str, scan_name: str, channel: int) -> bytes:
+    """Mirrors the real backend's per-channel download.
+
+    The chatterbox stores one blob per scan rather than per channel,
+    so we return that blob for any requested channel — sufficient for
+    cross-capability orchestration tests (e.g. ``stop_and_save``).
+    """
+    return await self.download(group, scan_name)
+
+
+class OdysseyInstrumentStatusChatterboxBackend(InstrumentStatusBackend):
+  """Chatterbox status — reflects the shared state."""
+
+  def __init__(self, state: _OdysseyChatterboxState) -> None:
+    super().__init__()
+    self._state = state
+
+  async def read_status(self) -> InstrumentStatusReading:
+    return InstrumentStatusReading(
+      state=self._state.scanner_state,
+      current_user=self._state.current_user,
+      progress=self._state.progress,
+      time_remaining="",
+      lid_open=self._state.lid_open,
+    )
+
+
+__all__ = [
+  "OdysseyChatterboxDriver",
+  "OdysseyScanningChatterboxBackend",
+  "OdysseyImageRetrievalChatterboxBackend",
+  "OdysseyInstrumentStatusChatterboxBackend",
+]
diff --git a/pylabrobot/li_cor/odyssey/device_card.py b/pylabrobot/li_cor/odyssey/device_card.py
new file mode 100644
index 00000000000..08119ddb218
--- /dev/null
+++ b/pylabrobot/li_cor/odyssey/device_card.py
@@ -0,0 +1,69 @@
+"""Odyssey Classic device card — model base.
+
+Specs sourced from the operator's manual (publication 984-11712,
+version 3.0, edition D). The ``identity`` slot is empty: each
+deployment populates it with its own unit's PIDInst Handle URI,
+landing page, and friendly name via an instance card::
+
+    instance = DeviceCard.instance(identity={
+      "pid": "http://hdl.handle.net/21.11157/...",
+      "landing_page": "https://b2inst.gwdg.de/records/...",
+      "name": "Odyssey, Lab 3",
+    })
+    card = ODYSSEY_CLASSIC_BASE.merge(instance)
+"""
+
+from __future__ import annotations
+
+from pylabrobot.device_card import DeviceCard
+
+ODYSSEY_CLASSIC_BASE = DeviceCard(
+  name="Odyssey Classic",
+  vendor="LI-COR Biosciences",
+  model="9120",
+  capabilities={
+    "scanning": {
+      "resolutions_um": [21, 42, 84, 169, 337],
+      "quality_levels": ["lowest", "low", "medium", "high", "highest"],
+      "intensity_range": [0.5, 10.0],
+      "intensity_step": 0.5,
+      "low_intensity_range": [0.5, 2.0],  # L0.5 to L2.0
+      "scan_area_cm": [25, 25],
+      "focus_offset_range_mm": [0.0, 4.0],
+      "scanning_speed_cm_s": [5, 40],
+    },
+    "channels": {
+      "700": {
+        "laser_wavelength_nm": 685,
+        "laser_type": "solid-state diode",
+        "laser_peak_power_mw": 80,
+        "detector": "silicon avalanche photodiode",
+        "dichroic_split_nm": 750,
+      },
+      "800": {
+        "laser_wavelength_nm": 785,
+        "laser_type": "solid-state diode",
+        "laser_peak_power_mw": 80,
+        "detector": "silicon avalanche photodiode",
+        "dichroic_split_nm": 810,
+      },
+    },
+    "image_retrieval": {
+      "format": "TIFF",
+      "channels_per_file": 1,
+      "storage_gb": 25,
+    },
+    "instrument_status": {
+      "states": ["Idle", "Scanning", "Paused"],
+      "lid_interlock": True,
+    },
+  },
+  connection={
+    "protocol": "http",
+    "port": 80,
+    "auth": "basic",
+    "network": "10/100Base-T Ethernet",
+    "discovery": "rendezvous/mdns",
+    "cgi_base": "/scanapp/nonjava",
+  },
+)
diff --git a/pylabrobot/li_cor/odyssey/driver.py b/pylabrobot/li_cor/odyssey/driver.py
new file mode 100644
index 00000000000..c1b92d2861a
--- /dev/null
+++ b/pylabrobot/li_cor/odyssey/driver.py
@@ -0,0 +1,309 @@
+"""LI-COR Odyssey Classic HTTP transport driver.
+
+Generic HTTP transport over Basic Auth for the Odyssey Classic
+embedded web server. Vendor-specific protocol — CGI paths, form
+encoding, response parsing — lives in the capability backends; this
+driver only ships bytes back and forth.
+
+Server: Apache/1.3.27 (Unix) (Red-Hat/Linux) mod_perl/1.23
+Auth realm: LICOR-Odyssey
+Transport: HTTP over 10/100Base-T Ethernet
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from typing import Any, Awaitable, Callable, Optional, TypeVar
+
+import aiohttp
+
+from pylabrobot.capabilities.capability import BackendParams
+from pylabrobot.device import Driver
+
+logger = logging.getLogger(__name__)
+
+
+# Transport errors worth retrying — connection-level transients only.
+RETRYABLE_EXCEPTIONS = (
+  aiohttp.ClientConnectionError,
+  asyncio.TimeoutError,
+  ConnectionResetError,
+  OSError,
+)
+_HTTP_RETRY_ATTEMPTS = 3
+_HTTP_RETRY_DELAY = 0.25
+
+_T = TypeVar("_T")
+
+# Environment variables for credentials.
+_CRED_ENV_USER = "ODYSSEY_USER"
+_CRED_ENV_PASS = "ODYSSEY_PASS"
+
+
+class OdysseyDriver(Driver):
+  """HTTP transport for the LI-COR Odyssey Classic.
+
+  Wraps an aiohttp.ClientSession with HTTP Basic Auth. Capability
+  backends share a single OdysseyDriver instance and call
+  :meth:`post` / :meth:`get` / :meth:`get_bytes` to exchange bytes
+  with the embedded web server.
+  """
+
+  def __init__(
+    self,
+    host: str,
+    username: str,
+    password: str,
+    port: int = 80,
+    timeout: float = 60.0,
+  ) -> None:
+    super().__init__()
+    if not username or not password:
+      raise ValueError(
+        "OdysseyDriver requires both username and password. "
+        f"Use OdysseyDriver.from_env() to read them from "
+        f"{_CRED_ENV_USER}/{_CRED_ENV_PASS}."
+      )
+    self._host = host
+    self._port = port
+    self._timeout_seconds = timeout
+    self._username = username
+    self._password = password
+    self._base_url = f"http://{host}:{port}"
+    self._auth = aiohttp.BasicAuth(username, password)
+    self._timeout = aiohttp.ClientTimeout(total=timeout)
+    self._session: Optional[aiohttp.ClientSession] = None
+    logger.info(
+      "OdysseyDriver initialised: host=%s %s=%s",
+      host,
+      _CRED_ENV_USER,
+      username,
+    )
+
+  def serialize(self) -> dict:
+    return {
+      **super().serialize(),
+      "host": self._host,
+      "port": self._port,
+      "timeout": self._timeout_seconds,
+    }
+
+  @classmethod
+  def from_env(
+    cls,
+    host: Optional[str] = None,
+    port: int = 80,
+    timeout: float = 60.0,
+  ) -> "OdysseyDriver":
+    """Construct from ODYSSEY_USER / ODYSSEY_PASS env vars.
+
+    Raises ValueError if either is missing — the driver does not
+    silently fall back to default credentials. If ``host`` is None,
+    ODYSSEY_HOST is read from the environment too.
+    """
+    username = os.environ.get(_CRED_ENV_USER, "")
+    password = os.environ.get(_CRED_ENV_PASS, "")
+    if not username or not password:
+      missing = [
+        name
+        for name, val in (
+          (_CRED_ENV_USER, username),
+          (_CRED_ENV_PASS, password),
+        )
+        if not val
+      ]
+      raise ValueError(f"Missing required environment variable(s): {', '.join(missing)}.")
+    if host is None:
+      host = os.environ.get("ODYSSEY_HOST", "")
+      if not host:
+        raise ValueError("No host provided and ODYSSEY_HOST is unset.")
+    return cls(
+      host=host,
+      username=username,
+      password=password,
+      port=port,
+      timeout=timeout,
+    )
+
+  @property
+  def base_url(self) -> str:
+    return self._base_url
+
+  async def setup(self, backend_params: Optional[BackendParams] = None) -> None:
+    """Open the HTTP session and verify reachability.
+
+    ``Connection: close`` is forced on every request: the embedded
+    Apache 1.3.27 doesn't always handle keep-alive cleanly when a
+    second request arrives before the first response is fully
+    consumed. Closing per request is a couple of ms slower but
+    eliminates the inter-request races we see in the field.
+
+    Auth verification is intentionally NOT done here. Backends
+    perform the first auth-protected call; a 401 surfaces there.
+    """
+    self._session = aiohttp.ClientSession(
+      auth=self._auth,
+      timeout=self._timeout,
+      headers={"Connection": "close"},
+    )
+    async with self._session.get(self._base_url) as resp:
+      if resp.status != 200:
+        raise ConnectionError(f"Cannot reach Odyssey at {self._base_url} (HTTP {resp.status})")
+    logger.info("Connected to Odyssey at %s", self._base_url)
+
+  async def stop(self) -> None:
+    """Close the HTTP session."""
+    if self._session is not None:
+      await self._session.close()
+      self._session = None
+
+  def _check_session(self) -> aiohttp.ClientSession:
+    if self._session is None:
+      raise RuntimeError("OdysseyDriver not set up")
+    return self._session
+
+  # -- Generic transport ---------------------------------------------------
+
+  async def post(
+    self,
+    path: str,
+    form_data: Optional[dict[str, str]] = None,
+    *,
+    allow_redirects: bool = False,
+    with_retry: bool = False,
+  ) -> tuple[int, str, dict[str, str]]:
+    """POST ``form_data`` to ``path``. Returns (status, body, headers)."""
+    if with_retry:
+      return await self._retry(self._post_once, path, form_data, allow_redirects)
+    return await self._post_once(path, form_data, allow_redirects)
+
+  async def _post_once(
+    self,
+    path: str,
+    form_data: Optional[dict[str, str]],
+    allow_redirects: bool,
+  ) -> tuple[int, str, dict[str, str]]:
+    session = self._check_session()
+    url = f"{self._base_url}{path}"
+    async with session.post(url, data=form_data, allow_redirects=allow_redirects) as resp:
+      body = await resp.text()
+      return resp.status, body, dict(resp.headers)
+
+  async def get(
+    self,
+    path: str,
+    params: Optional[dict[str, str]] = None,
+    *,
+    allow_redirects: bool = True,
+    with_retry: bool = False,
+  ) -> tuple[int, str, dict[str, str]]:
+    """GET ``path`` with ``params``. Returns (status, body, headers)."""
+    if with_retry:
+      return await self._retry(self._get_once, path, params, allow_redirects)
+    return await self._get_once(path, params, allow_redirects)
+
+  async def _get_once(
+    self,
+    path: str,
+    params: Optional[dict[str, str]],
+    allow_redirects: bool,
+  ) -> tuple[int, str, dict[str, str]]:
+    session = self._check_session()
+    url = f"{self._base_url}{path}"
+    async with session.get(url, params=params, allow_redirects=allow_redirects) as resp:
+      body = await resp.text()
+      return resp.status, body, dict(resp.headers)
+
+  async def get_bytes(
+    self,
+    path: str,
+    params: Optional[dict[str, str]] = None,
+    *,
+    with_retry: bool = False,
+  ) -> tuple[int, bytes, dict[str, str], Optional[int]]:
+    """GET binary content. Returns (status, bytes, headers, content_length).
+
+    ``content_length`` is the server-advertised ``Content-Length``
+    header (or None). Truncation checks belong on the caller — this
+    method just returns whatever the socket delivered.
+    """
+    if with_retry:
+      return await self._retry_bytes(path, params)
+    return await self._get_bytes_once(path, params)
+
+  async def _get_bytes_once(
+    self,
+    path: str,
+    params: Optional[dict[str, str]],
+  ) -> tuple[int, bytes, dict[str, str], Optional[int]]:
+    session = self._check_session()
+    url = f"{self._base_url}{path}"
+    async with session.get(url, params=params) as resp:
+      data = await resp.read()
+      return resp.status, data, dict(resp.headers), resp.content_length
+
+  async def _retry(
+    self,
+    method: Callable[..., Awaitable[_T]],
+    *args: Any,
+  ) -> _T:
+    last_exc: Optional[Exception] = None
+    for attempt in range(_HTTP_RETRY_ATTEMPTS):
+      try:
+        return await method(*args)
+      except RETRYABLE_EXCEPTIONS as exc:
+        last_exc = exc
+        if attempt < _HTTP_RETRY_ATTEMPTS - 1:
+          logger.warning(
+            "%s attempt %d/%d failed (%s) — retrying",
+            method.__name__,
+            attempt + 1,
+            _HTTP_RETRY_ATTEMPTS,
+            exc,
+          )
+          await asyncio.sleep(_HTTP_RETRY_DELAY)
+          continue
+    assert last_exc is not None
+    raise last_exc
+
+  async def _retry_bytes(
+    self,
+    path: str,
+    params: Optional[dict[str, str]],
+  ) -> tuple[int, bytes, dict[str, str], Optional[int]]:
+    last_exc: Optional[Exception] = None
+    for attempt in range(_HTTP_RETRY_ATTEMPTS):
+      try:
+        return await self._get_bytes_once(path, params)
+      except RETRYABLE_EXCEPTIONS as exc:
+        last_exc = exc
+        if attempt < _HTTP_RETRY_ATTEMPTS - 1:
+          logger.warning(
+            "GET bytes %s attempt %d/%d failed (%s) — retrying",
+            path,
+            attempt + 1,
+            _HTTP_RETRY_ATTEMPTS,
+            exc,
+          )
+          await asyncio.sleep(_HTTP_RETRY_DELAY)
+          continue
+    assert last_exc is not None
+    raise last_exc
+
+  # -- Admin / non-capability ---------------------------------------------
+
+  async def shutdown_instrument(self) -> str:
+    """Power off the instrument. WARNING: restart can take 30 minutes."""
+    logger.warning("Shutting down Odyssey instrument")
+    _, body, _ = await self.get(
+      "/scanapp/admin/admin/index",
+      params={"action": "InitiateShutdown"},
+    )
+    return body
+
+  async def get_instrument_info(self) -> str:
+    """Fetch instrument info page (serial, software version)."""
+    _, body, _ = await self.get("/scanapp/help/instinfo.pl")
+    return body
diff --git a/pylabrobot/li_cor/odyssey/errors.py b/pylabrobot/li_cor/odyssey/errors.py
new file mode 100644
index 00000000000..18e26b64baa
--- /dev/null
+++ b/pylabrobot/li_cor/odyssey/errors.py
@@ -0,0 +1,54 @@
+"""Odyssey driver exceptions — dual-base for capability + vendor reach.
+
+Each backend-level error inherits from BOTH the vendor's driver-level
+exception (:class:`OdysseyError`) AND the capability-generic exception
+(:class:`ScanningError`, :class:`ImageRetrievalError`,
+:class:`InstrumentStatusError`). A single raise is then catchable on
+either axis::
+
+    try:
+      await odyssey.scanning.start()
+    except ScanningError:
+      ...   # capability-generic recovery (works for any scanning backend)
+    except OdysseyError:
+      ...   # vendor-specific debugging
+"""
+
+from __future__ import annotations
+
+from pylabrobot.capabilities.scanning.image_retrieval import ImageRetrievalError
+from pylabrobot.capabilities.scanning.instrument_status import InstrumentStatusError
+from pylabrobot.capabilities.scanning.scanning import ScanningError
+
+
+class OdysseyError(Exception):
+  """Base exception for the LI-COR Odyssey Classic driver.
+
+  Raised at the connection / transport layer for protocol or HTTP
+  failures. Capability-specific raises use a subclass that also
+  inherits from the matching capability-generic exception.
+  """
+
+
+class OdysseyScanError(OdysseyError, ScanningError):
+  """Odyssey scanning capability failed.
+
+  Catchable as either :class:`OdysseyError` (vendor-specific) or
+  :class:`ScanningError` (capability-generic).
+  """
+
+
+class OdysseyImageError(OdysseyError, ImageRetrievalError):
+  """Odyssey image retrieval failed (download / list / preview)."""
+
+
+class OdysseyStatusError(OdysseyError, InstrumentStatusError):
+  """Odyssey status read failed."""
+
+
+__all__ = [
+  "OdysseyError",
+  "OdysseyScanError",
+  "OdysseyImageError",
+  "OdysseyStatusError",
+]
diff --git a/pylabrobot/li_cor/odyssey/image_retrieval_backend.py b/pylabrobot/li_cor/odyssey/image_retrieval_backend.py
new file mode 100644
index 00000000000..947f1a64476
--- /dev/null
+++ b/pylabrobot/li_cor/odyssey/image_retrieval_backend.py
@@ -0,0 +1,171 @@
+"""Odyssey image retrieval backend — protocol logic for /scan/image.
+
+Owns the image-retrieval protocol: XML query encoding, TIFF /
+JPEG / log GETs, and HTML parsing of the scan-list dropdown. The
+driver only ships the bytes back.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import List
+from urllib.parse import quote
+
+from pylabrobot.capabilities.scanning.image_retrieval import ImageRetrievalBackend
+
+from .driver import OdysseyDriver
+from .errors import OdysseyImageError
+
+logger = logging.getLogger(__name__)
+
+
+_IMAGE_BASE = "/scanapp/imaging/nonjava"
+_SCAN_LIST_PATH = "/scanapp/scan/nonjava/"
+_SCAN_IMAGE_PATH = "/scan/image"
+_SAVELOG_URL_PATH = f"{_IMAGE_BASE}/savelog.pl"
+
+
+def _tiff_xml(group: str, scan_name: str, channel: int) -> str:
+  """Build the XML query string for a TIFF download."""
+  return (
+    f"<image><in>"
+    f"<scangroup>{group}</scangroup>"
+    f"<scan>{scan_name}</scan>"
+    f"<format>tiff</format>"
+    f"<channel>{channel}</channel>"
+    f"<clip><x0>0</x0><x1>0</x1><y0>0</y0><y1>0</y1></clip>"
+    f"</in></image>"
+  )
+
+
+def _jpeg_xml(
+  group: str,
+  scan_name: str,
+  contrast_700: int = 5,
+  contrast_800: int = 5,
+  channels: str = "700 800",
+  background: str = "black",
+  clip: tuple[int, int, int, int] = (0, 0, 0, 0),
+  vflip: bool = True,
+  hflip: bool = True,
+  zoom: int = 1,
+) -> str:
+  """Build the XML query string for a JPEG preview."""
+  x0, x1, y0, y1 = clip
+  return (
+    f"<image><in>"
+    f"<scangroup>{group}</scangroup>"
+    f"<scan>{scan_name}</scan>"
+    f"<zoom>{zoom}</zoom>"
+    f"<contrast700>{contrast_700}</contrast700>"
+    f"<contrast800>{contrast_800}</contrast800>"
+    f"<channel>{channels}</channel>"
+    f"<background>{background}</background>"
+    f"<clip><x0>{x0}</x0><x1>{x1}</x1><y0>{y0}</y0><y1>{y1}</y1></clip>"
+    f"<vflip>{'true' if vflip else 'false'}</vflip>"
+    f"<hflip>{'true' if hflip else 'false'}</hflip>"
+    f"</in></image>"
+  )
+
+
+def _parse_select_options(html: str, select_name: str) -> List[str]:
+  """Extract <option value="..."> values from an HTML <select>."""
+  pattern = rf'<select[^>]*name=["\']?{select_name}["\']?[^>]*>' r"(.*?)</select>"
+  match = re.search(pattern, html, re.DOTALL | re.IGNORECASE)
+  if not match:
+    return []
+  return re.findall(
+    r'<option[^>]*value=["\']?([^"\'>\s]+)',
+    match.group(1),
+    re.IGNORECASE,
+  )
+
+
+class OdysseyImageRetrievalBackend(ImageRetrievalBackend):
+  """Concrete image retrieval backend for the LI-COR Odyssey Classic."""
+
+  def __init__(self, driver: OdysseyDriver) -> None:
+    super().__init__()
+    self._driver = driver
+
+  async def list_groups(self) -> List[str]:
+    _, html, _ = await self._driver.get(_SCAN_LIST_PATH)
+    return _parse_select_options(html, "avail")
+
+  async def list_scans(self, group: str) -> List[str]:
+    _, html, _ = await self._driver.get(_SCAN_LIST_PATH)
+    return _parse_select_options(html, "preset")
+
+  async def download(self, group: str, scan_name: str) -> bytes:
+    """Download both 700 and 800 nm TIFFs concatenated."""
+    ch700 = await self.download_channel(group, scan_name, 700)
+    ch800 = await self.download_channel(group, scan_name, 800)
+    return ch700 + ch800
+
+  # -- Vendor extensions ---------------------------------------------------
+
+  async def download_channel(self, group: str, scan_name: str, channel: int) -> bytes:
+    """Download a single channel TIFF (700 or 800).
+
+    Verifies the byte count matches the server's Content-Length when
+    present so partial reads don't masquerade as success. Retries
+    transient connection errors via the driver.
+    """
+    xml = _tiff_xml(group, scan_name, channel)
+    path = f"{_SCAN_IMAGE_PATH}/{quote(scan_name)}-{channel}.tif"
+    logger.info("Downloading TIFF: %s channel %d", scan_name, channel)
+
+    status, data, _, content_length = await self._driver.get_bytes(
+      path,
+      params={"xml": xml},
+      with_retry=True,
+    )
+    if status != 200:
+      raise OdysseyImageError(f"TIFF download failed for {scan_name}-{channel}: HTTP {status}")
+    if content_length is not None and len(data) != content_length:
+      raise OdysseyImageError(
+        f"Truncated TIFF for {scan_name}-{channel}: got {len(data)} bytes, "
+        f"expected {content_length} (Content-Length)"
+      )
+    logger.info(
+      "Downloaded %s-%d.tif: %d bytes",
+      scan_name,
+      channel,
+      len(data),
+    )
+    return data
+
+  async def get_preview(
+    self,
+    group: str,
+    scan_name: str,
+    contrast_700: int = 5,
+    contrast_800: int = 5,
+    channels: str = "700 800",
+    background: str = "black",
+  ) -> bytes:
+    """Fetch a JPEG preview rendered server-side."""
+    xml = _jpeg_xml(
+      group,
+      scan_name,
+      contrast_700=contrast_700,
+      contrast_800=contrast_800,
+      channels=channels,
+      background=background,
+    )
+    status, data, _, _ = await self._driver.get_bytes(
+      _SCAN_IMAGE_PATH,
+      params={"xml": xml},
+    )
+    if status != 200:
+      raise OdysseyImageError(f"JPEG preview failed: HTTP {status}")
+    return data
+
+  async def download_scan_log(self, group: str, scan_name: str) -> str:
+    """Download the scan log for a completed scan."""
+    _, body, _ = await self._driver.get(
+      _SAVELOG_URL_PATH,
+      params={"group": group, "scan": scan_name},
+    )
+    return body
diff --git a/pylabrobot/li_cor/odyssey/instrument_status_backend.py b/pylabrobot/li_cor/odyssey/instrument_status_backend.py
new file mode 100644
index 00000000000..99041b06678
--- /dev/null
+++ b/pylabrobot/li_cor/odyssey/instrument_status_backend.py
@@ -0,0 +1,159 @@
+"""Odyssey instrument status backend — protocol logic for /scanapp/util/status/.
+
+Owns the status protocol: GET the status page, parse the HTML,
+normalise the raw state string to a canonical literal so downstream
+consumers can rely on exact string equality.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Literal
+
+from pylabrobot.capabilities.scanning.instrument_status import (
+  InstrumentStatusBackend,
+  InstrumentStatusReading,
+)
+
+from .driver import OdysseyDriver
+
+logger = logging.getLogger(__name__)
+
+
+_STATUS_BASE = "/scanapp/util/status"
+_STATUS_URL_PATH = f"{_STATUS_BASE}/"
+_STOP_FROM_STATUS_PATH = f"{_STATUS_BASE}/status"
+
+
+# Canonical Odyssey state literal exposed in :class:`InstrumentStatusReading`.
+OdysseyState = Literal[
+  "Idle",
+  "Configured",
+  "Initializing",
+  "Scanning",
+  "Paused",
+  "Stopped",
+  "Completed",
+  "Failed",
+]
+
+# Map raw instrument strings (lowercase) to the canonical literal.
+_STATE_MAP: dict[str, OdysseyState] = {
+  "idle": "Idle",
+  "configured": "Configured",
+  "initializing": "Initializing",
+  "scanning": "Scanning",
+  "escanning": "Scanning",  # firmware quirk
+  "paused": "Paused",
+  "stopped": "Stopped",
+  "completed": "Completed",
+  "failed": "Failed",
+  "error": "Failed",
+}
+
+
+def normalize_state(raw: str) -> OdysseyState:
+  """Map a raw instrument state string to the canonical literal.
+
+  Unrecognized values fall back to ``"Idle"`` (rather than ``"Failed"``)
+  so a parser miss does not lock the UI into a phantom error state.
+  Callers needing fresh-vs-stale terminal-state semantics should
+  combine this with a transition-out guard.
+  """
+  key = (raw or "").strip().lower()
+  if key in _STATE_MAP:
+    return _STATE_MAP[key]
+  logger.warning("Unknown instrument state %r — mapping to 'Idle' (parser miss?)", raw)
+  return "Idle"
+
+
+def _parse_status_html(html: str) -> dict[str, str]:
+  """Parse the instrument status page HTML.
+
+  Robust to tag layout: finds the label anywhere in the HTML
+  (case-insensitive), then walks forward skipping any tags and
+  whitespace until it hits the first non-empty text run. Handles
+  plain text, tags between label and colon, and table layouts.
+  """
+
+  def _extract(label: str) -> str:
+    idx = html.lower().find(label.lower())
+    if idx < 0:
+      return ""
+    rest = html[idx + len(label) :]
+    rest = re.sub(r"^(?:\s|<[^>]+>)*:?", "", rest, count=1)
+    text = re.sub(r"<[^>]+>", "|", rest)
+    for fragment in text.split("|"):
+      trimmed = fragment.strip()
+      if trimmed:
+        return trimmed.split("\n")[0].strip()
+    return ""
+
+  return {
+    "state": _extract("Scanner Status") or "Unknown",
+    "current_user": _extract("Current User"),
+    "progress": _extract("Percent Complete"),
+    "time_remaining": _extract("Time Remaining"),
+    "lid_status": _extract("Lid Status"),
+  }
+
+
+class OdysseyInstrumentStatusBackend(InstrumentStatusBackend):
+  """Concrete status backend for the LI-COR Odyssey Classic."""
+
+  def __init__(self, driver: OdysseyDriver) -> None:
+    super().__init__()
+    self._driver = driver
+    # Diagnostic cache — last raw HTML, populated on read.
+    self._last_status_html: str = ""
+    self._last_status_http: int = 0
+
+  async def read_status(self) -> InstrumentStatusReading:
+    status, html, _ = await self._driver.get(_STATUS_URL_PATH)
+    self._last_status_html = html
+    self._last_status_http = status
+    parsed = _parse_status_html(html)
+    if parsed["state"] == "Unknown":
+      logger.warning(
+        "Status parser missed 'Scanner Status' (HTTP %s, %d bytes).",
+        status,
+        len(html),
+      )
+    state = normalize_state(parsed["state"])
+    try:
+      progress = float(parsed.get("progress") or 0.0)
+    except (ValueError, TypeError):
+      progress = 0.0
+    lid_status = parsed.get("lid_status", "closed")
+    return InstrumentStatusReading(
+      state=state,
+      current_user=parsed.get("current_user", ""),
+      progress=progress,
+      time_remaining=parsed.get("time_remaining", ""),
+      lid_open=lid_status.lower() != "closed",
+    )
+
+  # -- Vendor extensions ---------------------------------------------------
+
+  async def force_stop(self) -> None:
+    """Stop the scanner via the status page.
+
+    The path to release a paused / stuck scanner without going through
+    the scan console.
+    """
+    logger.warning("Force-stopping scanner from status page")
+    await self._driver.post(
+      _STOP_FROM_STATUS_PATH,
+      form_data={"formContext": "1", "action": "Stop"},
+    )
+
+  @property
+  def last_status_html(self) -> str:
+    """Last raw status-page HTML — for diagnostic endpoints."""
+    return self._last_status_html
+
+  @property
+  def last_status_http(self) -> int:
+    """Last status-page HTTP status code — for diagnostic endpoints."""
+    return self._last_status_http
diff --git a/pylabrobot/li_cor/odyssey/odyssey.py b/pylabrobot/li_cor/odyssey/odyssey.py
new file mode 100644
index 00000000000..8865a08300e
--- /dev/null
+++ b/pylabrobot/li_cor/odyssey/odyssey.py
@@ -0,0 +1,281 @@
+"""LI-COR Odyssey Classic device class.
+
+Wires the Odyssey driver and three capability backends. The default
+mode is real hardware (HTTP); pass ``chatterbox=True`` for an
+in-memory chatterbox path that runs anywhere — useful for CI and
+notebooks.
+
+Usage::
+
+  import asyncio
+  from pylabrobot.li_cor.odyssey import OdysseyClassic, OdysseyScanningParams
+
+  async def main():
+    # Chatterbox — no instrument required.
+    odyssey = OdysseyClassic(chatterbox=True)
+    async with odyssey:
+      await odyssey.scanning.configure(OdysseyScanningParams(name="demo"))
+      await odyssey.scanning.start()
+      # ... poll status, then download:
+      tiff = await odyssey.images.download("odyssey", "demo")
+      print(f"{len(tiff)} bytes")
+
+  asyncio.run(main())
+
+Real hardware reads ODYSSEY_USER / ODYSSEY_PASS from the environment::
+
+  odyssey = OdysseyClassic(host="169.254.206.190")  # credentials from env
+  async with odyssey:
+    ...
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from typing import Callable, Optional
+
+from pylabrobot.capabilities.scanning.image_retrieval import (
+  ImageRetrieval,
+  ImageRetrievalBackend,
+)
+from pylabrobot.capabilities.scanning.instrument_status import (
+  InstrumentStatus,
+  InstrumentStatusBackend,
+  InstrumentStatusReading,
+)
+from pylabrobot.capabilities.scanning.scanning import Scanning, ScanningBackend
+from pylabrobot.device import Device
+from pylabrobot.device_card import DeviceCard, HasDeviceCard
+
+from .chatterbox import (
+  OdysseyChatterboxDriver,
+  OdysseyImageRetrievalChatterboxBackend,
+  OdysseyInstrumentStatusChatterboxBackend,
+  OdysseyScanningChatterboxBackend,
+  _OdysseyChatterboxState,
+)
+from .device_card import ODYSSEY_CLASSIC_BASE
+from .driver import OdysseyDriver
+from .image_retrieval_backend import OdysseyImageRetrievalBackend
+from .instrument_status_backend import (
+  OdysseyInstrumentStatusBackend,
+  normalize_state,
+)
+from .errors import OdysseyScanError
+from .scanning_backend import (
+  OdysseyScanningBackend,
+  OdysseyScanningParams,
+  StopResult,
+)
+
+logger = logging.getLogger(__name__)
+
+# Terminal states that end a scan session. ``Idle`` is included
+# because the real Odyssey transitions back to Idle when a scan
+# finishes — it never reports ``Completed``. The fresh-terminal-state
+# guard in :meth:`OdysseyClassic.wait_until_done` makes Idle safe.
+_TERMINAL_STATES = frozenset({"Idle", "Completed", "Stopped", "Failed"})
+
+# Bound on the post-Stop "settle to Idle" wait used by :meth:`stop_and_save`.
+_STOP_IDLE_TIMEOUT_SEC = 15.0
+_STOP_IDLE_POLL_SEC = 1.0
+
+
+class OdysseyClassic(Device, HasDeviceCard):
+  """LI-COR Odyssey Classic (model 9120) infrared imaging system.
+
+  Capabilities:
+    scanning: configure and control fluorescence scans.
+    images:   download saved scan TIFFs.
+    status:   poll the instrument's state machine.
+
+  Pass ``chatterbox=True`` for an in-memory test path; otherwise the
+  device connects to the instrument over HTTP using credentials from
+  ODYSSEY_USER / ODYSSEY_PASS (or supplied directly).
+
+  ``card`` accepts an instance-level :class:`DeviceCard` (typically
+  carrying this unit's PIDInst identity). When provided, it is merged
+  on top of :data:`ODYSSEY_CLASSIC_BASE` and exposed as ``self.card``.
+  When omitted, ``self.card`` is the model-base card.
+  """
+
+  def __init__(
+    self,
+    host: Optional[str] = None,
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+    port: int = 80,
+    timeout: float = 60.0,
+    chatterbox: bool = False,
+    card: Optional[DeviceCard] = None,
+  ) -> None:
+    driver: OdysseyDriver
+    scanning_backend: ScanningBackend
+    image_backend: ImageRetrievalBackend
+    status_backend: InstrumentStatusBackend
+
+    if chatterbox:
+      driver = OdysseyChatterboxDriver()
+      state = _OdysseyChatterboxState()
+      scanning_backend = OdysseyScanningChatterboxBackend(state)
+      image_backend = OdysseyImageRetrievalChatterboxBackend(state)
+      status_backend = OdysseyInstrumentStatusChatterboxBackend(state)
+    else:
+      resolved_host = host or os.environ.get("ODYSSEY_HOST", "")
+      if not resolved_host:
+        raise ValueError("OdysseyClassic requires a host (or ODYSSEY_HOST env var).")
+      resolved_user = username or os.environ.get("ODYSSEY_USER", "")
+      resolved_pass = password or os.environ.get("ODYSSEY_PASS", "")
+      if not resolved_user or not resolved_pass:
+        raise ValueError(
+          "OdysseyClassic requires both username and password "
+          "(or ODYSSEY_USER / ODYSSEY_PASS env vars)."
+        )
+      driver = OdysseyDriver(
+        host=resolved_host,
+        username=resolved_user,
+        password=resolved_pass,
+        port=port,
+        timeout=timeout,
+      )
+      scanning_backend = OdysseyScanningBackend(driver)
+      image_backend = OdysseyImageRetrievalBackend(driver)
+      status_backend = OdysseyInstrumentStatusBackend(driver)
+
+    super().__init__(driver=driver)
+
+    self.card = ODYSSEY_CLASSIC_BASE.merge(card) if card is not None else ODYSSEY_CLASSIC_BASE
+
+    self.scanning = Scanning(backend=scanning_backend)
+    self.images = ImageRetrieval(backend=image_backend)
+    self.status = InstrumentStatus(backend=status_backend)
+    self._capabilities = [self.scanning, self.images, self.status]
+
+  # -- Convenience helpers -------------------------------------------------
+
+  async def wait_until_done(
+    self,
+    poll_interval: float = 1.0,
+    timeout: Optional[float] = None,
+    on_progress: Optional[Callable[[InstrumentStatusReading], None]] = None,
+    require_fresh: bool = True,
+  ) -> InstrumentStatusReading:
+    """Poll status until the instrument reaches a terminal state.
+
+    With ``require_fresh=True`` (default) the method requires the
+    instrument to transition out of any initial terminal state before
+    accepting the next terminal as "this scan finished". Without this
+    guard, a caller racing against a just-completed scan would silently
+    receive that previous run's status.
+
+    Set ``require_fresh=False`` when the caller knows the wait was
+    triggered by an action that just initiated a new run — :meth:`scan`
+    does this since it owns the configure-then-start sequence.
+
+    Returns the final :class:`InstrumentStatusReading`. Raises
+    :class:`asyncio.TimeoutError` if ``timeout`` elapses first.
+    """
+    loop = asyncio.get_event_loop()
+    deadline = None if timeout is None else loop.time() + timeout
+
+    initial = await self.status.read_status()
+    if on_progress is not None:
+      on_progress(initial)
+    require_state_change = require_fresh and normalize_state(initial.state) in _TERMINAL_STATES
+
+    while True:
+      status = await self.status.read_status()
+      if on_progress is not None:
+        on_progress(status)
+      state = normalize_state(status.state)
+      if state not in _TERMINAL_STATES:
+        require_state_change = False
+      elif not require_state_change:
+        return status
+      if deadline is not None and loop.time() > deadline:
+        raise asyncio.TimeoutError(
+          f"Scan did not reach a "
+          f"{'fresh ' if require_fresh else ''}terminal state within "
+          f"{timeout:.0f} s (last state={status.state!r})"
+        )
+      await asyncio.sleep(poll_interval)
+
+  async def scan(
+    self,
+    backend_params: Optional[OdysseyScanningParams] = None,
+    poll_interval: float = 1.0,
+    on_progress: Optional[Callable[[InstrumentStatusReading], None]] = None,
+  ) -> InstrumentStatusReading:
+    """Configure → Start → wait for completion. Returns the final status.
+
+    One-shot helper for the common notebook flow. Does not download
+    the result — call ``odyssey.images.download(group, name)``
+    afterwards.
+    """
+    await self.scanning.configure(backend_params=backend_params)
+    await self.scanning.start()
+    # scan() owns the configure+start sequence — no risk of latching
+    # onto a previous run's terminal state, so opt out of the
+    # fresh-terminal guard. Standalone wait_until_done() callers still
+    # get protection by default.
+    return await self.wait_until_done(
+      poll_interval=poll_interval,
+      on_progress=on_progress,
+      require_fresh=False,
+    )
+
+  async def stop_and_save(self) -> StopResult:
+    """Graceful Stop that saves whatever has been acquired.
+
+    Cross-capability orchestration:
+      1. Issue the scanning Stop command (saves partial output).
+      2. Poll status until the instrument reports Idle (bounded by
+         ``_STOP_IDLE_TIMEOUT_SEC``) — what makes "auto-return to
+         idle" real.
+      3. Probe which channel TIFFs were written.
+
+    Lives on the device because it spans three capabilities; no
+    single backend should hold references to the other two.
+
+    Raises :class:`OdysseyScanError` if the instrument does not
+    settle at Idle within the timeout.
+    """
+    scanning_backend = self.scanning.backend
+    group, name = scanning_backend.current_scan  # type: ignore[attr-defined]
+    if not group or not name:
+      await self.scanning.stop()
+      return StopResult(state="Stopped", partial=False, channels_available=[])
+
+    await self.scanning.stop()
+
+    deadline = asyncio.get_event_loop().time() + _STOP_IDLE_TIMEOUT_SEC
+    while True:
+      reading = await self.status.read_status()
+      state = reading.state.strip().lower()
+      if state in ("idle", "stopped"):
+        break
+      if asyncio.get_event_loop().time() > deadline:
+        raise OdysseyScanError(
+          f"Instrument did not return to Idle within "
+          f"{_STOP_IDLE_TIMEOUT_SEC:.0f} s after Stop "
+          f"(last state={reading.state!r})"
+        )
+      await asyncio.sleep(_STOP_IDLE_POLL_SEC)
+
+    image_backend = self.images.backend
+    channels_available: list[int] = []
+    for ch in (700, 800):
+      try:
+        data = await image_backend.download_channel(group, name, ch)  # type: ignore[attr-defined]
+        if data:
+          channels_available.append(ch)
+      except Exception as e:
+        logger.info("Channel %d not available after Stop: %s", ch, e)
+
+    return StopResult(
+      state="Stopped",
+      partial=bool(channels_available),
+      channels_available=channels_available,
+    )
diff --git a/pylabrobot/li_cor/odyssey/odyssey_tests.py b/pylabrobot/li_cor/odyssey/odyssey_tests.py
new file mode 100644
index 00000000000..4fd31ea1c10
--- /dev/null
+++ b/pylabrobot/li_cor/odyssey/odyssey_tests.py
@@ -0,0 +1,150 @@
+"""Tests for OdysseyClassic — chatterbox-driven, no instrument required."""
+
+import unittest
+
+from pylabrobot.device_card import DeviceCard, HasDeviceCard
+from pylabrobot.li_cor.odyssey import (
+  OdysseyClassic,
+  OdysseyScanningParams,
+  StopResult,
+)
+
+
+class TestOdysseyDeviceCard(unittest.IsolatedAsyncioTestCase):
+  """DeviceCard merging is exercised at construction, before any I/O."""
+
+  def test_default_card_is_model_base(self):
+    odyssey = OdysseyClassic(chatterbox=True)
+    self.assertEqual(odyssey.card.name, "Odyssey Classic")
+    self.assertEqual(odyssey.card.vendor, "LI-COR Biosciences")
+    self.assertEqual(odyssey.card.model, "9120")
+    self.assertEqual(odyssey.card.identity, {})
+    self.assertTrue(odyssey.card.has("scanning"))
+    self.assertTrue(odyssey.card.has("image_retrieval"))
+    self.assertTrue(odyssey.card.has("instrument_status"))
+
+  def test_instance_card_merges_identity(self):
+    instance = DeviceCard.instance(
+      identity={
+        "pid": "http://hdl.handle.net/21.11157/test",
+        "landing_page": "https://example.org/test",
+        "name": "Test Lab Odyssey",
+      }
+    )
+    odyssey = OdysseyClassic(chatterbox=True, card=instance)
+    self.assertEqual(odyssey.card.identity["pid"], "http://hdl.handle.net/21.11157/test")
+    self.assertEqual(odyssey.card.identity["name"], "Test Lab Odyssey")
+    # model-base preserved
+    self.assertEqual(odyssey.card.vendor, "LI-COR Biosciences")
+    self.assertTrue(odyssey.card.has("scanning"))
+
+  def test_instance_card_can_override_capability_specs(self):
+    custom = DeviceCard.instance(
+      capabilities={
+        "scanning": {"resolutions_um": [42, 84]},  # subset
+      }
+    )
+    odyssey = OdysseyClassic(chatterbox=True, card=custom)
+    self.assertEqual(
+      odyssey.card.get("scanning", "resolutions_um"),
+      [42, 84],
+    )
+    # other scanning specs from the base survive
+    self.assertEqual(
+      odyssey.card.get("scanning", "scan_area_cm"),
+      [25, 25],
+    )
+
+  def test_implements_has_device_card_mixin(self):
+    odyssey = OdysseyClassic(chatterbox=True)
+    self.assertIsInstance(odyssey, HasDeviceCard)
+
+
+class TestOdysseyLifecycle(unittest.IsolatedAsyncioTestCase):
+  async def test_setup_finished_transitions(self):
+    odyssey = OdysseyClassic(chatterbox=True)
+    self.assertFalse(odyssey.setup_finished)
+    self.assertFalse(odyssey.scanning.setup_finished)
+
+    await odyssey.setup()
+    self.assertTrue(odyssey.setup_finished)
+    self.assertTrue(odyssey.scanning.setup_finished)
+    self.assertTrue(odyssey.images.setup_finished)
+    self.assertTrue(odyssey.status.setup_finished)
+
+    await odyssey.stop()
+    self.assertFalse(odyssey.setup_finished)
+    self.assertFalse(odyssey.scanning.setup_finished)
+
+  async def test_capability_methods_blocked_pre_setup(self):
+    odyssey = OdysseyClassic(chatterbox=True)
+    with self.assertRaises(RuntimeError):
+      await odyssey.status.read_status()
+    with self.assertRaises(RuntimeError):
+      await odyssey.scanning.start()
+    with self.assertRaises(RuntimeError):
+      await odyssey.images.list_groups()
+
+
+class TestOdysseyScanFlow(unittest.IsolatedAsyncioTestCase):
+  async def asyncSetUp(self):
+    self.odyssey = OdysseyClassic(chatterbox=True)
+    await self.odyssey.setup()
+
+  async def asyncTearDown(self):
+    await self.odyssey.stop()
+
+  async def test_scan_helper_runs_to_completion(self):
+    final = await self.odyssey.scan(
+      backend_params=OdysseyScanningParams(name="demo", group="odyssey"),
+    )
+    self.assertEqual(final.state, "Completed")
+    self.assertEqual(final.progress, 100.0)
+
+  async def test_download_after_scan(self):
+    await self.odyssey.scan(
+      backend_params=OdysseyScanningParams(name="dl_demo", group="odyssey"),
+    )
+    scans = await self.odyssey.images.list_scans("odyssey")
+    self.assertIn("dl_demo", scans)
+    data = await self.odyssey.images.download("odyssey", "dl_demo")
+    self.assertGreater(len(data), 0)
+
+  async def test_start_without_configure_raises(self):
+    with self.assertRaises(RuntimeError):
+      await self.odyssey.scanning.start()
+
+  async def test_default_group_seeded_in_chatterbox(self):
+    groups = await self.odyssey.images.list_groups()
+    self.assertIn("odyssey", groups)
+
+
+class TestOdysseyStopAndSave(unittest.IsolatedAsyncioTestCase):
+  async def asyncSetUp(self):
+    self.odyssey = OdysseyClassic(chatterbox=True)
+    await self.odyssey.setup()
+
+  async def asyncTearDown(self):
+    await self.odyssey.stop()
+
+  async def test_stop_and_save_without_configure_returns_empty(self):
+    result = await self.odyssey.stop_and_save()
+    self.assertIsInstance(result, StopResult)
+    self.assertEqual(result.state, "Stopped")
+    self.assertFalse(result.partial)
+    self.assertEqual(result.channels_available, [])
+
+  async def test_stop_and_save_after_scan_lists_channels(self):
+    # Run a full scan, then stop_and_save — both channels recorded.
+    await self.odyssey.scan(
+      backend_params=OdysseyScanningParams(name="full", group="odyssey"),
+    )
+    result = await self.odyssey.stop_and_save()
+    self.assertEqual(result.state, "Stopped")
+    # The chatterbox returns the same blob for any channel,
+    # so both 700 and 800 register as available.
+    self.assertEqual(sorted(result.channels_available), [700, 800])
+
+
+if __name__ == "__main__":
+  unittest.main()
diff --git a/pylabrobot/li_cor/odyssey/scanning_backend.py b/pylabrobot/li_cor/odyssey/scanning_backend.py
new file mode 100644
index 00000000000..f3edc6afbf0
--- /dev/null
+++ b/pylabrobot/li_cor/odyssey/scanning_backend.py
@@ -0,0 +1,353 @@
+"""Odyssey scanning backend — protocol logic for the Odyssey CGI.
+
+Owns the scan-control protocol: form-encoded POST to configure.pl,
+the 7-second initialization countdown, and command.pl GETs for
+start / stop / pause / cancel. Driver only ships the bytes.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+from pylabrobot.capabilities.capability import BackendParams
+from pylabrobot.capabilities.scanning.scanning import ScanningBackend
+from pylabrobot.serializer import SerializableMixin
+
+from .driver import OdysseyDriver
+from .errors import OdysseyScanError
+
+logger = logging.getLogger(__name__)
+
+
+# CGI base + protocol invariants — contracts with Odyssey firmware 2.1.12.
+_SCAN_BASE = "/scanapp/scan/nonjava"
+_CONFIGURE_URL_PATH = f"{_SCAN_BASE}/configure.pl"
+_COMMAND_URL_PATH = f"{_SCAN_BASE}/command.pl"
+_INITIALIZING_URL_PATH = f"{_SCAN_BASE}/initializing.pl"
+_TIME_URL_PATH = f"{_SCAN_BASE}/time.pl"
+_INFO_URL_PATH = "/scanapp/imaging/nonjava/info.pl"
+
+# Hidden ``channel`` field must be the literal "x" — the form has
+# VAUE="x" (typo for VALUE), and the firmware rejects any other value.
+_CHANNEL_SENTINEL = "x"
+
+# Full 7→1 initialization countdown after configure.pl. Skipping
+# steps skips DSP / laser / motor preparation and produces invalid scans.
+_INIT_POLL_STEPS = 7
+
+# Default operational scan group on the Odyssey.
+DEFAULT_GROUP = "odyssey"
+
+
+@dataclass
+class OdysseyScanningParams(BackendParams):
+  """Scan parameters for the Odyssey Classic.
+
+  Field names align with the configure.pl form, captured from the
+  browser interface. Pass an instance to :meth:`Scanning.configure`.
+
+  Attributes:
+    name: Scan name. Avoid ;/?:@=&<>"#%{}|^~[].
+    group: Scan group name (e.g. "odyssey", "public").
+    resolution: Resolution in micrometers — "21", "42", "84", "169",
+      "337", or "preview".
+    quality: "lowest", "low", "medium", "high", "highest".
+    intensity_700: 700 nm channel intensity. L2, L1.5, L1, L0.5,
+      0.5, 1, 1.5, 2, ..., 10 (in 0.5 steps).
+    intensity_800: 800 nm channel intensity (same range).
+    channel_700: Enable 700 nm acquisition.
+    channel_800: Enable 800 nm acquisition.
+    origin_x: Scan origin X in cm (0–25).
+    origin_y: Scan origin Y in cm (0–25).
+    width: Scan width in cm; origin_x + width <= 25.
+    height: Scan height in cm; origin_y + height <= 25.
+    focus: Focus offset in mm (0.0–4.0). 0 for membranes,
+      ~1.0 for gels, 3.0 for microplates.
+    comment: Free-text comment.
+    preset: Preset name to load (empty for manual config).
+  """
+
+  name: str = "scan"
+  group: str = DEFAULT_GROUP
+  resolution: str = "169"
+  quality: str = "medium"
+  intensity_700: str = "5"
+  intensity_800: str = "5"
+  channel_700: bool = True
+  channel_800: bool = True
+  origin_x: int = 0
+  origin_y: int = 0
+  width: int = 10
+  height: int = 10
+  focus: float = 0.0
+  comment: str = ""
+  preset: str = ""
+
+  def to_form_data(self) -> dict[str, str]:
+    """Render as the form-data dict POSTed to configure.pl."""
+    data: dict[str, str] = {
+      "channel": _CHANNEL_SENTINEL,
+      "scan": self.name,
+      "scangroup": self.group,
+      "avail": self.group,
+      "preset": self.preset,
+      "resolution": str(self.resolution),
+      "quality": self.quality,
+      "intensity700": str(self.intensity_700),
+      "intensity800": str(self.intensity_800),
+      "x0": str(self.origin_x),
+      "y0": str(self.origin_y),
+      "width": str(self.width),
+      "height": str(self.height),
+      "x1": str(self.origin_x + self.width),
+      "y1": str(self.origin_y + self.height),
+      "focus": str(self.focus),
+      "comment": self.comment,
+      "prename": "",
+    }
+    if self.channel_700:
+      data["chan700"] = "chan700"
+    if self.channel_800:
+      data["chan800"] = "chan800"
+    return data
+
+  def to_time_params(self) -> dict[str, str]:
+    """Query params for the time.pl scan-time estimate."""
+    return {
+      "resolution": str(self.resolution),
+      "quality": self.quality,
+      "x0": str(self.origin_x),
+      "y0": str(self.origin_y),
+      "x1": str(self.origin_x + self.width),
+      "y1": str(self.origin_y + self.height),
+    }
+
+
+@dataclass
+class StopResult:
+  """Outcome of a graceful Stop.
+
+  ``state`` is "Stopped"; ``partial`` is True if the instrument wrote
+  any channel TIFFs before the interrupt; ``channels_available`` lists
+  which channels were written.
+  """
+
+  state: str
+  partial: bool
+  channels_available: list[int]
+
+
+def _parse_error_block(body: str) -> Optional[str]:
+  """Extract <Error shorterror="X">message</Error> if present."""
+  m = re.search(
+    r'<Error\s+shorterror="([^"]+)"\s*>\s*(.*?)\s*</Error>',
+    body,
+    re.IGNORECASE | re.DOTALL,
+  )
+  if m:
+    short = m.group(1).strip()
+    detail = re.sub(r"\s+", " ", m.group(2)).strip()
+    return f"{short}: {detail}"
+  return None
+
+
+def _parse_info_html(html: str) -> dict[str, str]:
+  """Parse the imaging info panel HTML."""
+
+  def _extract(label: str) -> str:
+    pattern = rf"{label}\s*[:]\s*(?:<[^>]+>)*\s*([^<\n]+)"
+    match = re.search(pattern, html, re.IGNORECASE)
+    return match.group(1).strip() if match else ""
+
+  return {
+    "dimensions": _extract("Dimensions"),
+    "file_size": _extract("File Size"),
+    "time_left": _extract("Time Left"),
+  }
+
+
+class OdysseyScanningBackend(ScanningBackend):
+  """Concrete scanning backend for the LI-COR Odyssey Classic.
+
+  Encodes the scan-control protocol over the driver's generic HTTP
+  transport: form-encoded POST to configure.pl with structured-error
+  parsing, the 7→1 initialization countdown, and command.pl GETs for
+  the four control verbs.
+  """
+
+  def __init__(self, driver: OdysseyDriver) -> None:
+    super().__init__()
+    self._driver = driver
+    self._current_scan: str = ""
+    self._current_group: str = ""
+
+  def _coerce_params(self, backend_params: Optional[SerializableMixin]) -> OdysseyScanningParams:
+    """Accept None / OdysseyScanningParams; reject anything else."""
+    if backend_params is None:
+      return OdysseyScanningParams()
+    if isinstance(backend_params, OdysseyScanningParams):
+      return backend_params
+    raise TypeError(
+      f"OdysseyScanningBackend.configure expects OdysseyScanningParams, "
+      f"got {type(backend_params).__name__}"
+    )
+
+  async def configure(self, backend_params: Optional[SerializableMixin] = None) -> None:
+    params = self._coerce_params(backend_params)
+
+    # If a previous session left the scanner Paused, release it first.
+    # We probe via the InstrumentStatus capability path — but the
+    # backend doesn't have a reference to the status backend, so
+    # we just check for the structured error in the configure
+    # response. (Status preflight is a backend's right to do, but
+    # complicates the wiring; defer to the device-level helper.)
+    await self._post_configure(params)
+    self._current_scan = params.name
+    self._current_group = params.group
+
+    await self._wait_initialization(params.name, params.group)
+
+  async def _post_configure(self, params: OdysseyScanningParams) -> None:
+    """POST configure.pl, follow redirect on 302, parse Error on 2xx body."""
+    form_data = params.to_form_data()
+    logger.info(
+      "Configuring scan: name=%s group=%s res=%s quality=%s",
+      params.name,
+      params.group,
+      params.resolution,
+      params.quality,
+    )
+    logger.debug("Form data: %s", form_data)
+
+    status, body, headers = await self._driver.post(
+      _CONFIGURE_URL_PATH,
+      form_data=form_data,
+      allow_redirects=False,
+      with_retry=True,
+    )
+    logger.info("POST configure.pl → HTTP %d, body length %d", status, len(body))
+
+    if status == 302:
+      redirect = headers.get("Location", "")
+      logger.info("configure.pl redirect → %s", redirect)
+      # Follow the redirect — this triggers hardware initialization.
+      if redirect:
+        await self._driver.get(redirect, allow_redirects=False)
+      return
+
+    if status >= 400:
+      raise OdysseyScanError(f"Scanner rejected configuration: HTTP {status}.")
+
+    # 2xx body — instrument may have embedded a structured error.
+    if "busy" in body.lower() or "<TITLE>Error</TITLE>" in body:
+      parsed = _parse_error_block(body)
+      if parsed:
+        raise OdysseyScanError(f"Scanner rejected configuration — {parsed}")
+      raise OdysseyScanError(f"Scanner rejected configuration: {body[:500]}")
+
+  async def _wait_initialization(
+    self,
+    scan_name: str,
+    group: str,
+    timeout_steps: int = _INIT_POLL_STEPS,
+  ) -> None:
+    """Poll initializing.pl through the 7→1 countdown."""
+    logger.info("Waiting %d s for hardware initialization...", timeout_steps)
+    for t in range(timeout_steps, 0, -1):
+      params = {"scan": scan_name, "scangroup": group, "timeout": str(t)}
+      logger.info("initializing.pl?timeout=%d", t)
+      status, _, headers = await self._driver.get(
+        _INITIALIZING_URL_PATH,
+        params=params,
+        allow_redirects=False,
+      )
+      if status == 302 and t <= 1:
+        redirect = headers.get("Location", "")
+        logger.info("Initialization complete → %s", redirect)
+        if redirect:
+          await self._driver.get(redirect, allow_redirects=True)
+        return
+      await asyncio.sleep(1)
+    logger.info("Initialization wait complete")
+
+  async def start(self) -> None:
+    await self._scan_command("start")
+
+  async def stop(self) -> None:
+    """Graceful stop — finish current line, save partial output."""
+    await self._scan_command("stop")
+
+  async def pause(self) -> None:
+    await self._scan_command("pause")
+
+  async def cancel(self) -> None:
+    await self._scan_command("cancel")
+
+  async def _scan_command(self, action: str) -> None:
+    """Send command.pl?action=<action> and parse the response.
+
+    On success: 302 redirect to console.pl (no body to consume).
+    On error (e.g. not configured): 200 with a structured Error block.
+    """
+    logger.info("Scan command: %s", action)
+    status, body, _ = await self._driver.get(
+      _COMMAND_URL_PATH,
+      params={"action": action},
+      allow_redirects=False,
+    )
+    logger.info("command.pl?action=%s → HTTP %d", action, status)
+    if status == 302:
+      return
+    if "<Error" in body or "not configured" in body.lower():
+      parsed = _parse_error_block(body)
+      raise OdysseyScanError(f"Scan command '{action}' failed: {parsed or body[:500]}")
+
+  async def _on_stop(self) -> None:
+    """Safety on lifecycle stop: cancel any in-flight scan."""
+    try:
+      await self.cancel()
+    except Exception:
+      logger.exception("Failed to cancel scan during _on_stop")
+
+  # -- Vendor extensions ---------------------------------------------------
+
+  async def estimate_time(self, backend_params: Optional[SerializableMixin] = None) -> str:
+    """Return the instrument's time estimate for the configured scan.
+
+    Returns the time string, e.g. "0 hours 2 minutes 15 seconds".
+    """
+    params = self._coerce_params(backend_params)
+    _, html, _ = await self._driver.get(
+      _TIME_URL_PATH,
+      params=params.to_time_params(),
+    )
+    match = re.search(
+      r"Estimated Scan Time.*?(\d+ hours? \d+ minutes? \d+ seconds?)",
+      html,
+      re.DOTALL | re.IGNORECASE,
+    )
+    return match.group(1) if match else html
+
+  async def get_progress(self) -> dict[str, str]:
+    """Return current scan progress (dimensions, file_size, time_left)."""
+    if not self._current_scan:
+      return {"dimensions": "", "file_size": "", "time_left": ""}
+    _, html, _ = await self._driver.get(
+      _INFO_URL_PATH,
+      params={
+        "scan": self._current_scan,
+        "group": self._current_group,
+        "update": "Off",
+        "console": "yes",
+      },
+    )
+    return _parse_info_html(html)
+
+  @property
+  def current_scan(self) -> tuple[str, str]:
+    """Return ``(group, name)`` for the most recently configured scan."""
+    return self._current_group, self._current_scan
diff --git a/pylabrobot/li_cor/odyssey/tagging.py b/pylabrobot/li_cor/odyssey/tagging.py
new file mode 100644
index 00000000000..8e3b8df2357
--- /dev/null
+++ b/pylabrobot/li_cor/odyssey/tagging.py
@@ -0,0 +1,121 @@
+"""TIFF identity tagging for Odyssey scans.
+
+Embeds an identity payload (e.g. PIDInst Handle URI, landing page,
+friendly name) into standard TIFF tags so a scan lifted out of its
+surrounding metadata still resolves back to the instrument it came
+from. Identity is supplied as a plain dict — populate per
+deployment.
+
+Tags written:
+
+- ``270`` ImageDescription — JSON blob with the identity fields plus
+  optional ``scan_name`` / ``channel`` for self-describing scans.
+- ``305`` Software — application name.
+
+The functions are no-ops when ``identity`` is empty AND no per-call
+``scan_name`` / ``channel`` is supplied. They never raise on a parse
+or save failure — the original bytes are returned so a download is
+never lost to a tagging failure.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import logging
+from typing import Any, Optional, Union
+
+from pylabrobot.device_card import DeviceCard
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_SOFTWARE_TAG = "PyLabRobot Odyssey"
+
+
+def _resolve_identity(source: Union[DeviceCard, dict[str, Any], None]) -> dict[str, Any]:
+  """Coerce the identity source into a plain dict.
+
+  Accepts a :class:`DeviceCard` (reads ``card.identity``), a plain
+  dict, or None.
+  """
+  if source is None:
+    return {}
+  if isinstance(source, DeviceCard):
+    return dict(source.identity or {})
+  return dict(source)
+
+
+def build_identity_description(
+  identity: Union[DeviceCard, dict[str, Any], None] = None,
+  *,
+  scan_name: str = "",
+  channel: Optional[int] = None,
+  extra: Optional[dict[str, Any]] = None,
+) -> str:
+  """Render the identity payload as a compact JSON string.
+
+  Suitable for TIFF ImageDescription, PNG ``tEXt`` chunks, JSON
+  sidecars, or anywhere else a self-describing identity blob fits.
+  ``identity`` may be a :class:`DeviceCard` (in which case its
+  ``identity`` slot is read) or a plain dict.
+  """
+  payload: dict[str, Any] = _resolve_identity(identity)
+  if scan_name:
+    payload["scan_name"] = scan_name
+  if channel is not None:
+    payload["channel"] = channel
+  if extra:
+    payload.update(extra)
+  return json.dumps(payload, separators=(",", ":"))
+
+
+def tag_tiff_with_identity(
+  raw_bytes: bytes,
+  identity: Union[DeviceCard, dict[str, Any], None] = None,
+  *,
+  scan_name: str = "",
+  channel: Optional[int] = None,
+  software_tag: str = DEFAULT_SOFTWARE_TAG,
+) -> bytes:
+  """Re-emit a TIFF with the identity payload in tags 270 + 305.
+
+  ``identity`` may be a :class:`DeviceCard` (its ``identity`` slot is
+  read) or a plain dict. Returns ``raw_bytes`` unchanged when no
+  identity / scan_name / channel are supplied (so unconfigured users
+  see no behavior change), when PIL is not importable, or when the
+  TIFF fails to parse / save.
+  """
+  if not raw_bytes:
+    return raw_bytes
+  resolved = _resolve_identity(identity)
+  if not (resolved or scan_name or channel is not None):
+    return raw_bytes
+  try:
+    from PIL import Image  # type: ignore[import-not-found]
+  except ImportError:
+    return raw_bytes
+  try:
+    img = Image.open(io.BytesIO(raw_bytes))
+    img.load()
+  except Exception as e:
+    logger.info("TIFF re-tag skipped (parse failed): %s", e)
+    return raw_bytes
+  description = build_identity_description(
+    resolved,
+    scan_name=scan_name,
+    channel=channel,
+  )
+  try:
+    out = io.BytesIO()
+    img.save(
+      out,
+      format="TIFF",
+      tiffinfo={
+        270: description,
+        305: software_tag,
+      },
+    )
+    return out.getvalue()
+  except Exception as e:
+    logger.info("TIFF re-tag skipped (save failed): %s", e)
+    return raw_bytes
diff --git a/pyproject.toml b/pyproject.toml
index c873d4096bd..7c4196c553b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -22,7 +22,8 @@ sila = ["zeroconf>=0.131.0", "grpcio"]
 cytation-microscopy = ["numpy>=1.26", "opencv-python", "PyGObject"]
 pico = ["PyLabRobot[sila]", "opencv-python", "numpy"]
 xarm = ["xarm-python-sdk"]
-all = ["PyLabRobot[serial,usb,ftdi,hid,modbus,websockets,visualizer,opentrons,sila,pico,xarm]"]
+odyssey = ["aiohttp"]
+all = ["PyLabRobot[serial,usb,ftdi,hid,modbus,websockets,visualizer,opentrons,sila,pico,xarm,odyssey]"]
 test = [
   "pytest",
   "pytest-timeout",