> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.conductorquantum.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.conductorquantum.com/_mcp/server.

# Changelog

## September 16, 2026

## Usage API, team wallets, and callbacks

The public Coda API now exposes remaining credits, post-hoc run cost, Enterprise team wallets, and an optional signed usage callback.

### Usage

Authenticated with the same bearer token (`mcp:read` or `agents:run`). Not available on `/mcp`.

* `GET /usage/credits` returns remaining free and paid credits.
* `GET /usage` returns the remaining balance, token totals, `daily[]` buckets, a `teams[]` breakdown, and recent runs (`since` / `until` / `limit`).
* `GET /usage/runs/{run_id}` looks up settled cost for `X-Run-Id` / `job_id`.
* `GET /usage/threads/{thread_id}` looks up cost for `X-Thread-Id`.
* `GET /usage/teams/{team_id}` looks up cost billed to one team.

`charged_credits` is the 1:1 settled deduction. The public API does not expose the internal rate formula. `thread_id` attach is best-effort; a charge can settle with `thread_id` null.

### Team wallets

* Optional `team_id` on `POST /agents` and `POST /qpus` bills a staff-loaded Enterprise team wallet (`billed_team_id`).
* Personal tokens bill the personal wallet unless `team_id` is set. Team service-account keys always bill their team. A mismatched `team_id` returns `400`. There is no fallback to the personal wallet.
* `GET /teams`, `GET /teams/{team_id}`, and `GET /teams/{team_id}/members` return the roster. Keys cannot be minted through the API.
* There is no Coda project entity. Teams are the grouping axis.

### Usage callbacks

Enterprise team owners can set an `https://` callback under Settings → Teams → Keys → Usage callback. Coda POSTs `usage.settled`, `usage.released`, and `usage.test` events signed with `X-Coda-Signature`. The pull usage API remains the ledger.

## July 22, 2026

## Unified Coda agent

The separate `build` and `learn` agents have been replaced by one unified Coda agent for writing circuits and answering quantum computing questions.

* `mode` and `fast` are deprecated. Existing `mode` values remain accepted, but new integrations should omit both fields.
* `budget` (`low`, `medium`, or `high`; default: `high`) controls the tradeoff between response quality and speed.
* `code_mode` controls code delivery: `inline` streams code in token events, while `file` returns it in a `files` event before completion.

## Search endpoints removed

The experimental `POST /search` and `POST /fetch` endpoints have been removed from the Coda API.

## Python SDK

The `conductorquantum` Python SDK now supports `budget` and `code_mode`, omits `mode` by default, and uses the canonical `/tools/*` and `/qpus*` endpoint paths.

## May 13, 2026

## Batch processing for Coulomb Blockade Peak Detector v2

Added a new batch endpoint for running `coulomb-blockade-peak-detector-v2` over multiple traces in a single request.

* `POST /models/batch` and `client.control.models.batch.run(...)`
* Accepts a `.npy` or `.pt` file containing a 2D array shaped `(batch_size, trace_length)`
* Returns `output.outputs` ordered by batch index

```python
import numpy as np
from conductorquantum import ConductorQuantum

client = ConductorQuantum(
    token="YOUR_TOKEN",
)

trace_a = ...  # replace with actual trace data
trace_b = ...  # replace with actual trace data
batch = np.stack([trace_a, trace_b])

client.control.models.batch.run(
    model="coulomb-blockade-peak-detector-v2",
    data=batch,
)
```

## April 15, 2026

## NVIDIA Ising Calibration agent and QEC Decoding models

### Ising Calibration 1

