Open-core local mode vs hybrid cloud quantum execution

QCOS operates on a Hybrid Software Model:

Open-Core Local Mode (Free): Runs simulations on your own laptop/server using CPU or GPU resources. No computing credits are charged.
Hybrid Cloud Mode (SaaS/Paid): Routes execution jobs to public QPU providers (IBM Quantum, Rigetti, IonQ, Quantinuum, Pasqal) or cloud GPU clusters managed by SoftQuantus.

Licensing boundaries and feature sets are verified locally and online using the QuantumLock licensing engine.

1. Open-Core Local Mode

In Local Mode, QCOS runs directly inside your infrastructure or on your development machine. This is ideal for development, testing, and debugging circuits before submitting them to expensive quantum processors.

Local CPU Simulation

By default, the SDK and CLI will execute circuits using the built-in CPU statevector simulator.

Engine: Qiskit Aer
Limits: Configured by your license tier (e.g., Trial is restricted to 10 qubits, Professional allows up to 50 qubits).
Execution Cost: Free

Local GPU Simulation

For larger circuits, you can run QCOS on GPU-accelerated local instances (utilizing CUDA/NVIDIA hardware). To execute using local GPU simulation:

Ensure NVIDIA CUDA Toolkit is installed and your system has a compatible GPU (e.g., T4, A10, A100).

Set the execution target backend to aer_simulator_gpu in your circuit submission:

# Python SDK example
job = client.execute(
    circuit_qasm=qasm_string,
    backend="aer_simulator_gpu",
    shots=2048
)

Running the Local Worker Daemon

If you are running QCOS in an enterprise/on-premise hybrid setup, you can launch a local worker daemon to process jobs from your internal queues:

# Start the local worker daemon (CPU mode)
python -m worker_local --max-jobs 0 --idle-timeout 300 --poll-interval 5

2. Hybrid Cloud Mode

When you promote your workload to cloud execution, QCOS acts as an intelligent control plane, handling routing, queuing, and retrieval.

Cloud Providers & Plans

Your allowed cloud backends are determined by your SoftQuantus subscription tier:

Plan	Allowed Backends	Cost Model
Trial	CPU Simulators only	Free
Professional	CPU + T4 GPUs + Rigetti QPUs	Compute Credits
Enterprise	CPU + T4/A10/V100 GPUs + Rigetti + IonQ QPUs + LUMI HPC	Compute Credits
HPC	All backends including A100 GPUs + IonQ Aria/Forte + Quantinuum + Pasqal QPUs	Compute Credits / Dedicated

Promoting Jobs to Cloud QPU

To run on cloud hardware, simply change your backend target name to a QPU identifier and submit via the CLI/SDK:

# CLI submission to Rigetti QPU
softqcos run circuit.qasm --backend rigetti --shots 1024

# Python SDK submission to IonQ QPU
job = client.execute(
    circuit_qasm=qasm_string,
    backend="ionq.aria",
    shots=1000
)

3. QuantumLock Licensing

QuantumLock controls commercial entitlements and limits (such as maximum qubits and allowed backends).

Activating Your License

When you purchase a QCOS License, you receive a license key in the format QLOCK-XXXX-XXXX-XXXX-XXXX. You must exchange this key for a local signed license file:

# Activate key via CLI
softqcos activate QLOCK-01C2-AA0F-2501-3B04

This command contacts the validation server and downloads a signed .qlicense file containing cryptographic signatures (RSA-4096 + post-quantum ML-DSA) to your machine:

Default Path: ~/.softqcos/license.qlicense

Validation Modes

You can configure how the licensing engine validates your entitlement by setting the QUANTUMLOCK_VALIDATION_MODE environment variable:

online: Every execution validates the license directly with the SoftQuantus API. Best for cloud-connected servers.
offline: The engine verifies the cryptographic signature of the local .qlicense file completely offline. Best for secure, air-gapped systems.
hybrid (Default): The engine validates the license signature offline locally for speed, but checks in with the online API periodically.

Offline Grace Period

In hybrid mode, if the licensing engine cannot connect to the internet (e.g., due to a temporary network drop), it permits a 7-day offline grace period. During this period, local simulation features remain fully functional. If connection isn’t restored within 7 days, local runs will be blocked until a successful check-in occurs.

4. Usage Walkthrough

Here is a full step-by-step example of switching from a local simulation to cloud QPU execution.

Step 1: Create a Circuit File

Save the following OpenQASM circuit as bell.qasm (a standard two-qubit entangled state):

OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0],q[1];
measure q[0] -> c[0];
measure q[1] -> c[1];

Step 2: Set Environment Variables

Configure your terminal environment variables:

export QCOS_API_KEY="sqt_live_your_key_here"
export QCOS_API_URL="https://api.softquantus.com"

Step 3: Run Locally (Free Simulator)

Submit the job to execute on the local CPU simulator:

softqcos run bell.qasm --backend simulator_aer --shots 1024

This returns counts instantly:

{
  "status": "completed",
  "backend": "simulator_aer",
  "execution_time_seconds": 0.042,
  "counts": {
    "00": 510,
    "11": 514
  }
}

Step 4: Run on Cloud QPU

Promote the execution to run on the IonQ Cloud processor:

softqcos run bell.qasm --backend azure_ionq --shots 1024

Because QPU time is billable, the CLI will estimate the cost, deduct credits from your budget, place the job in the queue, and return a tracking job ID:

Job submitted successfully. Job ID: job_ionq_7f8d1c
Estimated credit cost: 12.5 credits
Queue position: #3

Step 5: Check Job Status and Retrieve Results

Monitor the job queue status:

softqcos status job_ionq_7f8d1c

Once completed, fetch the physical processor results:

softqcos results job_ionq_7f8d1c

​1. Open-Core Local Mode

​Local CPU Simulation

​Local GPU Simulation

​Running the Local Worker Daemon

​2. Hybrid Cloud Mode

​Cloud Providers & Plans

​Promoting Jobs to Cloud QPU

​3. QuantumLock Licensing

​Activating Your License

​Validation Modes

​Offline Grace Period

​4. Usage Walkthrough

​Step 1: Create a Circuit File

​Step 2: Set Environment Variables

​Step 3: Run Locally (Free Simulator)

​Step 4: Run on Cloud QPU

​Step 5: Check Job Status and Retrieve Results