Conductor Quantum builds AI software to scale and operate quantum technologies. Before a silicon quantum chip can run a computation, every device on it has to be located, characterised, and tuned. That process has until now required days of expert manual work per device. We automate it.

This post accompanies a video introducing our team and the problem we are working on. It also covers what our software can do: automated tuning of 128 double quantum dots across 64 devices on a multiplexed silicon chip made by our partner SemiQon, run from scratch, without a researcher at the controls. To understand why that matters, it helps to understand what a quantum computer actually is and why turning one on is so hard.

Why quantum computers are different

Classical computers store information as bits. Each bit is either a 0 or a 1, like a light switch: on or off. This binary logic is the foundation of every laptop, phone, and data centre on the planet.

Quantum computers use quantum bits, or qubits. A qubit can hold a value of 0 or 1, but it can also hold a linear combination of both at the same time. This is superposition, a phenomenon with no classical analogue. A qubit in superposition is not undecided between two states. It occupies both, until it is measured and collapses to one. Two qubits can also become entangled, meaning the state of one is bound to the state of the other regardless of the distance between them. These two properties together give quantum computers a fundamentally different relationship with information.

Quantum computing is not a speed improvement. It is access to a different class of problems. Simulating the molecular interactions of penicillin, for example, would take every supercomputer on Earth working in concert longer than the age of the universe. A fault-tolerant quantum computer could in theory do it in a reasonable time. The same applies to the discovery of new materials, drugs, and chemical processes governed by quantum mechanics at the atomic scale. These problems are not hard because our classical computers are slow. They are hard because the tool we use to describe nature at the fundamental level is quantum mechanics, and a quantum computer is the natural machine for that language.

Access to a different class of problems is supported by exponential scaling. N qubits can represent 2 to the power of N states. Three qubits give you eight states. Fifty give you over a quadrillion.

But today’s qubits are noisy. They decohere before a computation finishes, and the operations performed on them are imperfect. To get reliable results, you need error correction: encoding one logical qubit across many imperfect physical ones. That means a useful quantum computer will need not hundreds of qubits, but millions.

Silicon quantum chips are built using the same fabrication processes that put a billion transistors in your phone. They are nanoscale, dense, and manufactured in structures the semiconductor industry already runs at volume. That path to scale is why we targeted silicon first. Every chip that comes out of a fab needs to be tuned before it can do anything, and that tuning does not scale by hand. It is the bottleneck we set out to break.

The fragile part is not just the chip

When quantum chips are described as fragile, we mean three distinct things.

First, the chips are vulnerable to electrostatic discharge. Static electricity, the kind you generate walking across a carpet, can destroy a chip before a single measurement is taken. There are stories in the research community of teams losing a run of chips to electrostatic discharge before they ever got to connect a wire. This is a handling problem, solved with discipline and proper equipment.

Second, the qubits and corresponding quantum dots (more on these later) drift. The voltages needed to control them change over time, as temperature shifts and charges in the material move around. A configuration that worked yesterday may not work today. The voltages that worked for calibrating one quantum dot, may not work on another quantum dot on the same chip. This is a calibration problem, and it is the one our software is built to solve.

Third, and most fundamentally, the qubit state itself is fragile. A qubit has a lifetime. A qubit has a limited lifetime due to its interactions with the surrounding environment. After a certain period, it decoheres, loses its quantum properties, and collapses into a classical state. This is the deepest challenge in the field, and it brings us to Schrödinger’s cat.

The paradox at the heart of quantum computing

In 1935, the physicist Erwin Schrödinger proposed a thought experiment. A cat is placed in a sealed box, along with a small amount of radioactive material. If a single atom decays, a mechanism triggers and the cat dies. Quantum mechanics says the atom is in a superposition of decayed and not-decayed until it is observed. So what is the cat? Until the box is opened, it is, in a strict quantum mechanical sense, both alive and dead at once.

Schrödinger meant this as a provocation, a reduction to the absurd of what quantum superposition implied at a macroscopic scale. For quantum computing, the thought experiment maps onto something real.

A qubit in superposition is the cat. It must be isolated from its environment, sealed in its box, to preserve the quantum state. Any interaction with the outside world, any stray electromagnetic field, any vibration, any thermal fluctuation, acts like opening the box. The qubit collapses. The state is destroyed.

Here is the contradiction that makes quantum computing hard: To run a computation, you need to manipulate the qubit, gate it, entangle it with its neighbours. Ideally you have perfect control of the qubit, but how can you do this if you also want the qubit to be perfectly isolated from the outside world.

Perfect isolation preserves the quantum state but makes computation impossible. Perfect control enables computation but opens the door to destroying the quantum state. Every quantum computing architecture is an attempt to live in the narrow space between those two extremes. You need to be isolated enough that environmental noise does not kill the qubit before the computation finishes, and controlled enough to perform the operations you need before the clock runs out.

It is not a problem that gets solved once. It gets managed at every layer of the stack: in the physical design of the qubit, in the cryogenic systems that reduce thermal noise, and in the software that tunes and recalibrates the system before every use.

What is a quantum dot?

We have built software to control quantum dots. A quantum dot is a nanoscale structure, around 100 nanometres across, engineered to trap individual charge carriers. Those carriers are typically electrons which hold a negative charge (or holes - the absence of an electron which carries a positive charge). The key property is confinement: the structure is small enough that electrons inside it behave like they are in an atom. They do not occupy a continuous range of energies. They occupy discrete “quantized” levels, stacked like rungs on a ladder. Each electron sits at a higher energy than the one below it, following the same rules of atomic physics that govern electrons in real atoms. This is why quantum dots are sometimes called artificial atoms, and the zero-dimensional density of states is the “dot” in the name.

