abbot 0.1.0__tar.gz

abbot-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,52 @@
+name: Publish to PyPI
+
+# Pushing a version tag (v0.1.0, ...) builds and uploads that release. PyPI
+# trusts this workflow directly (trusted publishing), so no API token is stored.
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Check the tag matches the package version
+        run: |
+          version=$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")
+          if [ "v$version" != "$GITHUB_REF_NAME" ]; then
+            echo "Tag $GITHUB_REF_NAME doesn't match version $version in pyproject.toml"
+            exit 1
+          fi
+          if ! grep -q "^__version__ = \"$version\"" src/abbot/__init__.py; then
+            echo "abbot.__version__ doesn't match version $version in pyproject.toml"
+            exit 1
+          fi
+      - run: pip install build twine
+      - run: python -m build
+      - run: twine check dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    # Add required reviewers to this environment in the repo settings to approve
+    # each upload by hand.
+    environment:
+      name: pypi
+      url: https://pypi.org/project/abbot/
+    permissions:
+      id-token: write  # trusted publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

abbot-0.1.0/.github/workflows/tests.yml

@@ -0,0 +1,43 @@
+name: Tests
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install "ruff==0.16.10"  # pinned so new rules don't fail unrelated PRs
+      # Lint only; the codebase isn't ruff-formatted.
+      - run: ruff check src/ tests/
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    name: tests / Python ${{ matrix.python-version }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+      # The CPU wheel: abbot runs on the CPU, and the CUDA wheel is gigabytes.
+      - run: pip install torch --index-url https://download.pytorch.org/whl/cpu
+      - run: pip install -e '.[ui,dev]'
+      - name: Fast tests
+        run: pytest -m "not slow" -q
+      - name: Slow tests (GP fits, policies, end-to-end loops)
+        run: pytest -m slow -q

abbot-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+build/
+dist/
+.ipynb_checkpoints/

abbot-0.1.0/CITATION.cff

@@ -0,0 +1,14 @@
+cff-version: 1.2.0
+message: "If you use abbot, please cite it as below."
+title: "abbot: goal-driven Bayesian experimental design for the lab"
+type: software
+authors:
+  - family-names: Gasiorowski
+    given-names: Sean
+repository-code: "https://github.com/sgasioro/abbot"
+license: Apache-2.0
+keywords:
+  - Bayesian optimization
+  - Bayesian algorithm execution
+  - experimental design
+  - laboratory automation

abbot-0.1.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

abbot-0.1.0/PKG-INFO

@@ -0,0 +1,291 @@
+Metadata-Version: 2.5
+Name: abbot
+Version: 0.1.0
+Summary: Goal-driven Bayesian experimental design for the lab.
+Project-URL: Repository, https://github.com/sgasioro/abbot
+Project-URL: Issues, https://github.com/sgasioro/abbot/issues
+Author: Sean Gasiorowski
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Requires-Dist: botorch>=0.18
+Requires-Dist: gest-api
+Requires-Dist: numpy>=1.26
+Requires-Dist: pydantic>=2
+Requires-Dist: torch>=2.7
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Provides-Extra: examples
+Requires-Dist: jupyter; extra == 'examples'
+Requires-Dist: matplotlib>=3.9; extra == 'examples'
+Requires-Dist: nbclient>=0.10; extra == 'examples'
+Requires-Dist: nbformat>=5; extra == 'examples'
+Provides-Extra: sbi
+Requires-Dist: pyro-ppl>=1.9; extra == 'sbi'
+Requires-Dist: sbi<0.23,>=0.22; extra == 'sbi'
+Provides-Extra: ui
+Requires-Dist: nicegui>=1.4; extra == 'ui'
+Requires-Dist: plotly>=5; extra == 'ui'
+Provides-Extra: xopt
+Requires-Dist: xopt>=3.2; extra == 'xopt'
+Description-Content-Type: text/markdown
+
+# abbot
+
+**Goal-driven Bayesian experimental design for the lab.**
+
+abbot helps you choose which experiment to run next. You describe the knobs you
+can turn, what you measure, and what you want to achieve; abbot suggests a
+setting, you (or your instrument, or a simulation) run it and report the result,
+and it learns from every run. The goal can be:
+
+- **an optimum:** single- or multi-objective Bayesian optimization;
+- **a region:** every setting that hits a target band, a level set, the best point
+  per band (Bayesian algorithm execution, BAX);
+- **anything you can write as code** over the model's predictions.
+
+The aim is to make sophisticated methods (goal-driven search, multiple fidelities
+or sources, constraints, supervision) available through a short, readable spec
+with safe defaults, so a lab gets them without writing BoTorch code or tuning an
+algorithm.
+
+It's built for how lab work goes: a measurement that isn't one number (a
+spectrum, replicates, a posterior from simulation-based inference), runs that
+are slow or fail, and a person who stays in charge of halts, retries and
+overrides. A web UI runs a campaign with no code. Built on [BoTorch](https://botorch.org):
+abbot uses its models and standard acquisition functions, and adds goal-driven
+(BAX) acquisitions and the campaign around them.
+
+**Status: alpha.** APIs marked *Stable* in [`docs/API.md`](https://github.com/sgasioro/abbot/blob/main/docs/API.md) are safe to
+build on; *Provisional* ones may change between releases. Issues and pull requests
+are welcome.
+
+## Install
+
+abbot needs Python 3.11 or later (tested on 3.11–3.13). Install torch first, from
+PyTorch's index (the CPU build is enough; see [Local setup](https://github.com/sgasioro/abbot#local-setup)
+for a GPU):
+
+```bash
+pip install torch --index-url https://download.pytorch.org/whl/cpu
+pip install "abbot[ui]"
+```
+
+The `ui` extra adds the web frontend; `xopt` and `sbi` add those integrations.
+
+## Quickstart
+
+```python
+from abbot import ProblemSpec, OutputSpec, ContinuousDomain, Campaign
+
+def run_in_lab(temp):                          # a stand-in: your measurement here
+    return 1.0 - ((temp - 55.0) / 30.0) ** 2
+
+# 1. Define the problem: design knobs + what you measure.
+spec = ProblemSpec(
+    domain=[ContinuousDomain(name="temp", lower=20.0, upper=80.0)],
+    outputs=[OutputSpec(name="yield", direction="MAXIMIZE")],
+)
+
+# 2. Open a session. The policy, surrogate and a few space-filling starting
+#    points are picked from the spec (pass initial_designs= for your own).
+campaign = Campaign(spec)
+
+# 3. Ask → run in the lab → tell. Repeat.
+for _ in range(8):
+    x = campaign.suggest(1)[0]                 # e.g. {"temp": 54.2}
+    measured_yield = run_in_lab(x["temp"])
+    campaign.ingest({"yield": measured_yield})
+
+# 4. Hand over the recommended design.
+best = campaign.result().best                  # a Record; best.candidate is the setting
+```
+
+You report **raw physical values** (`direction` handles maximize vs. minimize for
+you — never pre-negate). `Campaign(spec)` picks `SimpleBO` for one objective and
+`ParetoBO` for several, with a GP surrogate; pass `Campaign(spec, policy,
+model_constructor)` to choose your own. A few variations:
+
+- **Programmatic experiment** — if measurements come from code (an instrument
+  driver, a simulator), hand over the whole loop: `run_campaign(spec, experiment,
+  n_shots=8)`, where `experiment` is any object with `run(design) -> outputs`.
+  `design` is the same `{"temp": 54.2}` dict `suggest` gives you; return the
+  outputs as a `{"yield": ...}` dict (or a list in `spec.outputs` order).
+- **Multi-objective** — give the spec two+ directional outputs; the same calls
+  pick `ParetoBO`, and `result().recommended` is the Pareto set.
+- **Find a region, not an optimum (BAX)** — mark outputs `direction="OBSERVE"`, pick
+  a `Goal` (e.g. `BandIntersection({"yield": (0.4, 0.6)})`,
+  `LevelSet(0.9, output="purity")`), and pass it in: `Campaign(spec,
+  BAXPolicy(goal))`.
+- **Keep an output in range** — `OutputSpec(name="purity", direction="OBSERVE",
+  min_val=0.9)`: proposals and the recommendation favor designs likely to meet it.
+- **Cheap and accurate runs** — add `sources=[Source(domain=EnumeratedDomain(
+  name="code", values=["sim", "experiment"]), target="experiment")]` to the spec:
+  abbot chooses which to run, trading cost against information, and recommends
+  at the target.
+- **Hold a knob fixed** — `campaign.suggest(1, fixed={"temp": 30})` proposes with
+  `temp` at 30 and chooses the rest.
+- **Limit how far a knob moves** — `ContinuousDomain(..., max_step=0.5)`: every
+  proposal is within 0.5 of the last one, starting from the `initial_designs` you
+  give (the current settings).
+- **Categories** — `EnumeratedDomain(name="solvent", values=["water", "ethanol"])`;
+  designs carry the labels, and the model learns how alike they are.
+- **Know when to stop** — `Campaign(spec, supervisor=Supervisor(stops=[
+  target_reached(0.95), no_improvement(15)]))` (rules from `abbot.supervision`),
+  and `print(campaign.check())` to see whether the model makes sense.
+- **Runs that fail, or regions that give nothing** — a failed run is retried, then
+  halts for a person (`campaign.resolve("retry" | "exclude" | "bad_region")`); a
+  check like `Supervisor(faults=[per_shot(is_dark, bad_region="dark")])` marks a
+  region as unusable, and proposals steer away from it.
+- **No code** — `python -m abbot.ui` launches the lab web frontend over the same
+  `Campaign`.
+
+See [`docs/HOWTO.md`](https://github.com/sgasioro/abbot/blob/main/docs/HOWTO.md) for "how do I…" answers, [`docs/API.md`](https://github.com/sgasioro/abbot/blob/main/docs/API.md)
+for the stability contract (what's safe to build on), [`examples/`](https://github.com/sgasioro/abbot/tree/main/examples)
+for a runnable notebook per capability, and
+[`docs/ARCHITECTURE.md`](https://github.com/sgasioro/abbot/blob/main/docs/ARCHITECTURE.md) for how abbot is put together
+(modules, the seams an application plugs into, the session API).
+
+## Where abbot fits
+
+abbot brings together methods that had been spread across several
+problem-specific packages. Labs work in different modes (a control room, a
+beamline, a bench), and good tools already exist for some of them. abbot aims to
+cover the gaps, following the [gest-api](https://pypi.org/project/gest-api/)
+generator standard to promote interoperability and a coherent ecosystem. As it
+develops, the emphasis is on what can be shared with neighboring tools and what
+is better kept separate; [`docs/ECOSYSTEM.md`](https://github.com/sgasioro/abbot/blob/main/docs/ECOSYSTEM.md) has a first pass
+at that split.
+
+## Local setup
+
+```bash
+# Option A — conda:
+conda env create -f environment.yml
+conda activate abbot
+
+# Option B — venv (Python 3.11 or later):
+python3.12 -m venv .venv && source .venv/bin/activate
+
+# Then, either way: torch first, from PyTorch's index, then abbot.
+pip install torch --index-url https://download.pytorch.org/whl/cpu
+pip install -e '.[ui,dev]'    # editable install + UI (nicegui, plotly) + dev (pytest, ruff)
+```
+
+The CPU build of torch is all the UI and the tests need. For an NVIDIA GPU,
+install a CUDA build instead, e.g. `pip install torch --index-url
+https://download.pytorch.org/whl/cu128`; the right tag for your driver is listed
+at [pytorch.org/get-started](https://pytorch.org/get-started). Installing torch
+with pip from PyTorch's index is more reliable than conda's CUDA packages.
+Everything else (BoTorch, `gest-api`, ...) comes from PyPI with `pip install -e`.
+
+## Examples
+
+Five runnable notebooks in [`examples/`](https://github.com/sgasioro/abbot/tree/main/examples) (install `pip install -e
+'.[examples]'`), one per capability: lab BO, multi-objective (`ParetoBO`),
+composite-SBI, goal-driven BAX, and multi-fidelity. See [`examples/README.md`](https://github.com/sgasioro/abbot/blob/main/examples/README.md).
+
+## Run the frontend
+
+```bash
+python -m abbot.ui                 # http://127.0.0.1:8080, opens a browser tab
+python -m abbot.ui --port 9000     # pick a port (auto-picks a free one if taken)
+python -m abbot.ui --no-show       # headless (e.g. on a cluster) — tunnel the port:
+                                   #   ssh -L 8080:localhost:8080 <cluster>
+```
+Flags also read env vars: `ABBOT_UI_HOST`, `ABBOT_UI_PORT`, `ABBOT_UI_SHOW`.
+
+**Mock mode:** on the Define tab, toggle *Mock mode* before creating the campaign
+to attach a spec-adaptive `MockAnalyticExperiment` (smooth, seeded landscape over
+whatever variables/objectives you defined). This enables **auto-run**
+(run / pause / step / stop) on the Run tab, so a whole campaign drives itself
+with no typed measurements — the quickest way to see the loop and plots working.
+
+## Develop
+
+```bash
+pytest -m "not slow"   # fast unit tier (no GP fits) — run on every change
+pytest                 # full suite incl. GP-fitting integration tests (minutes;
+                       # run before committing)
+ruff check src/ tests/
+```
+
+Tests are tiered with a `slow` marker: the fast layer uses canned tensors (goal
+logic, reducer scoring, io round-trips, spec/VOCS maps, UI builders); the `slow`
+layer fits GPs / runs policies / drives end-to-end loops (botorch `optimize_acqf`,
+ParetoBO hypervolume, InfoBAX fantasy conditioning, the Xopt run).
+
+## Roadmap
+
+**Built:**
+- The ask/tell `Campaign`, blocking drivers, resume, batches and asynchronous
+  runs with pending designs.
+- Single- and multi-objective BO, uncertainty sampling, and goal-driven BAX
+  (InfoBAX, SwitchBAX, MeanBAX) over discrete grids.
+- Composite objectives and SBI (`composite_evaluate`, `Rescore`,
+  `abbot.interop.sbi`).
+- Multi-fidelity and multi-source BO with costs (`Source`,
+  `MultiSourceGPConstructor`, cost-aware `SimpleBO` and InfoBAX).
+- Output and domain constraints; names, `log=True` inputs and labeled categories
+  in the spec; `suggest(fixed=...)`; travel limits (`max_step`).
+- Prior means, and correlated outputs (`default_constructor(spec,
+  correlated=True)`).
+- Supervision: fault checks, retries and halts, bad regions with a usability
+  classifier, stopping rules, and `campaign.check()` diagnostics.
+- Xopt interop both ways: abbot as an Xopt generator, and Xopt generators (TuRBO,
+  Nelder-Mead, ...) in abbot's loop.
+- The NiceGUI lab frontend (`python -m abbot.ui`).
+
+**Next:**
+1. **The UI catches up with the engine:** constraints, travel limits, sources,
+   `check()`, and a model choice in the builder.
+2. **Agent setup:** an MCP server over `Campaign`, then a setup assistant that
+   writes the spec and goal. The UI stays the run console and the
+   human-in-the-loop entry point.
+3. **GPU support:** one setting (`Campaign(..., device="cuda")`) that fits models
+   and runs policies on the GPU, while the history, saved files, experiments and
+   the UI stay on the CPU. The default stays CPU, since lab-scale GPs are usually
+   faster there. CUDA only: abbot fits in float64, which Apple's MPS doesn't
+   support.
+
+**Later:**
+- Continuous BAX (no candidate grid).
+- Correlated outputs together with sources or prior means.
+- A BAX-shaped multi-fidelity goal; noise that varies with the source.
+- Check shots at a known-good design.
+- A Bluesky route: abbot as a blop `Optimizer` backend
+  (see [`docs/ECOSYSTEM.md`](https://github.com/sgasioro/abbot/blob/main/docs/ECOSYSTEM.md)).
+- A run-level JSON format that includes cached SBI payloads.
+
+**Ease of use is a priority.** For each core workflow we periodically set the
+same problem up in abbot and in neighboring tools, and compare how much a
+newcomer must learn and get right by hand, to find what to improve in abbot.
+
+## Citing
+
+If abbot helps your work, please cite the repository (see
+[`CITATION.cff`](https://github.com/sgasioro/abbot/blob/main/CITATION.cff)). Its goal-driven policies follow:
+
+- W. Neiswanger, K. A. Wang and S. Ermon, "Bayesian Algorithm Execution:
+  Estimating Computable Properties of Black-box Functions Using Mutual
+  Information," *ICML* 2021, [arXiv:2104.09460](https://arxiv.org/abs/2104.09460)
+  (InfoBAX).
+- S. R. Chitturi *et al.*, "Targeted materials discovery using Bayesian
+  algorithm execution," *npj Computational Materials* 10, 156 (2024),
+  [doi:10.1038/s41524-024-01326-2](https://doi.org/10.1038/s41524-024-01326-2)
+  (MeanBAX, SwitchBAX and target-subset goals).
+
+and its models and standard acquisitions come from BoTorch: M. Balandat *et al.*,
+"BoTorch: A Framework for Efficient Monte-Carlo Bayesian Optimization,"
+*NeurIPS* 2020, [arXiv:1910.06403](https://arxiv.org/abs/1910.06403).
+
+## License
+
+Apache-2.0; see [`LICENSE`](https://github.com/sgasioro/abbot/blob/main/LICENSE).