Comparison

eigenkit, marqov, quantum-executor and SuperQuantX: four ways to run one circuit on many backends

All four are open-source Python libraries that sit above Qiskit, PennyLane, Cirq and the cloud SDKs so that one program runs on several backends, and they solve different parts of that problem. marqov orchestrates workflows of quantum and classical tasks. quantum-executor dispatches circuits you already have to several platforms at once. SuperQuantX and eigenkit are libraries of models and algorithms with a classical baseline beside them; eigenkit goes further on gradients, on real QPUs and on the range of algorithms.

Updated

The four libraries compared

Every cell comes from the project's own README, documentation or package page, read on 2026-11-17, at the version in the first row. All four are young and change with every release, and one of them is ours, so check the rows you rely on against the sources.

Whateigenkitmarqovquantum-executorSuperQuantX
Version, licence1.2.2, Apache 2.0[1]0.12.0, Apache 2.0[2]0.1.2, AGPL 3.0[3]0.3.0, Apache 2.0[4]
First release on PyPIOctober 2026June 2026April 2025September 2025
Python3.12 to 3.143.12 or later3.12 or later3.11 or later
What it calls itselfA library to build quantum algorithms once and run them on any simulator or quantum computerAn orchestration engine for hybrid quantum-classical workflowsA unified interface for quantum computing, built on qBraidA toolkit for quantum machine learning and optimisation research, with a classical baseline for every result
How you write a circuitIts own blocks and circuit builder, compiled to each backendIts own Circuit, converted to and from Qiskit, Braket, Cirq, pyQuil and PennyLaneIn Qiskit, Cirq, PennyLane, PyQuil or OpenQASM; it has no circuit language of its ownIts own circuit and model classes, with a backend argument
SimulatorsBuilt-in NumPy, Qiskit and Qiskit Aer, PennyLane, qsim, CUDA-Q, Qulacs, TensorCircuitA local simulator, CUDA-Q, PennyLane Lightning, and vendor emulatorsLocal Qiskit AerBuilt-in NumPy, PennyLane, Qiskit Aer, Cirq, the Braket local simulator, pytket
Real hardwareIBM through Qiskit Runtime, Amazon Braket devices, IQM ResonanceAmazon Braket, IBM Quantum, Azure Quantum, IonQ, Rigetti, QuantinuumAzure Quantum, Amazon Braket, IonQ, IBM Quantum and qBraid, through qBraidThrough Qiskit, Braket and pytket, marked untested; D-Wave annealing through Ocean, hardware untested
Gradients for trainingYes: adjoint on the built-in simulator, the backend's own method where there is one, parameter shift elsewhereNot a feature the README describesNo: it executes circuits and returns resultsInside its models; not described as a general interface
Models and algorithmsscikit-learn estimators (kernels, hybrid networks, reservoirs), PyTorch layers, VQE, QAOA, HHL, amplitude estimationNone: it runs the tasks you writeNoneA quantum SVM, VQE, MaxCut QAOA and portfolio agents
Classical baselineA benchmark module that runs quantum and classical models on the same splitsNoneNonecompare_to_classical with identical folds and equal tuning budgets
Running many jobsAsynchronous job handles for QPU and cloud backends, with a cost warning before a paid runTasks and workflows that run in parallel with scheduling and retries, on a Temporal workerAsynchronous dispatch to several backends at once, partial results, policies that split shots and merge resultsNot a feature the README describes
For AI assistantsThe documentation as llms.txt and through an MCP serverNot describedNot describedAn MCP server that exposes circuits, backend checks, classification and MaxCut

"Not described" means the project's README does not present it, not that it cannot be done with the library.

What each one is for

marqov is an orchestration engine. You mark Python functions as tasks and compose them into a workflow; independent tasks run in parallel, and the engine handles scheduling, retries and collecting results on a Temporal worker that you run yourself, or on the project's hosted platform, which is separate from the SDK[2]. Its own Circuit class converts to and from the major SDKs, and its executors cover the widest list of hardware routes of the four. It is the one to look at when the problem is many jobs, not one model.