By adjusting the voltages on metal gate electrodes, for example a barrier gate or a plunger gate, surrounding the quantum dot, we can control the number of electrons inside, one by one, all the way down to a single electron. That single electron has a property called spin: it points either up or down. That spin is the qubit.

A double quantum dot places two of these structures side by side. When tuned correctly, an electron can tunnel between the two dots. The foundation for reading and controlling a spin qubit is in that tunnelling event. Each of our 64 devices contains two separate double quantum dots. Forming those pairs of dots, is what we did and announced today, across 64 devices.

Turning on a quantum computer

Turning on a quantum computer is nothing like booting a laptop. There is no power button. There is a process, one that until software like ours existed required days of expert manual work per device.

We ran that process from scratch across every one of the 64 devices on the chip. It begins with a health check: a source-drain voltage sweep to confirm current flows as expected, a gate leakage test to verify the gates are not shorted, a global turn-on check to confirm the device responds to gate voltage, and a pinch-off sweep for each gate to verify it can cut off current flow between source and drain. These steps tell you whether a device is worth tuning. If any fail, the device is set aside.

From there, the real work begins. Puddles of electrons must be formed at the right locations in the device. These become the quantum dots. The voltages controlling each dot must be swept and mapped to produce a charge stability diagram: a fingerprint that shows how many electrons occupy the dot and how sensitive it is to changes in voltage. The target is a regime where electron occupancy can be controlled with precision and the two dots in each pair are coupled, forming a double quantum dot.

The process is iterative: adjust, measure, adjust again. Every chip is different. Device variability means the voltages that work on one device are a poor starting point for the next. The parameter space is vast. Doing it by hand, across 64 devices, is not a realistic option.

128 double quantum dots: what we achieved

Our automated tuning software completed the full tuning sequence across all 64 devices on a SemiQon chip. The routine goes from health check through to double quantum dot formation for both electrons and holes, without a researcher at the controls. Each device contains a pair of double quantum dots, giving 128 in total. Each one was checked, characterised, and tuned from scratch in less than an hour on average.

The DQD (double quantum dot) search algorithm divides the voltage space into a grid and works through each square in three stages, each one more detailed than the last. First, a fast voltage sweep screens for electrical activity worth investigating. Squares in the grid that pass get a low-resolution charge stability diagram. Squares that pass that get a high-resolution scan for final confirmation. Each stage uses a machine learning model to automatically analyse the data acquired from the device in real-time. Finding the right voltage parameters to form a double quantum dot is like finding a needle in a haystack. The search space is vast and most regions will not contain what we are looking for. We cannot afford to waste time on false positives, which is why accurate classifiers at each stage matter so much. A square that fails at stage one costs 128 measurements. A square that makes it to stage three costs over 2,000.

The algorithm also learns where to look. Confirmed double quantum dot regions tend to cluster on a chip, so the search prioritises unvisited squares near previous successes before returning to a more explorative approach.

Forming a double quantum dot is the prerequisite for everything that follows: spin readout, qubit control, entanglement.

A useful quantum computer will need millions of qubits. Scaling to that number requires this kind of automation at every layer. There is no version of that future where researchers tune devices one at a time. Automation is not a convenience. It is the only path forward.

To learn more about DQD search and how to implement it on your own devices, see our documentation.

Why the name Conductor

We chose the name “Conductor” because we wanted something to outlast the moment, but specific enough to mean something in the industry. We knew we were going to initially start building for semiconductor spin qubits. We noticed that both “semiconductor” and “superconducting,” two qubit platforms, share the root “conduct.” People in the field were saying our name without knowing it.

The deeper reason was the metaphor. What our software does is calibrate arrays of qubits, coordinating their behaviour, bringing them into alignment before a computation. Our software also turns natural language into a working quantum circuit or hybrid quantum-classical workflow that you can run on calibrated qubits, allowing you to conduct a new computational paradigm with a few keystrokes. This maps onto what a conductor does before a performance. You are not playing the instruments. You are listening to each one, adjusting, coordinating, until the whole ensemble is in tune and the symphony is delivered.

Watching a conductor work with an orchestra, you understand that the conductor is not decorative. The conductor is the reason the performance works.

We are conducting an orchestra of qubits. The name was never going to be anything else.

Conductor Quantum is building quantum superintelligence. We are an American company headquartered in San Francisco, California. We are assembling a highly leveraged team of hardcore engineers whose sole focus is to develop quantum superintelligence.

If you would like to solve one of the hardest technological challenges of our time, this is your chance. Join us.

Coda is Conductor’s natural language interface for quantum computers. Describe what you want to do, and Coda turns that intent into an executable program, simulates it when you want fast iteration, runs it on real systems when you are ready, then returns results you can inspect.

Today we are launching Coda MCP, our Model Context Protocol (MCP) server that lets any MCP-compatible agent call quantum compute as a tool.

At a glance

• One MCP server for quantum execution, simulation, and transpilation

• Multi-provider QPU access across IBM, AQT, IQM, IonQ, and Rigetti

• Cross-framework transpilation, including IBM Qiskit and NVIDIA CUDA-Q

• Available now for anyone with a Coda account

One interface, multiple backends

Quantum workflows tend to fragment across providers and SDKs. Coda MCP is built to keep that from happening: one interface, consistent tools, and the flexibility to switch targets without rewriting everything.

Right now, that means live access to:

• Providers: IBM, AQT, IQM, IonQ, and Rigetti

