Qoro builds tools that take full advantage of today’s quantum hardware. In our latest experiments on IBM’s Heron 2 quantum processors, we explored how automated circuit packing can drive down costs and runtime while maintaining high-quality results. The results show that with the right strategy, users can stretch their quantum compute budget significantly without compromising performance. We show that a naïve approach to running QAOA can cost $10,000s, where with some clever tricks offered through Qoro’s software, the costs can be significantly reduced, to $100s.
Hardware-Level Parallelization: Circuit-Packing
Today quantum computers are mostly accessed through the cloud, and cost-of-use is usually based on how long (in time) a quantum program runs on a quantum computer. It’s therefore important to minimize the runtime of a quantum program in order to save cost (and using quantum computers isn’t cheap!). Through Qoro’s software stack, we give users the possibility to use a technique we call “circuit packing”. Circuit packing can be explained with the following example.
Imagine you have access to a 100-qubit quantum computer, but your quantum program only requires 10 qubits. If you need 100,000 samples of that 10-qubit circuit, you can use circuit packing to dramatically reduce resource usage. By duplicating the 10-qubit circuit across ten non-overlapping 10-qubit blocks, you can collect 10 samples per shot, requiring only 10,000 total shots — a 10x reduction. After post-processing to separate and organize the results, you still end up with the full 100,000 samples.
Circuit packing doesn’t just save time and cost, it also helps when running batches of different circuits. Multiple circuits can be loaded simultaneously, reducing the number of programs you need to run.
However, packing circuits manually is tedious and error-prone. Worse, without careful handling, it can introduce additional crosstalk and noise, degrading the quality of your results.
The question is: Does this deteriorate the results significantly? This is what we explore in this series of experiments. (Spoiler: The results are pretty good!)
Quantum Cloud Computing
Quantum cloud computing refers to the use of quantum computers accessed remotely via the internet, rather than running them locally. Because quantum hardware is extremely delicate, expensive, and housed in specialized facilities (often requiring cryogenic temperatures and strict isolation), it’s not practical for most users to own or operate one. Instead, major providers like IBM, Rigetti, IQM, IonQ, and others offer access to their quantum processors through cloud platforms.
This model allows researchers, developers, and companies to write quantum programs on their local machines and submit them to real quantum devices hosted in remote data centers. Quantum cloud services typically include APIs used to submit jobs, queuing and batch job services, and have a usage-based pricing model. It allows users to access to cutting-edge quantum hardware and enables experimentation and application development at scale, without the need to maintain quantum infrastructure in-house.
Despite the availability of cloud-based quantum computing, the cost remains prohibitive for most users who want to experiment at scale. For instance, IBM’s Pay-As-You-Go plan is priced at $96 per minute (https://www.ibm.com/quantum/pricing), while reserving a device on AWS Braket can run into thousands of dollars per hour (https://aws.amazon.com/braket/pricing/). In one of our tests, running just 100 circuits with 50,000 samples each took about 22 minutes on IBM’s basic plan — costing over $2,000. Without access to credits, academic partnerships, or enterprise-level budgets, running quantum algorithms on real hardware is currently out of reach for the average user.
At Qoro, we are developing methods that give users access to techniques that will drastically reduce runtime.
One key strategy is parallelization: breaking down large quantum programs into smaller, independent tasks that can run in parallel across multiple devices or simulators. This allows users to take full advantage of all available resources, whether quantum or classical, to speed up execution.
Another core technique is workload reduction, such as using circuit packing to maximize the utilization of qubits per shot, or using techniques to reduce the total number of shots and circuits to execute while still achieving the desired statistical accuracy.
By embedding these capabilities into tools like Divi, we’re creating an environment where users can prototype and test utility-scale quantum programs — without needing a massive budget or custom infrastructure. Our goal is to bring high-performance, cloud-accessible quantum computing to a broader community of researchers, developers, and innovators.
Automated Circuit Packing with Composer
As part of the features offered in our software-stack we’ve built an automated system, integrated into our Composer tool, that takes user-submitted circuits and optimizes their allocation for execution on quantum hardware. Composer inspects the topology, connectivity, and qubit availability on a quantum backend and dynamically “packs” circuits—placing multiple quantum programs within a single circuit. The single circuit, much wider than the original, is the circuit that gets sent to the cloud quantum computer. The number of shots will be reduced or the number of jobs will be fewer, saving in total overall runtime. With the coming of 1,000+ qubit systems, the cost savings can be significant
In our tests, we took an optimization problem, namely the MaxCut problem, for a 20-node graph using Divi to construct the program. MaxCut is a practical task that can be used in fraud detection, graph clustering, network design, and more. A great tutorial video on building QAOA programs for MaxCut can be found here, by Olivia Lanes from the IBM Quantum team.
The code to solve a MaxCut problem in Divi is the following:
from divi.qprog import GraphProblem, QAOA
from divi import QoroService
N_NODES = 20
graph = generate_random_graph(N_NODES, N_EDGES)
qaoa_problem = QAOA(
problem=graph,
graph_problem=GraphProblem.MAXCUT,
n_layers=1,
optimizer=Optimizers.MONTE_CARLO,
max_iterations=1,
is_constrained=True,
backend=QoroService(
QORO_API_KEY, use_packing=True, shots=50000
),
grouping_strategy="qwc",
)This code generates a random graph with 20 nodes and sets up a QAOA (Quantum Approximate Optimization Algorithm) problem using Divi. We define the problem as a MAXCUT instance and configure the optimizer to use the Monte Carlo method, which densely samples the parameter space — here just one iteration is enough. The backend is provided via QoroService, with use_packing=True to enable automatic circuit packing, significantly reducing the number of shots and cost.
Notably, the user does not need to specify which quantum computer to use, Composer will handle device selection automatically. Additionally, we enable observable grouping (grouping_strategy=”qwc”), which reduces the number of circuits from the original count of 2550 circuits to just 100, (a 96% workload reduction!) improving efficiency without sacrificing any accuracy.
The data speaks for itself: circuit packing can yield high-quality results while dramatically reducing execution costs. In our experiments, we compared the cut value obtained from a classical heuristic MAXCUT solver with the results produced by QAOA on quantum hardware. We tracked runtime, cost, and solution quality to understand how these factors relate.
In the first test, we submitted 100 circuits without any packing, running 50,000 samples per circuit sequentially. This resulted in a runtime of about 22 minutes and a total cost of $2,168.00. In the second test, we enabled 3-way circuit packing, which utilized 60 of the available 156 qubits. The runtime dropped significantly, and the cost fell to $738.20 — a more than 50% reduction. Interestingly, the solution quality actually improved.
In the final test, we increased packing to use 140 qubits, letting the system run many circuits in parallel. This entire process — packing, resource allocation, and scheduling — was fully automated by Composer, requiring no manual intervention. While the raw optimality dropped to about 63%, we applied error mitigation techniques to bring it back up to 78%, all while achieving an 83% cost reduction compared to the unpacked baseline.
To put this in perspective: naively running all 2,550 circuits with 50,000 shots each at an estimated 0.22 minutes per circuit would result in a cost of approximately $53,856. With automated circuit packing, that total cost dropped to just $360 — with no additional effort required from the user.
Summary
As quantum hardware becomes more accessible via the cloud, the bottlenecks are no longer just technical — they’re economic. Without workload optimization, running large-scale quantum algorithms can quickly become prohibitively expensive. Our results demonstrate that with smart automation — particularly through techniques like circuit packing, observable grouping, and hybrid execution — we can unlock substantial savings in both cost and runtime, without compromising result quality.
More importantly, these optimizations are fully abstracted away from the user. With Divi and Composer developers don’t need to worry about device selection, packing strategies, or shot management — they just write quantum programs, and the system takes care of the rest.
We believe this kind of automation is essential for moving from small demos to real, utility-scale quantum applications in a cost-effective manner. It’s not just about squeezing more out of today’s hardware — it’s about making quantum computing usable by more people, in more domains, today.