quantum-executor is a thin execution layer on top of qBraid. You bring circuits written in Qiskit, Cirq, PennyLane, PyQuil or OpenQASM, describe in a dispatch which circuit goes to which backend with how many shots, and it runs them in parallel across providers, returns partial results while slow queues are still running, and can split shots and merge results by a policy you write[3]. It has no circuit language, no gradients and no algorithms, on purpose. Its licence is AGPL 3.0, which matters if you ship it inside a product.

SuperQuantX is the closest to eigenkit in intent. It is a toolkit for quantum machine learning and optimisation research that runs its models on several SDKs' simulators and reports a classical reference beside each result. Its README is plain about its state: examples use local simulation, remote devices are untested, and nothing in it demonstrates quantum advantage[4]. It also ships an MCP server through which an AI assistant can run circuits and comparisons.

eigenkit is a library of circuits, models and algorithms that run unchanged on a built-in simulator, on seven other simulators and on real devices from IBM, IQM and the vendors on Amazon Braket[1]. Circuits come with gradients, which is what training needs. On top of them are scikit-learn estimators and PyTorch layers, solvers for chemistry, optimisation, linear systems and amplitude estimation, and a benchmark that puts a quantum model next to classical ones on the same data.

Which one for which job

If the job isLook atWhy
Training a quantum model and comparing it with classical oneseigenkit or SuperQuantXBoth have models and a comparison protocol; eigenkit has more models, built-in gradients and documented hardware routes
Moving a trained model from a simulator to a QPUeigenkitThe same model object runs on a device by changing the provider
Running circuits you already wrote in Qiskit or Cirq on several cloudsquantum-executorIt takes the circuits as they are and dispatches them; nothing to rewrite
Splitting shots across devices and merging the countsquantum-executorSplit and merge policies are its core feature
A pipeline of many quantum and classical steps with retriesmarqovIt is a workflow engine; the others are not
Azure Quantum, Rigetti or Quantinuum hardwaremarqov or quantum-executoreigenkit does not reach them directly today
Chemistry, linear systems or amplitude estimation out of the boxeigenkitVQE with molecular Hamiltonians, HHL and IQAE ship as solvers
Letting an AI assistant run small quantum experimentsSuperQuantXIts MCP server exposes circuits and benchmarks as tools; eigenkit's MCP server serves documentation
A permissive licence inside a commercial producteigenkit, marqov or SuperQuantXApache 2.0; quantum-executor is AGPL 3.0

What eigenkit does not do

It is not a workflow engine. It has asynchronous job handles for QPU and cloud runs, but no scheduler, no retries and no way to describe a pipeline of dependent tasks. If that is the problem, marqov is built for it, and eigenkit models can run inside its tasks.

It does not take circuits written in another SDK. A circuit has to be written with eigenkit's blocks or builder to run on its backends. If you have a folder of Qiskit and Cirq circuits and want them executed as they are, quantum-executor does that and eigenkit does not.

Its hardware list is shorter than marqov's. It reaches IBM, IQM and the devices on Amazon Braket, which include IonQ, Rigetti, IQM and AQT, and has no direct route to Azure Quantum or Quantinuum.

It does not let an assistant run experiments. Its MCP server and llms.txt give an assistant the documentation, so the code it writes is current; running the code is up to you.

How to choose

  1. Decide what the unit of work is

    A model you train, a batch of circuits you already have, or a pipeline of steps. That one answer separates the libraries: a model points to eigenkit or SuperQuantX, a batch to quantum-executor, a pipeline to marqov.

  2. Check the hardware you need against the table

    Then check it against the project's own documentation, because these lists change with every release, and look for the word "tested" next to the device you care about.

  3. Check the licence

    Three of the four are Apache 2.0. AGPL 3.0 has conditions for software offered over a network that your legal team will want to read.

  4. Look at how often it is released and who maintains it

    All four are young projects with small teams. Read the changelog and the open issues before building on any of them, ours included.

  5. Run the same small problem on two of them

    A Bell state and one expectation value on a simulator take minutes in each. Differences in qubit ordering and in what a result object holds show up at once, and they are the real cost of switching later.