• Hardware: 6+ QPUs totalling 1000+ qubits

With more hardware providers coming soon. If you’re not sure which one to choose, we’ve included a QPU (quantum processing unit) leaderboard to help.

Write once, run anywhere

Quantum work rarely stays inside one SDK. Coda MCP includes a transpile tool so you can prototype in one framework and execute in another while keeping results comparable.

Frameworks include:

• Qiskit

• NVIDIA CUDA-Q

• Cirq

• PennyLane

• Braket

• PyQuil

• OpenQASM

Simulation you can iterate on

When you are iterating on a circuit or debugging an experiment, simulation is the fastest feedback loop.

Coda also supports simulations up to 34 qubits supported by the NVIDIA cuQuantum libraries and NVIDIA CUDA-Q platform for hybrid quantum-classical computing.

In practice, this is how you and your coding agent debug quickly, benchmark, and run parameter sweeps before you spend queue time on hardware.

Small utilities that make real workflows smoother

Coda MCP includes workflow utilities you will end up needing anyway:

• Export to OpenQASM 3 (to_openqasm3)

• Estimate resources like qubit count, depth, and gate counts (estimate_resources)

• Split larger circuits for distributed execution (split_circuit)

It also includes paper search and retrieval tools (search_papers, get_paper) so an agent can ground an experiment in the literature, then immediately test an idea in simulation or on hardware.

Why MCP matters here

Agents can already write quantum code. What has been missing is a reliable, repeatable path from that code to execution across real backends.

Coda MCP provides that path. It lets an agent plan an experiment, run it end to end on simulators or QPUs, collect results, and iterate, all through a simple interface.

Under the hood, the loop is simple: generate or import a circuit, transpile to the target framework, simulate for fast iteration, execute on a QPU when you are ready, then pull results back into the conversation for analysis and next steps. All of these steps are completely handled by Coda.

Get started

Docs: https://pypi.org/project/coda-mcp/

If you want to try Coda first

If you just want to get a feel for Coda’s natural language interface, you can use the web chat at coda.conductorquantum.com.

Once you are ready to give an agent access to the same capabilities, connect via Coda MCP below.

If you want to connect an MCP compatible agent

Coda MCP works with MCP clients that support stdio transport, including Claude Desktop, Claude Code (CLI), VS Code, Cursor, Zed, and more.

First, generate an API token in Coda (Settings → API) and set it as CODA_API_TOKEN. If you need to override the API endpoint, you can set CODA_API_URL as well.

Install the server using one of the supported options:

pip install coda-mcp

coda-mcp  # runs the server

Then add the server to your MCP client.

Claude Desktop uses these config paths:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

• Windows: %AppData%\Claude\claude_desktop_config.json

Example Claude Desktop config:

{

  “mcpServers”: {

    “coda”: {

      “command”: “/path/to/uvx”,

      “args”: [”coda-mcp”],

      “env”: {

        “CODA_API_TOKEN”: “your-token-here”

      }

    }

  }

}

Claude Code (CLI):

claude mcp add coda -e CODA_API_TOKEN=your-token-here -- uvx coda-mcp

OpenAI Codex (CLI):

codex mcp add coda --env CODA_API_TOKEN=your-token-here -- uvx coda-mcp

Tip: in the Codex terminal UI, run /mcp to confirm the server is connected.

Cursor: add the same mcpServers.coda entry to ~/.cursor/mcp.json or .cursor/mcp.json in your project.

Zed: add a context_servers.coda entry to ~/.config/zed/settings.json.

Once connected, try:

• “Coda, create a 2 qubit Bell circuit in Qiskit, simulate it, then export to OpenQASM 3.”

• “Coda, transpile this Qiskit circuit to CUDA-Q and run a GPU backed simulation.”

• “Coda, list available QPUs and submit this circuit to IonQ or Rigetti.”

• “Coda, compile the same circuit for two targets and compare depth, gate counts, and output distributions.”

Access

Coda MCP is available now for anyone with a Coda account.

• To try Coda in the browser, use the chat interface at coda.conductorquantum.com.

• To connect an agent, generate a token, add the MCP server, and run your first job.

If you are building agent workflows and want a specific backend or capability prioritized, reach out. We are actively expanding coverage and improving the developer experience.

– Brandon, Joel and Ray, Conductor Quantum

TL;DR Qubit counts are increasing quickly. To keep pace, we need better software that makes quantum computers usable by more people, earlier. That is why we built Coda.

Hi. This is Brandon, Joel and Ray from Conductor Quantum.

Today, we are announcing Coda, a natural language interface for running real quantum programs on real quantum hardware.

What Coda does

Coda lets you interact with a quantum computer using natural language.

You describe the problem you want to run. Coda converts that intent into a quantum circuit, checks it for correctness, and executes it on available hardware.

The goal is not to hide quantum mechanics, but to remove unnecessary friction between intent and execution.

How this fits into the current state of quantum computing

Quantum computers already exist and are improving steadily. Qubit counts are rising, hardware reliability is improving, and access to cloud hosted quantum systems is becoming more common.

What has not kept pace is software.

Most quantum tools still assume deep prior knowledge, low level programming, and significant setup overhead. This slows down experimentation and limits who can realistically use the hardware.

Coda is designed to sit above existing quantum SDKs and hardware providers, translating high level intent into executable programs without requiring users to manage the entire stack themselves.

Learning and exploration

For users who are new to quantum computing, Coda includes a learn mode.

Instead of treating the system as a black box, learn mode explains what circuit is being generated, why specific operations are used, and what the results mean. The goal is to let users build intuition while still running real programs.

