diff --git a/examples/logical_error_rates/5_alpha_syndrome.ipynb b/examples/logical_error_rates/5_alpha_syndrome.ipynb
new file mode 100644
index 000000000..c8b2b065e
--- /dev/null
+++ b/examples/logical_error_rates/5_alpha_syndrome.ipynb
@@ -0,0 +1,324 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "eeb8c0ca-7f77-4577-ada8-5d28854173e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%capture\n",
+    "%pip install qldpc\n",
+    "%pip install matplotlib"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa2ac094-a676-40d0-aaa8-250ee2d05ebb",
+   "metadata": {},
+   "source": [
+    "## AlphaSyndrome measurement strategy\n",
+    "\n",
+    "We can specify a custom stabilizer measurement circuit for running active error correction cycles by defining a new `SyndromeMeasurementStrategy`.  As an example, `AlphaSyndrome` from [arXiv:2601.12509](https://arxiv.org/abs/2601.12509) uses a Monte Carlo tree search to find stabilizer measurement circuits with reduced logical error rates."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "090f328e-5391-4d9a-8e20-546e07f37675",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "### imports, simulation, and plotting code"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "cb253965-309e-4d59-88ca-9b77ff629e25",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from collections.abc import Sequence\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import sinter\n",
+    "\n",
+    "from qldpc import circuits, codes, decoders\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d56f75ee-0126-4d1c-84aa-220ae733eb8c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_memory_experiments(\n",
+    "    code: codes.CSSCode,\n",
+    "    strategies: Sequence[circuits.SyndromeMeasurementStrategy],\n",
+    "    error_rates: Sequence[float] = list(np.logspace(-4, -2, 5)),\n",
+    "    max_shots: int = 10**5,\n",
+    "    max_errors: int = 100,\n",
+    "    distance_trials: int = 100,\n",
+    "    **decoding_kwargs: object,\n",
+    ") -> list[sinter.TaskStats]:\n",
+    "    \"\"\"Use sinter to simulate memory cycles of the given codes.\n",
+    "\n",
+    "    This function ...\n",
+    "      1. Builds a memory experiment for each code.\n",
+    "      2. Adds a depolarizing noise to all gates, at the provided error rates.\n",
+    "      2. Wraps each noisy circuit in a `sinter.Task``.\n",
+    "      3. Runs batched Monte Carlo sampling with `sinter.collect`.\n",
+    "\n",
+    "    Args:\n",
+    "        code: The code we wish to simulate.\n",
+    "        strategies: The syndrome measurement strategies we wish to use.\n",
+    "        error_rates: The i.i.d. probabilities of a depolarizing error after each gate.\n",
+    "        max_shots: Stop sampling the circuit after this many shots.\n",
+    "        max_errors: Stops the sampling process after this many errors have been seen in samples\n",
+    "            taken from the circuit.\n",
+    "        distance_trials: If the code distance is not known, estimate it with this many trials.\n",
+    "            The estimated distance determines the number of rounds of syndrome measurement.\n",
+    "        **decoding_kwargs: Arguments to pass to the decoder.\n",
+    "\n",
+    "    Returns:\n",
+    "        A `sinter` stats object aggregating shots, errors, and metadata for downstream plotting.\n",
+    "    \"\"\"\n",
+    "    distance = code.get_distance(bound=distance_trials)\n",
+    "    noise_models = {\n",
+    "        prob: circuits.DepolarizingNoiseModel(prob, include_idling_error=False)\n",
+    "        for prob in error_rates\n",
+    "    }\n",
+    "\n",
+    "    tasks = []\n",
+    "    custom_decoders = {}  # each code is going to need its own decoder\n",
+    "    for strategy_index, strategy in enumerate(strategies):\n",
+    "        # Collect the components of the memory experiment.  In particular, we will need the record\n",
+    "        # of detectors and qubit indices.\n",
+    "        initialization, qec_cycle, readout, measurement_record, detector_record, qubit_ids = (\n",
+    "            circuits.get_memory_experiment_parts(\n",
+    "                code, basis=None, num_rounds=distance, syndrome_measurement_strategy=strategy\n",
+    "            )\n",
+    "        )\n",
+    "\n",
+    "        # Identify detectors associated with X-type and Z-type stabilizers (parity checks).\n",
+    "        detectors_x = detector_record.get_events(*qubit_ids.checks_x)\n",
+    "        detectors_z = detector_record.get_events(*qubit_ids.checks_z)\n",
+    "\n",
+    "        # Build a decoder that separately decodes X and Z sectors to predict X and Z observables.\n",
+    "        # Here X observables are numbered 0, 1, ..., code.dimension - 1, and Z observables are\n",
+    "        # numbered code.dimension, code.dimension + 1, ..., code.dimension * 2 - 1.\n",
+    "        decoder = decoders.SubgraphDecoder(\n",
+    "            (detectors_x, detectors_z),  # X/Z detectors\n",
+    "            (range(code.dimension), range(code.dimension, 2 * code.dimension)),  # X/Z observables\n",
+    "            **decoding_kwargs,\n",
+    "        )\n",
+    "        decoder_name = f\"decoder_{strategy_index}\"\n",
+    "        custom_decoders[decoder_name] = decoder\n",
+    "\n",
+    "        for prob in error_rates:\n",
+    "            noise_model = noise_models[prob]\n",
+    "            noisy_circuit = initialization + noise_model.noisy_circuit(qec_cycle) + readout\n",
+    "            dem = noisy_circuit.detector_error_model(decompose_errors=True)\n",
+    "            tasks.append(\n",
+    "                sinter.Task(\n",
+    "                    circuit=noisy_circuit,\n",
+    "                    detector_error_model=dem,\n",
+    "                    decoder=decoder_name,\n",
+    "                    json_metadata={\"label\": type(strategy).__name__, \"prob\": prob},\n",
+    "                )\n",
+    "            )\n",
+    "\n",
+    "    return sinter.collect(\n",
+    "        num_workers=os.cpu_count() - 2,\n",
+    "        max_shots=max_shots,\n",
+    "        max_errors=max_errors,\n",
+    "        tasks=tasks,\n",
+    "        custom_decoders=custom_decoders,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "def make_memory_experiment_figure(\n",
+    "    code: codes.CSSCode,\n",
+    "    strategies: Sequence[circuits.SyndromeMeasurementStrategy],\n",
+    "    error_rates: Sequence[float] = list(np.logspace(-4, -2, 5)),\n",
+    "    max_shots: int = 10**5,\n",
+    "    max_errors: int = 100,\n",
+    "    distance_trials: int = 100,\n",
+    "    figsize: tuple[int, int] = (5, 4),\n",
+    "    **decoding_kwargs: object,\n",
+    ") -> tuple[plt.Figure, plt.Axes]:\n",
+    "    \"\"\"Use sinter to simulate memory cycles of the given codes, and plot the results.\n",
+    "\n",
+    "    Args:\n",
+    "        code: The code we wish to simulate.\n",
+    "        strategies: The syndrome measurement strategies we wish to use.\n",
+    "        error_rates: The i.i.d. probabilities of a depolarizing error after each gate.\n",
+    "        max_shots: Stop sampling the circuit after this many shots.\n",
+    "        max_errors: Stops the sampling process after this many errors have been seen in samples\n",
+    "            taken from the circuit.\n",
+    "        distance_trials: If the code distance is not known, estimate it with this many trials.\n",
+    "            The estimated distance determines the number of rounds of syndrome measurement.\n",
+    "        figsize: The size of the figure to produce.\n",
+    "        **decoding_kwargs: Arguments to pass to the decoder.\n",
+    "\n",
+    "    Returns:\n",
+    "        The matplotlib.pyplot figure and axis.\n",
+    "    \"\"\"\n",
+    "    stats = run_memory_experiments(\n",
+    "        code, strategies, error_rates, max_shots, max_errors, distance_trials, **decoding_kwargs\n",
+    "    )\n",
+    "\n",
+    "    figure, axis = plt.subplots(figsize=figsize)\n",
+    "    sinter.plot_error_rate(\n",
+    "        ax=axis,\n",
+    "        stats=stats,\n",
+    "        x_func=lambda stats: stats.json_metadata[\"prob\"],\n",
+    "        group_func=lambda stats: stats.json_metadata[\"label\"],\n",
+    "    )\n",
+    "\n",
+    "    axis.axline(\n",
+    "        (0, 0),\n",
+    "        slope=1,\n",
+    "        color=\"k\",\n",
+    "        linestyle=\":\",\n",
+    "        label=r\"$p_{\\mathrm{log}}=p_{\\mathrm{phys}}$\",\n",
+    "    )\n",
+    "    axis.loglog()\n",
+    "    axis.set_xlabel(r\"physical error rate\")\n",
+    "    axis.set_ylabel(r\"logical error rate\")\n",
+    "    axis.legend(loc=\"best\")\n",
+    "    axis.grid(which=\"both\")\n",
+    "    figure.tight_layout()\n",
+    "\n",
+    "    return figure, axis"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "348a2ee4-47b4-44f8-84ce-aed2a178ab43",
+   "metadata": {},
+   "source": [
+    "### Steane code\n",
+    "\n",
+    "`AlphaSyndrome` is really a big-compute method.  For a small demonstration, though, we'll find a syndrome extraction circuit that is better than the default for the Steane code.  Again, to speed things up we'll use minimum-weight perfect matching (MWPM) decoder for this demo, even though the Steane code yields a non-matchable decoding graph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "604a53a6-9624-4a9f-bf00-ff471676408e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building gate schedule for X-type syndrome extraction circuit...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Scheduling gate 1 of 12: 100%|█████████████████████████████████████████| 1000/1000 [00:24<00:00, 40.01it/s]\n",
+      "Scheduling gate 2 of 12: 100%|█████████████████████████████████████████████| 23/23 [00:00<00:00, 40.63it/s]\n",
+      "Scheduling gate 3 of 12: 100%|█████████████████████████████████████████████| 24/24 [00:00<00:00, 39.19it/s]\n",
+      "Scheduling gate 4 of 12: 100%|█████████████████████████████████████████████| 28/28 [00:00<00:00, 40.67it/s]\n",
+      "Scheduling gate 5 of 12: 100%|█████████████████████████████████████████████| 17/17 [00:00<00:00, 40.79it/s]\n",
+      "Scheduling gate 6 of 12: 100%|█████████████████████████████████████████████| 13/13 [00:00<00:00, 40.55it/s]\n",
+      "Scheduling gate 7 of 12: 100%|███████████████████████████████████████████████| 9/9 [00:00<00:00, 39.98it/s]\n",
+      "Scheduling gate 8 of 12: 100%|███████████████████████████████████████████████| 8/8 [00:00<00:00, 39.45it/s]\n",
+      "Scheduling gate 9 of 12: 100%|█████████████████████████████████████████████| 12/12 [00:00<00:00, 39.96it/s]\n",
+      "Scheduling gate 10 of 12: 100%|██████████████████████████████████████████████| 5/5 [00:00<00:00, 40.70it/s]\n",
+      "Scheduling gate 11 of 12: 100%|██████████████████████████████████████████████| 3/3 [00:00<00:00, 39.24it/s]\n",
+      "Scheduling gate 12 of 12: 100%|██████████████████████████████████████████████| 2/2 [00:00<00:00, 40.50it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building gate schedule for Z-type syndrome extraction circuit...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Scheduling gate 1 of 12: 100%|█████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.86it/s]\n",
+      "Scheduling gate 2 of 12: 100%|█████████████████████████████████████████████| 43/43 [00:01<00:00, 39.79it/s]\n",
+      "Scheduling gate 3 of 12: 100%|█████████████████████████████████████████████| 50/50 [00:01<00:00, 40.15it/s]\n",
+      "Scheduling gate 4 of 12: 100%|█████████████████████████████████████████████| 12/12 [00:00<00:00, 39.58it/s]\n",
+      "Scheduling gate 5 of 12: 100%|█████████████████████████████████████████████| 12/12 [00:00<00:00, 40.57it/s]\n",
+      "Scheduling gate 6 of 12: 100%|█████████████████████████████████████████████| 11/11 [00:00<00:00, 39.40it/s]\n",
+      "Scheduling gate 7 of 12: 100%|█████████████████████████████████████████████| 12/12 [00:00<00:00, 40.62it/s]\n",
+      "Scheduling gate 8 of 12: 100%|█████████████████████████████████████████████| 20/20 [00:00<00:00, 40.72it/s]\n",
+      "Scheduling gate 9 of 12: 100%|█████████████████████████████████████████████| 63/63 [00:01<00:00, 40.13it/s]\n",
+      "Scheduling gate 10 of 12: 100%|████████████████████████████████████████████| 10/10 [00:00<00:00, 40.58it/s]\n",
+      "Scheduling gate 11 of 12: 100%|██████████████████████████████████████████| 149/149 [00:03<00:00, 40.14it/s]\n",
+      "Scheduling gate 12 of 12: 100%|████████████████████████████████████████████| 43/43 [00:01<00:00, 40.34it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "code = codes.SteaneCode()\n",
+    "decoding_kwargs = dict(with_MWPM=True, ignore_non_graphlike_errors=True)\n",
+    "\n",
+    "noise_model = circuits.DepolarizingNoiseModel(10e-3)  # noise model used to train AlphaSyndrome\\\n",
+    "decoder = decoders.SinterDecoder(**decoding_kwargs)\n",
+    "strategies = [\n",
+    "    circuits.EdgeColoring(),\n",
+    "    circuits.AlphaSyndrome(noise_model, decoder=decoder),\n",
+    "]\n",
+    "\n",
+    "make_memory_experiment_figure(code, strategies, **decoding_kwargs)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "96f8da12-2d42-4724-ad9d-05391bf820c7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/qldpc/circuits/__init__.py b/src/qldpc/circuits/__init__.py
index 30b2b112c..a4e82fd3b 100644
--- a/src/qldpc/circuits/__init__.py
+++ b/src/qldpc/circuits/__init__.py
@@ -1,3 +1,4 @@
+from .alpha_syndrome import AlphaSyndrome
 from .bookkeeping import (
     DetectorRecord,
     MeasurementRecord,
@@ -61,6 +62,7 @@
     "as_noiseless_circuit",
     "EdgeColoring",
     "EdgeColoringXZ",
+    "AlphaSyndrome",
     "SyndromeMeasurementStrategy",
     "get_transversal_automorphism_group",
     "get_transversal_circuit",
diff --git a/src/qldpc/circuits/alpha_syndrome.py b/src/qldpc/circuits/alpha_syndrome.py
new file mode 100644
index 000000000..66a57289e
--- /dev/null
+++ b/src/qldpc/circuits/alpha_syndrome.py
@@ -0,0 +1,392 @@
+"""Classes to define the AlphaSyndrome syndrome measurement strategies
+
+Copyright 2023 The qLDPC Authors and Infleqtion Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from __future__ import annotations
+
+import collections
+import math
+import random
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+import numpy as np
+import numpy.typing as npt
+import sinter
+import stim
+import tqdm
+
+from qldpc import codes, decoders
+from qldpc.objects import Node, Pauli, PauliXZ
+
+from .bookkeeping import MeasurementRecord, QubitIDs
+from .common import restrict_to_qubits, with_remapped_qubits
+from .noise_model import NoiseModel, as_noiseless_circuit
+from .syndrome_measurement import SyndromeMeasurementStrategy
+
+# Scrappy type to represent a schedule of two-qubit gates:
+# A list whose t-th entry is a list of gates to apply at time t.
+# For the purposes of this schedule, a "gate" is just an ordered pair of target qubits.
+GateSchedule = list[list[tuple[int, int]]]
+
+
+class AlphaSyndrome(SyndromeMeasurementStrategy):
+    """AlphaSyndrome strategy for constructing a syndrome measurement circuit.
+
+    Uses Monte-Carlo tree search (MCTS) to suppress hook errors.  Currently only supports CSS codes.
+
+    For more information, see the paper at https://www.arxiv.org/abs/2601.12509.
+
+    WARNING: This strategy is extremely SLOW due to unsolved problem with multiprocessing and MCTS.
+    """
+
+    def __init__(
+        self,
+        noise_model: NoiseModel,
+        decoder: sinter.Decoder | str = decoders.SinterDecoder(),
+        iters_per_step: int = 1000,
+        shots_per_iter: int = 10000,
+        exploration_weight: float = math.sqrt(2),
+        *,
+        verbose: bool = True,
+    ) -> None:
+        """Initialize an AlphaSyndrome syndrome measurement strategy, based on arXiv:2601.12509.
+
+        This strategy uses a Monte Carlo tree serch (MCTS) to construct a syndrome measurement
+        circuit that minimizes logical error rates.
+
+        The MCTS requires building and simulating noisy evaluation circuits, which naturally requires
+        defining a noise model.  Computing a logical error rate, in turn, requires specifying a
+        decoder.  The "decoder' and "custom_decoders" arguments to AlphaSyndrome are
+
+        Args:
+            noise_model: The noise model append to the syndrome measurement circuit.
+            decoder: The decoder that Sinter will use to compute logical error rates.  If this
+                argument is a string, it must must be a decoder name recognized by Sinter, such as
+                "pymatching" or "fusion_blossom".
+            iters_per_step: Iterations per MCTS step (default: 100).
+            shots_per_iter: Number of times to sample evaluation circuits (default: 10000).
+            exploration_weight: Exploration parameter of MCTS (default: sqrt(2)).
+            verbose: If True, print updates when constructing a syndrome extraction circuit.
+        """
+        self.noise_model = noise_model
+        self.iters_per_step = iters_per_step
+        self.shots_per_iter = shots_per_iter
+        self.exploration_weight = exploration_weight
+        self.verbose = verbose
+
+        # keyword arguments passed to sinter.predict_observables
+        self.sinter_decoding_kwargs: dict[str, str | dict[str, sinter.Decoder]]
+        if isinstance(decoder, str):
+            self.sinter_decoding_kwargs = dict(decoder=decoder)
+        else:
+            self.sinter_decoding_kwargs = dict(
+                decoder="custom", custom_decoders=dict(custom=decoder)
+            )
+
+    @restrict_to_qubits
+    def get_circuit(
+        self, code: codes.QuditCode, qubit_ids: QubitIDs | None = None
+    ) -> tuple[stim.Circuit, MeasurementRecord]:
+        """Construct a circuit to measure the syndromes of a quantum error-correcting code.
+
+        Args:
+            codes.QuditCode: The code whose syndromes we want to measure.
+            circuits.QubitIDs: Integer indices for the data and check (syndrome readout) qubits.
+                Defaults to QubitIDs.from_code(code).
+
+        Returns:
+            stim.Circuit: A syndrome measurement circuit.
+            circuits.MeasurementRecord: The record of measurements in the circuit.
+        """
+        if not isinstance(code, codes.CSSCode):
+            raise ValueError(
+                "The AlphaSyndrome strategy for syndrome measurement only supports CSS codes"
+            )
+        qubit_ids = qubit_ids or QubitIDs.from_code(code)
+
+        # the heavy lifting: schedule gates
+        schedule_cx = self._build_schedule(code, Pauli.X)
+        schedule_cz = self._build_schedule(code, Pauli.Z)
+
+        # construct a circuit from the gate schedules
+        circuit = stim.Circuit()
+        circuit.append("RX", range(len(code), len(code) + code.num_checks))
+        circuit += _schedule_to_circuit(schedule_cx, Pauli.X)
+        circuit += _schedule_to_circuit(schedule_cz, Pauli.Z)
+        circuit.append("MX", range(len(code), len(code) + code.num_checks))
+
+        # remap qubits and return the circuit together with a measurement record
+        circuit = with_remapped_qubits(circuit, qubit_ids.data + qubit_ids.check)
+        record = MeasurementRecord({qubit: [mm] for mm, qubit in enumerate(qubit_ids.check)})
+        return circuit, record
+
+    def _build_schedule(self, code: codes.CSSCode, basis: PauliXZ) -> GateSchedule:
+        """Schedule the gates that extract basis-type stabilizers of a CSS code."""
+        # identify gates that need to be scheduled, as (control, target) pairs
+        graph = code.get_graph(basis)
+        gates = [(check.index + len(code), data.index) for data, check in map(sorted, graph.edges)]
+
+        if self.verbose:  # pragma: no cover
+            print(f"Building gate schedule for {basis}-type syndrome extraction circuit...")
+
+        # schedule one gate at a time with MCTS
+        node = TreeNode(TreeState.head(gates))
+        for step in range(len(gates)):
+            node = self._schedule_one_gate(code, basis, node, step=step)
+
+        # convert the final tree node into a gate schedule
+        return node.state.to_schedule()
+
+    def _schedule_one_gate(
+        self, code: codes.CSSCode, basis: PauliXZ, root: TreeNode, *, step: int
+    ) -> TreeNode:
+        """Schedule one gate by penalizing its contribution to logical error rates."""
+        exploration_iterator = range(self.iters_per_step - root.visits)
+
+        if self.verbose:  # pragma: no cover
+            exploration_iterator = tqdm.tqdm(
+                exploration_iterator, f"Scheduling gate {step + 1} of {len(root.state.gates)}"
+            )
+
+        for _ in exploration_iterator:
+            # Starting from the root node, explore down through fully expanded non-terminal nodes.
+            # If we end at a non-terminal node that is not fully expanded, expand once.
+            node = root
+            while not node.is_terminal() and node.is_fully_expanded():
+                node = node.best_child(self.exploration_weight)
+            if not node.is_terminal():
+                node = node.expand()
+
+            # Construct a (randomly completed) schedule from the current node, build an evaluation
+            # circuit for the schedule, and inject noise into the circuit.
+            schedule = node.simulate().to_schedule()
+            evaluation_circuit = self._get_evaluation_circuit(code, basis, schedule)
+            noisy_evaluation_circuit = self.noise_model.noisy_circuit(
+                evaluation_circuit, insert_ticks=False
+            )
+
+            # sample detection events and observable flips from the evaluation circuit
+            sampler = noisy_evaluation_circuit.compile_detector_sampler()
+            dets, observable_flips = sampler.sample(self.shots_per_iter, separate_observables=True)
+
+            # penalize logical errors: disagreements in observable flips vs. decoding predictions
+            dem = noisy_evaluation_circuit.detector_error_model(
+                decompose_errors=True, ignore_decomposition_failures=True
+            )
+            predictions = sinter.predict_observables(
+                dem=dem, dets=dets, **self.sinter_decoding_kwargs
+            )
+            num_logical_errors = np.sum(np.any(predictions != observable_flips, axis=1))
+            node.backpropagate(self.shots_per_iter / (num_logical_errors + 1))
+
+        # pathological edge case: we never explored from this root
+        if not root.children:
+            root.expand()  # pragma: no cover
+
+        return root.best_child(exploration_weight=0)
+
+    def _get_evaluation_circuit(
+        self, code: codes.CSSCode, basis: PauliXZ, schedule: GateSchedule
+    ) -> stim.Circuit:
+        """Build the circuit used to evaluate a gate schedule.
+
+        Assume without loss of generality that basis is Pauli.X.  The evaluation circuit penalizes
+        Z-type logical operator flips when reading out X-type stabilizers.
+        """
+
+        # noiseless measurement of stabilizers and logical operators in the opposite basis
+        opposite_basis = Pauli.swap_xz(basis)
+        stabilizers = code.get_stabilizer_ops(opposite_basis, symplectic=True)
+        logical_ops = code.get_logical_ops(opposite_basis, symplectic=True)
+        opposite_basis_ops = np.vstack([stabilizers, logical_ops])
+        opposite_basis_measurements = as_noiseless_circuit(
+            _get_pauli_product_measurements(opposite_basis_ops)
+        )
+        num_stabilizers = len(stabilizers)
+        num_observables = len(logical_ops)
+        num_measurements = num_stabilizers + num_observables
+
+        # if reading out (say) X-type stabilizers, detect Z-type stabilizer and observable flips
+        circuit = stim.Circuit()
+        circuit += opposite_basis_measurements
+        circuit += _schedule_to_circuit(schedule, basis)
+        circuit += opposite_basis_measurements
+        for ii in range(num_stabilizers):
+            meas_index = -num_measurements + ii
+            circuit.append(
+                "DETECTOR",
+                [stim.target_rec(meas_index), stim.target_rec(meas_index - num_measurements)],
+                ii,
+            )
+        for ii in range(num_observables):
+            meas_index = -num_measurements + num_stabilizers + ii
+            circuit.append(
+                "OBSERVABLE_INCLUDE",
+                [stim.target_rec(meas_index), stim.target_rec(meas_index - num_measurements)],
+                ii,
+            )
+
+        return circuit
+
+
+class TreeNode:
+    """Node of a tree for Monte Carlo tree search (MCTS).
+
+    TreeNode is agnostic to the problem being solved by MCTS.
+    All problem data is handled by the TreeState.
+
+    References:
+    - https://en.wikipedia.org/wiki/Monte_Carlo_tree_search
+    """
+
+    def __init__(self, state: TreeState, parent: TreeNode | None = None):
+        self.state = state
+        self.parent = parent
+
+        self.children: list[TreeNode] = []
+        self.unvisited = state.transitions()
+
+        self.visits = 0
+        self.value = 0.0
+
+    def is_terminal(self) -> bool:
+        """Is this a terminal node of the tree, which specifies a complete schedule?"""
+        return self.state.is_terminal()
+
+    def is_fully_expanded(self) -> bool:
+        """Have we constructed all children of this node?"""
+        return len(self.unvisited) == 0
+
+    def expand(self) -> TreeNode:
+        """Construct a child of this node."""
+        child_state = self.state.select(self.unvisited.pop())
+        child_node = TreeNode(child_state, self)
+        self.children.append(child_node)
+        return child_node
+
+    def backpropagate(self, reward: float) -> None:
+        """Increase the value of this node and all of its parents."""
+        self.visits += 1
+        self.value += reward
+        if self.parent:
+            self.parent.backpropagate(reward)
+
+    def simulate(self) -> TreeState:
+        """Select transitions at random until we reach a terminal node, and return its state."""
+        state = self.state
+        while not state.is_terminal():
+            state = state.select(random.choice(state.transitions()))
+        return state
+
+    def best_child(self, exploration_weight: float) -> TreeNode:
+        """Select a child of this node with the highest UCB score."""
+        assert self.children
+
+        def ucb_score(child: TreeNode) -> float:
+            if child.visits == 0:
+                return float("inf")  # pragma: no cover
+            return child.value / child.visits + exploration_weight * math.sqrt(
+                math.log(self.visits) / child.visits
+            )
+
+        return max(self.children, key=ucb_score)
+
+
+@dataclass(slots=True)
+class TreeState:
+    """The state of an MCTS tree, representing a (possibly incomplete) gate schedule."""
+
+    gates: list[tuple[int, int]]
+    gate_to_time: list[int | None]  # time index for each gate, or None for unscheduled gates
+    target_to_min_time: list[int]  # minimum time index for a new gate on a target
+
+    @staticmethod
+    def head(gates: Sequence[tuple[int, int]]) -> TreeState:
+        """A TreeState in which no gates have been scheduled."""
+        num_gates = len(gates)
+        num_targets = max(target for gate in gates for target in gate) + 1
+        return TreeState(list(gates), [None] * num_gates, [0] * num_targets)
+
+    def is_terminal(self) -> bool:
+        """Have all gates been scheduled?"""
+        return None not in self.gate_to_time
+
+    def transitions(self) -> list[int]:
+        """The indices of gates that still need to be scheduled."""
+        return [
+            gate_index
+            for gate_index, time_index in enumerate(self.gate_to_time)
+            if time_index is None
+        ]
+
+    def select(self, gate_index: int) -> TreeState:
+        """Append the gate at the given index to the gate schedule."""
+        target_a, target_b = self.gates[gate_index]
+        time_index = max(self.target_to_min_time[target_a], self.target_to_min_time[target_b])
+
+        gate_to_time = self.gate_to_time.copy()
+        gate_to_time[gate_index] = time_index
+
+        min_time_for_target = self.target_to_min_time.copy()
+        min_time_for_target[target_a] = time_index + 1
+        min_time_for_target[target_b] = time_index + 1
+
+        return TreeState(self.gates, gate_to_time, min_time_for_target)
+
+    def to_schedule(self) -> GateSchedule:
+        """Convert this TreeState into a gate schedule.
+
+        The schedule is provided as a list whose t-th entry is a list of gates to apply at time t.
+        Unscheduled gates are excluded from the returned schedule.
+        """
+        # collect gates according to their time index
+        time_to_gates: dict[int, list[tuple[int, int]]] = collections.defaultdict(list)
+        for gate, time in zip(self.gates, self.gate_to_time):
+            if time is not None:
+                time_to_gates[time].append(gate)
+
+        # return a schedule of gates: a list whose t-th index is a list of gates to apply at time t
+        return [time_to_gates[time] for time in sorted(time_to_gates.keys())]
+
+
+def _schedule_to_circuit(schedule: GateSchedule, target_pauli: Pauli) -> stim.Circuit:
+    """Convert a schedule of controlled-Pauli gates into a circuit."""
+    circuit = stim.Circuit("TICK")
+    for gates in schedule:
+        for gate in gates:
+            circuit.append(f"C{target_pauli}", gate)
+        circuit.append("TICK")
+    return circuit
+
+
+def _get_pauli_product_measurements(op_matrix: npt.NDArray[np.int_]) -> stim.Circuit:
+    """Construct a circuit that measures Pauli strings represented by the rows of a matrix.
+
+    For example, passing the parity check matrix will measure stabilizers.
+    """
+    op_graph = codes.QuditCode.matrix_to_graph(op_matrix)
+
+    circuit = stim.Circuit()
+    for node_index in range(len(op_matrix)):
+        observable_node = Node(node_index, is_data=False)
+        targets = [
+            stim.target_pauli(data_node.index, str(edge_data[Pauli]))
+            for _, data_node, edge_data in op_graph.edges(observable_node, data=True)
+        ]
+        circuit.append("MPP", stim.target_combined_paulis(targets))
+
+    return circuit
diff --git a/src/qldpc/circuits/alpha_syndrome_test.py b/src/qldpc/circuits/alpha_syndrome_test.py
new file mode 100644
index 000000000..ea7aaf9d4
--- /dev/null
+++ b/src/qldpc/circuits/alpha_syndrome_test.py
@@ -0,0 +1,79 @@
+"""Unit tests for alpha_syndrome.py
+
+Copyright 2023 The qLDPC Authors and Infleqtion Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from __future__ import annotations
+
+import random
+
+import numpy as np
+import pytest
+import stim
+
+from qldpc import circuits, codes, math
+from qldpc.objects import Pauli
+
+
+def test_alpha_syndrome(pytestconfig: pytest.Config) -> None:
+    """Verify that syndromes are read out correctly."""
+    seed = pytestconfig.getoption("randomly_seed")
+
+    # verify that AlphaSyndrome builds valid syndrome extraction circuits for a few codes
+    assert alpha_syndrome_is_valid(codes.SteaneCode())
+    assert alpha_syndrome_is_valid(codes.ToricCode(2, rotated=True))
+    assert alpha_syndrome_is_valid(codes.SurfaceCode(2, rotated=True))
+
+    code_a = codes.ClassicalCode.random(5, 3, seed=seed)
+    code_b = codes.ClassicalCode.random(3, 2, seed=seed + 1)
+    assert alpha_syndrome_is_valid(codes.HGPCode(code_a, code_b))
+
+    # AlphaSyndrome does not support non-CSS codes
+    with pytest.raises(ValueError, match="only supports CSS codes"):
+        strategy = circuits.AlphaSyndrome(circuits.DepolarizingNoiseModel(0.001), "decoder_name")
+        strategy.get_circuit(codes.FiveQubitCode())
+
+
+def alpha_syndrome_is_valid(
+    code: codes.QuditCode,
+    strategy: circuits.AlphaSyndrome = circuits.AlphaSyndrome(
+        circuits.DepolarizingNoiseModel(0.001),
+        iters_per_step=3,
+        shots_per_iter=1,
+    ),
+) -> bool:
+    """Check that an AlphaSyndrome circuit correctly reads out stabilizers."""
+    # prepare a logical |0> state
+    state_prep = circuits.get_encoding_circuit(code)
+
+    # apply random Pauli errors to the data qubits
+    errors = random.choices([Pauli.I, Pauli.X, Pauli.Y, Pauli.Z], k=len(code))
+    error_ops = stim.Circuit()
+    for qubit, pauli in enumerate(errors):
+        error_ops.append(f"{pauli}_error", [qubit], [1])
+
+    # measure syndromes
+    syndrome_extraction_circuit, measurement_record = strategy.get_circuit(code)
+    for check in range(len(code), len(code) + code.num_checks):
+        syndrome_extraction_circuit.append("DETECTOR", measurement_record.get_target_rec(check))
+
+    # sample the circuit to obtain a syndrome vector
+    circuit = state_prep + error_ops + syndrome_extraction_circuit
+    syndrome = circuit.compile_detector_sampler().sample(1).ravel()
+
+    # compare against the expected syndrome
+    error_xz = code.field([pauli.value for pauli in errors]).T.ravel()
+    expected_syndrome = code.matrix @ math.symplectic_conjugate(error_xz)
+    return np.array_equal(expected_syndrome, syndrome)