Run it on a real QPU with EigenOrbit RouterOne circuit on QPUs from several vendors with a single account, without a cloud account per vendor.In eigenkit: pip install "eigenkit[router]", then provider=RouterConfig(device=...) (docs).

Questions

What is eigenkit?

eigenkit is an open-source Python library from EigenOrbit, under the Apache 2.0 licence. A circuit or model is written once and runs on a built-in simulator, on Qiskit, PennyLane, qsim, CUDA-Q, Qulacs and TensorCircuit, and on real devices through Qiskit Runtime, Amazon Braket and IQM. It adds scikit-learn estimators, PyTorch layers, solvers such as VQE, QAOA, HHL and amplitude estimation, and a benchmark against classical models.

What is the difference between eigenkit and marqov?

marqov is an orchestration engine: it runs workflows of quantum and classical tasks in parallel, with scheduling and retries, and reaches a wide list of hardware. eigenkit is a library of differentiable circuits, models and algorithms. They overlap little, and an eigenkit model can be a task in a marqov workflow.

What is the difference between eigenkit and quantum-executor?

quantum-executor takes circuits already written in Qiskit, Cirq, PennyLane or OpenQASM and dispatches them to several platforms through qBraid, with policies for splitting shots and merging results. It has no models or gradients and is licensed under AGPL 3.0. eigenkit has its own circuit format, gradients, models and algorithms, and is Apache 2.0.

What is the difference between eigenkit and SuperQuantX?

Both run quantum machine learning and optimisation models on several backends and compare them with classical baselines. SuperQuantX runs on simulators and marks remote devices as untested, and ships an MCP server that lets an AI assistant run experiments. eigenkit has more models and solvers, built-in gradients and documented routes to IBM, IQM and Amazon Braket hardware.

Which Python library runs one quantum circuit on several backends?

Several do. PennyLane does it through device plugins, and qBraid through transpiling between SDKs. Among the newer open-source layers, eigenkit runs one circuit on eight simulators and three hardware routes, with gradients, marqov converts its circuit to five SDKs and runs it through cloud executors, quantum-executor dispatches existing circuits through qBraid, and SuperQuantX runs its models on six simulators.

Are these libraries free?

Yes, all four are open source. eigenkit, marqov and SuperQuantX use the Apache 2.0 licence and quantum-executor uses AGPL 3.0. Runs on real quantum computers are billed by the hardware vendor or cloud, and marqov also offers a hosted platform that is separate from the SDK.

Sources

  1. EigenOrbit. eigenkit 1.2.2 documentation: Providers, QPU and cloud workflows, Algorithms, Benchmark, Use with AI. docs.kit.eigenorbit.com and pypi.org/project/eigenkit, read 2026-11-17, 2026.
  2. D. Ryan and the Marqov contributors. Marqov SDK 0.12.0: README (workflows, circuit conversions, cloud executors, hosted platform). github.com/marqov-dev/marqov-sdk and pypi.org/project/marqov, read 2026-11-17, 2026.
  3. G. Bisicchia. Quantum Executor 0.1.2: README (unified execution, dispatch, split and merge policies). github.com/GBisi/quantum-executor and pypi.org/project/quantum-executor, read 2026-11-17, 2026.
  4. Superagentic AI. SuperQuantX 0.3.0: README (backends, classical comparison, MCP server, command line). github.com/SuperagenticAI/superquantx and pypi.org/project/superquantx, read 2026-11-17, 2026.

Run it yourself with eigenkit

eigenkit is EigenOrbit's open-source Python library: write a circuit once, run it on any simulator or QPU, and test it against a classical baseline on your own data before you invest in it or rule it out.

$ pip install eigenkit