One of the first quantum computers available on the platform is Rigetti’s 84 qubit system. If users want to iterate quickly before using quantum hardware Coda also supports simulations up to 34 qubits supported by the NVIDIA cuQuantum libraries and NVIDIA CUDA-Q platform for hybrid quantum-classical computing.

Why we are building this

We believe quantum computing will only be useful if people can experiment quickly and cheaply.

As hardware scales, the primary constraint will shift from qubit count to orchestration, usability, and integration with classical computation. Software needs to evolve to meet that shift.

What we have built so far

Coda builds on several years of work at lower levels of the quantum stack.

We have:

• Built the first API for low-level silicon quantum chip control.

• Partnered with quantum chip maker SemiQon and ran our software across 64 of their quantum devices.

• Shipped quantum control software for companies including Quobly and EeroQ.

This experience informs how Coda generates circuits, validates execution, and interacts with hardware constraints.

What is next

We are continuing to expand Coda in three directions:

• End to end GPU plus QPU orchestration so classical and quantum computation can run together in a single workflow

• Connecting Coda to our lower level control and tune up software, enabling a path from high level intent to device level execution

• Scaling our control software as quantum hardware moves to larger systems

Our aim is to reduce the distance between intent and execution as much as possible.

Try it

Coda is live and evolving. Try it here:

https://coda.conductorquantum.com/

If you try it, we would love feedback on what works, what is confusing, and what you want to do that you cannot yet do.

— Brandon, Joel and Ray, Conductor Quantum

At the core of this release is a completely reimagined notebook workflow. Engineers can now visualize results in real time with inline live plotting, and maintain persistent measurement instances that automatically manage logging and state. The result: no restarts, no data loss, and seamless continuity across experimental sessions.

Plus, we’ve added extra benefits such as General-Purpose Input/Output (GPIO) control and charge carrier support straight from the device config. Read more below…

Live plotting

Some engineers love to peek under the hood and see exactly what our algorithms are measuring. Others prefer to fine-tune their devices by hand — for the joy of it, or to chase down that one elusive anomaly. Either way, live plotting turns every experiment into an interactive experience.

Now, with real-time data streaming built directly into Stanza, you can watch electrons move as measurements unfold — right from your desktop.

GPIO control

Hardware control just got easier. With built-in General-Purpose Input/Output (GPIO) support straight from the Stanza config, you can trigger relays, blink LEDs, control multiplexers or orchestrate complex control sequences without leaving Stanza. One config, one workspace full control.

Just add your gpio connectors to your device.yaml and away you go.

gpios:

  VSS:

    type: INPUT

    control_channel: 5

    v_lower_bound: 0

    v_upper_bound: 3.3

  VDD:

    type: INPUT

    control_channel: 6

    v_lower_bound: -3.3

    v_upper_bound: 0

Electrons or holes?

Are you working with an ambipolar device, or do you work with a range of semiconductor samples that use different charge carriers? If you’re struggling to keep track, don’t worry - you can set this straight in the device.yaml config. Also, Conductor’s pre-built tuning routines can read from this setting and set the search space parameters for tune-up based on your charge carrier setting automatically.

Persistent measurements

Jupyter notebooks crash all the time, but they are the staple of the quantum engineer. If the notebook crashes, don’t worry - your measurements and automated tuning procedures will continue in the background. Plus you can now keep track of what is happening directly in the terminal with live measurement logging. Our persistent measurement logging includes a ipykernel manager that allows users to coordinate multiple jupyter notebook sessions within a single terminal window. It is particularly useful for running long-running processes in the background, detaching from a session without terminating the processes, and reattaching later. We see this being useful going forward as quantum engineers put multiple experiments into a fridge and control them with the same lab pc.

Got a feature idea? We’re all ears. Share your requests and help us build the next generation of Stanza together.

Powering up a new quantum chip is like getting a car roadworthy — you check for leaks, make sure the engine starts, and verify that every control responds before hitting the road. In quantum hardware, those checks are tedious — each gate voltage must be swept, every contact measured, and baseline noise characterised by hand. And as we scale to quantum chips with millions of qubits, these manual checks quickly become impossible to manage.

Introducing Health Check

Health Check automates this whole procedure. It’s a family of quick, automated tests that confirm your chip is ready to go. Instead of writing new scripts for every sample, you run the Health Check routine and get a clear report on whether your device is healthy — and where its critical voltage thresholds lie. Designed for scale, Health Check is engineered from the ground up to run just as smoothly on a single test device as it does across multiplexed or wafer-prober systems.

Read the full documentation here.

Why Health Check?

Running quantum dot experiments without a health check is risky. A leaky gate or a mis-set voltage can waste hours of data collection or even damage your device. Health Check reduces that risk by running a consistent set of baseline tests every time. It helps you:

• Spot leakage early by measuring any unwanted current flowing through each gate — a key indicator of material defects or device degradation.

• Find where conduction begins by sweeping all gates together and identifying the global turn-on point.

• Calibrate individual gates (reservoirs, plungers, barriers) so you know where each gate electrode starts to pinch-off the flow of current through the channel.

When the routine finishes, you get a short list of voltages that feed directly into more advanced experiments — saving you time and protecting your hardware.

How It Works

Health Check runs four main tests in sequence:

1. Noise floor check — measures background current so later tests can tell real signals from noise.

2. Leakage test — sweeps each gate and looks for any unwanted gate current. Excessive leakage can signal fabrication issues or device wear.