[NVIDIA Ising Calibration 1](https://huggingface.co/nvidia/Ising-Calibration-1-35B-A3B): 35B-parameter VLM that interprets quantum calibration plots and produces structured assessments for autonomous QPU tune-up.

* `POST /agents/{agent_id}` and `client.control.agents.run("ising-calibration-v1", ...)`
* `GET /agents` and `client.control.agents.list()`

### Ising Decoding (QEC)

[NVIDIA Ising Decoding](https://github.com/NVIDIA/Ising-Decoding): AI pre-decoders for quantum error correction on surface codes.

* **Fast** (0.9M params) and **Accurate** (1.8M params) variants
* `POST /models` and `client.control.models.run("ising-decoding-v1-fast", ...)`

## April 8, 2026

## Coda API

Launched the Coda API for interacting with quantum hardware programmatically.

* `GET /qpus`: list available QPU devices
* `POST /qpus`: submit quantum circuits
* `POST /qpus/status`: check job status
* `client.coda.qpus.list()`, `client.coda.qpus.run(...)`, `client.coda.qpus.status(...)`

## March 9, 2026

## Coulomb Diamond Detector v2

Added `coulomb-diamond-detector-v2` to the Control API. This version detects the vertices of Coulomb diamond structures directly from conductance data with improved accuracy over v1.

```python
result = client.control.models.run(
    model="coulomb-diamond-detector-v2",
    data=f,
)
```

## March 6, 2026

## Resonator Dip Finder v0

Added `resonator-dip-finder-v0` to the Control API. Detects resonator dips in spectroscopy magnitude traces, accepting 1D input of any length and returning detected dip indices.

```python
result = client.control.models.run(
    model="resonator-dip-finder-v0",
    data=f,
)
```

## February 22, 2026

## Model result voting

Vote on model results to help improve model quality.

* `PUT /model-results/{result_id}/vote`: create or update a vote
* `DELETE /model-results/{result_id}/vote`: remove a vote
* `client.control.model_results.vote_on_model_result(result_id, vote=1)`
* `client.control.model_results.remove_vote_on_model_result(result_id)`

## January 12, 2026

## Coulomb Diamond Detector v1

Added `coulomb-diamond-detector-v1` to the Control API. Unlike v0 which requires a pre-segmented binary mask, v1 detects diamond vertices directly from raw conductance data without a segmentation step.

```python
result = client.control.models.run(
    model="coulomb-diamond-detector-v1",
    data=f,
)
```

## November 18, 2025

## Anticrossing Detector and Electron Unload models

Added two new model families to the Control API:

* **Anticrossing Detector**: detects anticrossing features in charge stability diagrams
* **Electron Unload Detector**: detects electron unloading events in gate voltage sweeps

```python
result = client.control.models.run(
    model="anticrossing-detector-v0",
    data=f,
)
```

## November 13, 2025

## Stanza DQD Search routine

Added the Double Quantum Dot (DQD) Search routine to Stanza. Automates the search for double quantum dot regimes using adaptive grid search and barrier sweeps.

```python
from stanza.routines.builtins.dqd_search import DQDSearchRoutine

routine = DQDSearchRoutine(device)
routine.run()
```

## October 28, 2025

## Stanza live plotting

Stream measurement data to interactive Bokeh plots during experiments with automatic axis labelling and configurable update rates.

## October 10, 2025

## Stanza Health Check routine

Automated diagnostics to verify instrument connectivity, channel mappings, and basic qubit response before starting experiments.

```python
from stanza.routines.builtins.health_check import HealthCheckRoutine

routine = HealthCheckRoutine(device)
routine.run()
```

## October 3, 2025

## Stanza v0.1.0

Initial release of Stanza, the open-source Python framework for quantum device control.

* Device configuration and channel mapping
* Instrument drivers (OPX, QDAC2)
* Data logging with HDF5 and JSONL writers
* Calibration routines framework

```bash
pip install stanza-quantum
```

## September 19, 2025

## CSD Binary Classifier for DQD Search

Deployed `charge-stability-diagram-binary-classifier-v0-16x16` to the Control API. A compact classifier designed for rapid double quantum dot search, accepting 16x16 input patches.

## July 14, 2025

## Coulomb Diamond Segmenter and Detector

Deployed `coulomb-diamond-segmenter-v0` and `coulomb-diamond-detector-v0` to the Control API. Segment Coulomb diamond conductance grids and detect diamond vertex structures.

## June 28, 2025

## Charge Stability Diagram Transition Detector

Deployed `charge-stability-diagram-transition-detector-v0` to the Control API. Detects the locations of charge transition lines in 2D charge stability diagrams.

## April 23, 2025

## Charge Stability Diagram, Coulomb Blockade, Pinch-off, and Turn-on models

Added the first batch of quantum device characterization models to the Control API:

* **Charge Stability Diagram**: segmentation, binary classification, and transition detection models
* **Coulomb Blockade**: classifiers and peak detectors for current measurements
* **Pinch-off**: classifier and parameter extractor for pinch-off curves
* **Turn-on**: classifier and threshold voltage extractor for turn-on measurements

```python
result = client.control.models.run(
    model="coulomb-blockade-peak-detector-v1",
    data=f,
)
```

## August 14, 2024

## Control API and Python SDK launch

Launched the Control API and `conductorquantum` Python SDK for programmatic access to ML models for quantum device characterization.

* `GET /models`: list models
* `POST /models`: run a model
* `GET /model-results`: list results
* `GET /model-results/{result_id}`: fetch a result
* `DELETE /model-results/{result_id}`: delete a result

```bash
pip install conductorquantum
```

## June 18, 2024

## Turn-on and Pinch-off models

Deployed Turn-on Classifier, Turn-on Parameter Extractor, and Pinch-off Classifier to the Control API for quantum device characterization.