System Architecture
Overview
flowchart TD
U["Divi (Python SDK)<br/>or any REST client"] -->|"HTTPS + API token"| API["Composer API<br/>auth · credits · job store"]
U -.->|"local runs"| LM["Maestro (local)"]
D["Qoro dashboard"] --> API
API --> S["Composer scheduling<br/>cost model · packing · batching"]
S --> O["Composer orchestration<br/>queues · dispatch · aggregation"]
O --> MF["Maestro simulator fleet<br/>CPU and GPU tiers"]
O --> QI["QPU Interfaces"]
QI --> IBM{{"IBM"}}
QI --> IQM{{"IQM"}}
QI --> BR{{"AWS Braket"}}
MF -->|"results"| API
O -->|"results"| API
Components
Divi is where workloads are written. It turns a problem into circuits, groups observables, applies error-mitigation transforms, merges circuits from many sub-programs into large batches, and submits them to a backend. Local backends run Maestro in-process. The cloud backend, QoroService, talks to the Composer API. See Divi.
The Composer API is the entry point to Qoro’s cloud. It authenticates API tokens, checks access tier and credits, stores jobs, circuits, and results, and exposes the catalogue of simulator clusters and QPU systems a user can target. Divi and the dashboard both use it.
Composer scheduling and orchestration turn a stored job into executable work. They predict what each circuit will cost to run, pack circuits onto QPU qubits, size message batches for the simulator fleet, warm up capacity, dispatch work through message queues, and gather results. See Composer.
Maestro runs on both sides. On a laptop it is Divi’s default local simulator. In the cloud it is a fleet of workers that take batches from the queue, pick a simulation method for each circuit, apply noise models when requested, and write results back. See Maestro.
QPU Interfaces are vendor-specific workers. Each compiles circuits against its device’s calibration, submits them through the vendor SDK, optionally applies readout-error mitigation, and posts counts back to Composer. See QPU Interfaces.
The life of a cloud job
- Create. The client creates a job with a type (sample counts, compute expectation values, or characterise a QUBO) and exactly one target: a simulator cluster or a QPU system. Simulator jobs can carry a Maestro configuration; QPU jobs can carry vendor-specific device options. Access tier, credit balance, and per-target permissions are checked here.
- Upload. Circuits are uploaded in compressed chunks as OpenQASM. Variational workloads can upload a single parametric template plus parameter sets, which are bound on the server. Observables travel as Pauli strings. As each circuit arrives, a cost model predicts its run time.
- Schedule. Once the upload is finalised, the job is queued. The next step depends on the target:
- Simulator target. Circuits are grouped into batches sized by predicted cost and placed on the queue for the requested simulator tier. Capacity for that tier is warmed up ahead of the work.
- QPU target. Circuits are assigned to the QPUs in the system that are online. With packing enabled, several small circuits share one device run on disjoint qubits. Each device’s batch is serialised and handed to that vendor’s interface worker.
- Execute. Maestro workers simulate their batches, choosing a simulation method per circuit unless the job fixed one. Interface workers compile, submit, and wait for the vendor.
- Return. Results flow back to the job store. Packed QPU results are split back into per-circuit counts. The job completes when every circuit has a result, and credits are charged for the run time used.
- Collect. The client polls job status and pages through results. Divi does this automatically and feeds the results into the next optimisation step.
A job can be cancelled at any point. Cancellation reaches in-flight vendor jobs as well as queued work. A job that can never run, for example because of an invalid device option or a rejected vendor account, fails fast with the reason attached.
Job statuses: PENDING, SCHEDULED, RUNNING, PAUSED, COMPLETED, FAILED, CANCELLED, INSUFFICIENT_CREDITS, TIMED_OUT.