3. Global accumulation sweep — ramps all control gates together to find the voltage where the channel first starts conducting.

4. Individual gate characterisation — sweeps each reservoir, plunger, or barrier on its own while others are held at the conduction point to find its cutoff voltage.

That’s it — no complicated maths or fitting functions in sight, just straightforward measurements that give you confidence in your hardware.

Built-In Stanza Advantages

Health Check isn’t a standalone script; it’s part of Stanza, our open-source control framework. That means it inherits useful benefits out of the box:

• Configuration-first design — Define all gates and parameters in YAML; no code edits required.

• Hardware-agnostic and scalable — Works across different instruments and adapts to a wide range of quantum devices through Stanza’s driver abstraction layer. Whether you’re tuning a single dot or scaling to multi-dot and multiplexed arrays, the same Health Check framework scales with you.

• Automatic data logging — Every measurement and result is saved in standard HDF5 and JSONL formats with full metadata. No manual file handling — your data’s ready for any analysis tool.

• Result chaining — Downstream routines can automatically access Health Check outputs, so you don’t have to pass parameters around manually.

Together, these features make Health Check not only easier to run but also easier to reproduce, share, and build upon.

Getting Started

Using Health Check is simple:

1. Annotate your device YAML with gate types (for example, plunger, barrier, reservoir) and voltage limits.

2. Add a health_check routine to your configuration — most parameters have sensible defaults. Just hit run, and you’re off.

3. Examine the results — noise floor, leakage report, and gate cutoff voltages — to decide your next steps.

Because all data is stored automatically in HDF5/JSONL, you can revisit results later or feed them directly into higher-level tuning routines.

Final Thoughts

Quantum devices are delicate. Making sure they’re leak-free and ready for action should be as easy as pressing a button. Health Check gives you that button — wrapping up the messy work of baseline testing into a single command. Built on top of Stanza, it benefits from configuration-first design, modularity, scalability, and standardized data formats as we build for the million-qubit era.

Health Check makes setup effortless and scalable — so you can focus less on wiring and more on discovery.

We are excited to introduce Stanza, an open-source Python framework for building tune-up sequences for quantum devices. Quantum hardware is like a musical instrument – each device needs careful tuning before it can perform. Stanza aims to make this tuning process easier, faster, and more automated for quantum engineers. By combining simple configuration files with Python routines, Stanza lets you orchestrate complex device calibrations with minimal code. No heavy frameworks required (we don’t depend on QCoDeS).

Whether you’re a seasoned quantum researcher tired of writing one-off scripts, or a software engineer stepping into the quantum lab, Stanza provides a friendly way to define your device setup, write calibration routines as Python functions, and execute them with push-button simplicity. Let’s dive into what Stanza is and how it works.

What Is Stanza?

Stanza is a Python framework for automating quantum device tune-ups from us at Conductor Quantum. In practical terms, it’s a tool to help you configure your quantum hardware and run calibration routines without the usual hassle.

Why Did We Build Stanza?

The motivation for Stanza comes from our experience in the quantum lab. Quantum device calibration is a bottleneck: as devices scale up, manually tuning dozens of voltages by hand or maintaining huge scripts becomes unmanageable [1]. Existing tools (like QCoDeS) can help, but they often carry a lot of baggage or steep learning curves for new users. We wanted something more lightweight and tailored to the specific workflow of quantum dot and spin qubit tune-ups.

Stanza was built to embrace automation and scalability from the ground up. By separating the configuration, routine logic, and execution engine, we make it easier to adapt and scale your tuning procedures. For example, when your lab moves from a single-qubit device to a 16-dot array, you can update your configuration file with new gates and add routines, without rewriting everything from scratch. The execution layer will orchestrate it all in a consistent way.

Another reason: we see Stanza as a stepping stone toward fully automated tune-up integrated with AI. Conductor Quantum’s broader mission is to remove the human bottleneck in quantum scaling [2]. We’ve developed machine learning models for tasks like identifying turn-on points, pinch-off voltages, and Coulomb blockade peaks in device data [3]. Stanza is designed to play nicely with these models. In the near future, you can imagine running a Stanza routine to collect data and then seamlessly feeding that data into our AI models for analysis – all in one pipeline. This combination of quantum device control + AI-driven analysis is what excites us, and Stanza is a core part of that vision.

Lastly, practicality: We deliberately made Stanza agnostic of specific control electronics vendor frameworks. It currently supports instruments like Quantum Machine’s QDevil QDAC-II (a 24-channel DAC for quantum control) out-of-the-box via raw PyVisa. We know every lab has a different mix of equipment, so we plan to add support for more control electronics over time, from other DACs to measurement units and beyond. If it speaks Python, we want Stanza to be able to talk to it! By not being tied to one closed ecosystem, Stanza can evolve with the needs of the community.

Key Features

Key aspects of Stanza include:

• YAML Device Configuration: YAML is a human readable format to define your device’s components in a single file. You can list out your gates, contacts (e.g. source/drain), and instruments along with their parameters and limits. This configuration-driven approach means you can tweak hardware setups or routine parameters by editing a single file, no code changes needed. For example, you might specify which gate is a “barrier” vs. a “plunger”, which channels they connect to, safe voltage ranges, etc. Stanza will load this config and understand your device’s topology.

• Simple Routine Definitions: Write tune-up sequences as simple Python functions. You just decorate a function with @routine (provided by Stanza) and implement your calibration logic inside. The function can take parameters (like voltages to sweep or which gate to tune), and those parameters are automatically populated from the YAML config at runtime. This means your routine code stays clean and focused on the experiment, not on parsing config files or setting up instruments.

• Automatic Logging and Results: Every time you run a routine, Stanza handles the data logging for you behind the scenes. It can log data to convenient formats like HDF5 or JSONL, so you never forget to hit “save” on that important measurement. Routines can also return results (like measured currents, extracted parameters, etc.), and Stanza makes it easy to retrieve those results later or pass them into subsequent routines. This is great for building multi-step calibrations – for instance, using the output of a coarse tune-up as the input for a fine-tune routine.

• Lightweight and No QCoDeS Dependency: Stanza does not rely on QCoDeS, the (often heavyweight) framework commonly used in quantum labs. Instead, Stanza is a clean-slate design tailor-made for quantum device tuning. It interfaces with hardware directly via its own drivers or lightweight libraries, so you don’t have to pull in the entire QCoDeS stack. The result is a more streamlined experience with fewer moving parts – just install Stanza and you’re ready to go.

Stanza lets you focus on the problem (like tuning up that double quantum dot and adjacent charge sensor) rather than boilerplate code.

In summary, Stanza is our approach to simplifying the quantum tuning process with a modern, lightweight framework. We can’t wait to see how you use Stanza in your labs and projects, and we’re excited to continue improving it with your input. Together, let’s automate the boring stuff, so you can focus on the exciting science and engineering that truly matters.

Happy tuning,

Hello Stanza.

Within three months of launching, Conductor Quantum released six tools for quantum device characterization and analysis. Today, we’re announcing our largest and most capable model yet:

coulomb-blockade-peak-detector-v1

Coulomb blockade is one of the most basic phenomena encountered by quantum dot engineers.

The electronic properties of quantum dots are governed by two main effects: the Coulomb repulsion between electrons (or holes) on the quantum dot, and the electron dynamics within the quantum dot being influenced by quantum effects due to confinement. This leads to quantum dots behaving as artificial atoms, exemplified by their discrete energy spectrum.

Here we focus on what arises from the Coulomb repulsion between electrons. When an additional electron is added to the quantum dot, there is an associated energy cost — referred to as the charging energy. At low temperatures, unless the electrochemical potential of the dot aligns with the bias window, tunneling of electrons onto the dot is suppressed — this is the Coulomb blockade effect.

As you sweep the gate voltage, these alignment points show up as sharp peaks in the current flowing through the device: Coulomb peaks.

By counting the number of Coulomb peaks, you are able to infer how many individual electrons you have loaded onto your quantum dot. This task, while a fundamental lego building block, is mission-critical for building a quantum computer out of electron spin qubits in semiconductor devices.

The task of peak detection may seem simple, but is one that has itched computer vision and signal processing engineers for years. Detecting peaks is easy but discerning peaks of interest from noise is not.

Many quantum engineers rely on standard packages such as SciPy’s `find_peaks` for their peak detection. This often requires manual tuning of hyperparameters and is rarely robust in noisy conditions.

Where v0 was optimized for low-resolution readout traces, v1 is 5× more capable — designed for wafer-scale cryoprobing, long sweeps, and noisy device conditions. It doesn’t just find peaks. It finds the **right** peaks — even in the most challenging traces.

Peak detection evolution — from SciPy (left) to Conductor v0 (middle) to our latest model v1 (right). Cleaner outputs, fewer false positives, and higher confidence in signal interpretation.

coulomb-blockade-peak-detector-v1 is the next step in building the most reliable control and characterization software for semiconductor quantum devices. Get in touch if you’d like to try it out and join us as we continue leveraging AI to accelerate quantum technologies.

Conductor Quantum is delighted to announce that Professor Andrea Morello has joined our Scientific Advisory Team. Andrea has been pivotal in the development of spin qubits in silicon and his research lies at the frontier of quantum technologies.

His landmark 2010 Nature paper demonstrated the world’s first single-shot readout of an electron spin in silicon.

A few years later, Andrea achieved the longest-lived quantum memory in the solid state. This record is held to this day.

His contributions to science continue outside of the lab. Andrea is a prolific science communicator with his lectures, talks and interviews viewed millions of times across the web. For many of those now entering the field of semiconductor quantum devices, it was most likely an online video featuring Andrea which captured their imagination.

To bring the next generation to the forefront of quantum technology, Andrea was the driving force behind creating the world’s first undergraduate degree in quantum engineering at the University of New South Wales (UNSW) in Sydney, Australia in 2020.

Andrea’s work continues to be pioneering with more world-firsts including the world’s first demonstration of coherent electrical control of a single nuclear spin. As well as being one of the first labs to demonstrate universal 1- and 2-qubit logic operations in silicon with greater than 99% fidelity - a benchmark for fault tolerant quantum computation.

Andrea obtained his PhD in the Kamerlingh Onnes Laboratory in Leiden (2004). After a postdoc at the University of British Columbia in Vancouver, he joined UNSW in 2004. At UNSW, he is the Scientia Professor of Quantum Engineering and Telecommunications, a Program Manager in the ARC Centre of Excellence for Quantum Computation and Communication Technology (CQC2T) and an Australia Research Council Laureate Fellow.

Over his career, Andrea has been awarded numerous prizes including the Eureka Prize, Malcolm McIntosh Prize, David Syme Prize, Walter Boas Medal, Pollock Memorial Lectureship and the Rolf Landauer and Charles. H. Bennett Award for Quantum Computing.

We are honoured to have Prof. Andrea Morello join the scientific advisory team at Conductor Quantum.

At Conductor Quantum, we’re building foundational software for quantum computers. Today, we’re excited to unveil Models —an SDK to use our machine learning models for quantum device calibration and characterization.

Why Calibration Matters

Before you can harness the power of a quantum computer, you first need to turn it on—and that’s no small feat. For quantum computers based on spin qubits in semiconductors, this process begins with trapping and manipulating single electrons. Imagine isolating a single electron from a sea of billions flowing through a semiconductor device every second. This is where quantum engineers start their journey.

But, before electrons can be trapped, engineers must ensure that the semiconductor device itself is functioning correctly. This involves a series of vital health checks:

1. Turn-On Check - Engineers determine the voltage at which current begins to flow through the device.

2. Pinch-Off Check - By sweeping the voltage on each gate electrode, they observe when the current transitions from high to low, ensuring the gates function as intended.

3. Coulomb Blockade Check - Detecting Coulomb oscillations signals the formation of a quantum dot—a critical milestone for enabling quantum transport and, ultimately, qubits.

These steps are essential because they validate whether a device is operational. They also provide key insights into device performance—vital as semiconductor quantum devices move into the foundry era, with fabs such as Global Foundries, Imec, and Intel producing chips at scale.

Our models enable users to extract reliable performance metrics both within a single wafer and across multiple wafers, empowering them to make data-driven decisions about their devices.

What’s in Our Models SDK?

We’re launching with three flagship models that focus on semiconductor quantum device health checks:

Turn-On Parameter Extraction Model

• Automatically classifies current traces as successful or unsuccessful turn-ons.

• Accurately extracts the turn-on voltage with 99% reliability.

• Helps you identify the voltage threshold at which current begins to flow through your device.

Pinch-Off Parameter Extraction Model

• Extracts critical parameters such as cutoff, transition, and saturation voltages from a pinch-off sweep.

• Enables coarse quantum dot tuning and provides insights into gate-electrode performance and device hysteresis.

Coulomb Peak Finder

• Identifies the presence of Coulomb peaks in current traces and returns their corresponding voltage values.

• This is a foundational tool for tuning algorithms, enabling adaptability across various device architectures and scalability to qubit formation.

What’s Next?

All models shown are for single parameter datasets. The natural next step are models for two-dimensional measurements, such as charge stability diagrams. For decades, engineers have manually analyzed these datasets. But as devices grow more complex, the need for automated, scalable tools becomes unavoidable. Stay tuned as we expand Models to tackle this challenge and more.

About Conductor Quantum

Conductor Quantum is an American company headquartered in San Francisco, California. We are assembling a leveraged pack of hungry animals and cracked engineers whose sole focus is to develop software to enable fault-tolerant quantum computation.

If you would like to expand the quantum frontier and solve one of the hardest technological challenges of our time, this is your chance.

Join us.

Conductor Quantum, Inc.

founders@conductorquantum.com

Conductor Quantum is thrilled to announce that Dr Silvano De Franceschi has joined the company’s Scientific Advisory Team. With an illustrious career in experimental condensed-matter physics and quantum nanoelectronics, Silvano brings a wealth of expertise.

Silvano earned his undergraduate degree in Physics from Pisa University and stayed on in Pisa to complete his Ph.D. in Physics at the Scuola Normale Superiore.

During his postdoc in TU Delft, Silvano focused on quantum transport in semiconductor quantum dots and nanowires. Silvano also mentored the likes of J.M. Elzerman, R. Hanson, J.A. van Dam, and P. Jarillo-Jerrero who famously went on to win the Wolf Prize in Physics for his work on bi-layer graphene.

Silvano’s pioneering research has uncovered insights into several significant phenomena in the realm of quantum devices. His studies on the Kondo effect in quantum dots, superconducting proximity effects in semiconductor nanowires, the potential of SiGe nanocrystals for quantum spintronics and the fascinating properties of single dopants in silicon nanoMOSFETs have all made significant contributions to our understanding of these complex systems.

Silvano’s professional journey includes research at leading institutions including the CNR-TASC Lab in Trieste and CEA Grenoble, where he currently serves as Research Director of the Interdisciplinary Research Institute of Grenoble (IRIG) and CEA Senior Fellow.

At CEA Grenoble, Silvano’s work has continued to be core to the community of semiconductor quantum devices, famously demonstrating a spin qubit in a silicon chip made with an industry-standard fabrication process (CMOS).

As a recognized leader in the field, Silvano has been honored with numerous awards, including the prestigious Nicholas Kurti European Science Prize and the Friedel-Volterra Prize. His prolific output includes over 90 publications in top scientific journals such as Nature and Science. His works have been cited over 14,000 times.

At Conductor Quantum, Silvano’s deep expertise will position the company at the forefront of quantum innovation. We are delighted to have Dr Silvano De Franceschi as part of our team.

Conductor Quantum is excited to announce that Professor Susan Coppersmith has joined our Scientific Advisory Team. A leading figure in theoretical condensed matter physics, Sue has made groundbreaking contributions across quantum computing, condensed matter theory and complex materials.

Sue authored a leading review on silicon spin qubits for quantum computing, Silicon Quantum Electronics, which has been cited over 1000 times. Additionally, she is pioneering the application of quantum computers to tackle fundamental challenges in high-energy physics, such as enhancing the discovery potential of dark matter experiments and exploring the entanglement dynamics in core-collapse supernovae.

Sue was part of the team that demonstrated the use of a two-qubit processor in silicon to perform the Deutsch–Josza algorithm and the Grover search algorithm. These are quantum algorithms which significantly outperform their classical counterparts.

Sue is currently the Head of the School of Physics at the University of New South Wales (UNSW) Sydney, where she continues to drive innovative research. After obtaining degrees from MIT and the University of Cambridge, Sue obtained her PhD in Physics at Cornell. She subsequently carried out research at Brookhaven National Labs, Princeton University, and AT&T Bell Labs, and was a professor at the University of Chicago and at the University of Wisconsin-Madison.

Sue’s numerous accolades include fellowships in prestigious institutions such as the Australian Academy of Science, the Royal Society of New South Wales, the American Academy of Arts and Sciences, and the National Academy of Sciences of the United States. Additionally, she has served in influential roles such as the Chair of the Condensed Matter and Materials Research Committee of the National Research Council of the US and the Chair of the Division of Condensed Matter Physics of the American Physical Society.

Over the course of Sue’s career, she has published over 200 papers and her work has been cited over 17,000 times.

At Conductor Quantum, we are thrilled to work with Sue to push the boundaries of quantum technology. We are honored to have Professor Susan Coppersmith as part of our team.

Quantum computing holds immense promise for solving complex problems in artificial intelligence, materials science, and optimization. Despite the hype, two challenges loom large:

• Scalability: How do we scale systems to millions or billions of qubits?

• Utilization: Once we have qubits, how do we make quantum computers practical and accessible?

These challenges are deeply intertwined. Without scalable systems, utilization remains a distant dream. And without better software tools, scaling quantum hardware will stall.

But the vision is clear: quantum computers can and should be as transformative as classical ones. The question is not just “when” but “how.”

Scaling: The Key to Quantum’s Potential

Everyone has qubits, and many platforms—superconducting circuits, neutral atoms, photonics, ion traps, semiconductor spin qubits—are approaching or have reached fault-tolerant thresholds. But scalability is not just better qubits. It’s about solving the entire system-level enigma:

• How do we make millions of qubits?

• How do we initialize them?

• How do we calibrate them?

• How do we connect them together?

Take semiconductor spin qubits as an example. Each device requires careful tuning of voltages applied to gate electrodes to isolate individual electrons and form qubits. This process varies from device to device, arising from events such as atomic defects and trapped charges.

And this is just step one. After forming qubits, engineers still need to optimize readout, pulses, and gate performance. Imagine repeating this process for billions of qubits - manual calibration simply will not scale.

Automation is not optional; it is essential.

1. Short-term wins: Automating calibration accelerates development cycles. Researchers can focus on testing and iterating, rather than spending days fine-tuning parameters. The bottleneck shifts from human effort to fixed physical constraints, such as device preparation and cryogenic thermal cycle time.

2. Long-term scale: A fault-tolerant quantum computer may require millions if not billions of qubits. Without automated procedures, building and maintaining such systems would be impossible.

Already, quantum computing as a whole is advancing: Qubits that work at higher temperatures, foundry compatible device manufacture, and logical qubit numbers in the tens. But, automation in tuning and calibration remains the critical enabler for scalable quantum devices.

Why We Started Conductor Quantum

During our PhDs, we saw firsthand how hardware innovation outpaced software development. Quantum research groups and startups had world-class engineers building cutting-edge hardware. But software? That was often an afterthought.

Without software to control and calibrate quantum devices, the number of qubits an engineer can manage is physically limited. This might be fine for early-stage academic research but it will not work for building quantum computers with millions of qubits.

We’ve been there:

• Weeks spent manually tuning experimental parameters just to get a device operational.

• Days lost to repetitive tasks that felt like they could—and should—be automated.

It was clear to us that software could be the game-changer. Conductor Quantum was born to address this gap.

What Makes Conductor Quantum Different?

At Conductor Quantum, we bring a unique blend of technical expertise and practical experience:

Brandon Severin

• PhD from Oxford specializing in AI for quantum computing in silicon.

• Developed algorithms for creating and calibrating semiconductor quantum dots and spin qubits resulting in multiple peer-reviewed publications.

• Broad software expertise, from machine learning models to hardware integration.

Joel Pendleton

• Experience at deep-tech startups, including Quantum Motion, C12 and QuantrolOx.

• Built software for tuning-up and calibrating superconducting qubits.

• Skilled in full-stack web development, machine learning and quantum control systems.

Together, we understand quantum hardware *and* how to build the software it needs to scale.

Real-World Impact: Faster, Smarter Quantum Development

Our software enables researchers to:

• Rapidly tune and calibrate devices: Minutes instead of weeks.

• Iterate faster: Measure, learn, fabricate, and improve without manual bottlenecks.

• Bridge the gap: Allow non-specialists to harness quantum power through intuitive interfaces.

Imagine a future where a researcher could design a drug, and a quantum computer simulates its interactions with the human body instantly. Conductor Quantum is paving the road as we race towards this future.

Our Vision: Democratization of Quantum

We envision a world where quantum computing is as accessible as our personal computers are today:

• Systems that are easy to use, maintain, and deploy.

• Software that abstracts away complexity, letting users focus on problems, not hardware.

• Layers of innovation—from the basic input/output system to the operating system and user-facing applications—that make quantum computing truly universal.

Today’s classical computers rely on a vast software stack we take for granted, from basic instruction sets to high-level applications. Quantum computing will require the same—and we’re building it.

Join Us in Building the Quantum Future

We are an American company headquartered in San Francisco, California. We are assembling a leveraged pack of hungry animals and cracked engineers whose sole focus is to develop software to enable fault-tolerant quantum computation.

If you would like to expand the quantum frontier and solve one of the hardest technological challenges of our time, this is your chance.

Join us.

Conductor Quantum, Inc.

founders@conductorquantum.com