Skip to main content
Five versions released in June. Two ways to build with AI headline the month: a Quantum Engineer plugin that brings Classiq into Claude, Cursor, and Codex, and a no-code Assistant on the platform.

Key Update: AI with Classiq

A Quantum Engineer plugin for AI coding agents, and a Classiq platform assistant

6 Enhancements

GPU simulation, molecular embedding, streamlined remote execution, and more

3 Documentation Additions

New user guides for the AI capabilities and M2M authentication

6 Bug Fixes & Deprecations

Correctness fixes and one function removal

​
AI with Classiq

Two separate AI capabilities shipped this month; if you work locally, the Quantum Engineer plugin enables your coding agent to model, synthesize, execute, and analyze quantum programs with Classiq. If you work on the platform, the Classiq Assistant turns a description into a synthesized, executable program, and answers your questions along the way. For further reading, refer to the Classiq blog.

​
Quantum Engineer Plugin

The plugin draws its capability from a set of Classiq skills paired with the Classiq MCP: it writes in Qmod (through the Classiq SDK), builds on validated components from the Classiq Library, and synthesizes on Classiq’s backend engine to produce optimized circuits. That grounding is what lets it pull ahead on hard work, such as reproducing paper implementations, research, and multi-step applications you refine over time. The plugin is available to Classiq’s enterprise customers. For more information, including a full breakdown of the skills for each phase of quantum algorithm development, see the Quantum Engineer Plugin user guide. To request access, contact us.

​
Classiq Assistant (Beta)

The new Classiq Assistant, built within the Classiq platform, takes you from an idea to a working quantum program. It accepts natural-language descriptions or circuit images, builds a Qmod-native model, synthesizes it, and opens the result on the Quantum Program page. You start from the new text input box at the center of the home page, with no prior installation or configuration needed: Classiq Assistant input box on the platform home page From there, the assistant follows you onto the Quantum Program page, opening as a side panel: Classiq Assistant panel on the Quantum Program page It keeps the context of your session, attaching the circuit you currently have open to the conversation, so you can ask it to explain what the program does, predict what results to expect, or refine the model, all in one continuous flow. It also answers conceptual questions about quantum computing, and a new chat starts fresh whenever you move to a different problem. When the program is ready, Execute takes it straight to a backend. For more information, see the Classiq Assistant user guide.

​
Enhancements

​
NVIDIA DGX Statevector Simulator

Statevector simulations can now run on a GPU-accelerated backend hosted on an NVIDIA DGX system. Selected by passing backend="classiq/dgx_simulator", it handles up to 35 qubits in single precision (float32) across both sampling and statevector modes. Exact simulation at this scale lets you validate larger algorithms, so you can catch errors in the logic before spending resources running on real hardware. Access requires specific license permissions; see DGX Statevector Simulator.

​
Wavefunction-in-DFT Embedding

Simulating a full molecule at quantum accuracy quickly outgrows the qubit budget of current hardware, yet most of the chemistry that matters happens in a small, chemically active region of it. The new EmbeddingCalculator class runs projection-based embedding to exploit exactly that: it partitions a molecular system into an active fragment, treated with a quantum algorithm such as VQE, and a surrounding environment described by DFT. The calculator drives the full DFT-and-embedding pipeline server-side and returns Hamiltonians ready to hand to a quantum solver. A notebook walking through a complete example is coming in July.

​
Streamlined Remote Execution

Two changes cut the job and queueing overhead of running on remote cloud hardware:
  • Hosted optimization on IonQ: The variational_minimize variants (standalone function and ExecutionSession methods), used for variational algorithms such as VQE or QAOA, now accept hosted=True to run the entire optimization loop on IonQ Hosted Hybrid as a single Classiq execution job. Previously each optimizer iteration was submitted as its own Classiq sample job, so the job count grew with the optimization; now the SDK submits and polls that one job, while the Classiq backend handles all communication with IonQ. Code Example: 
    with ExecutionSession(qprog, backend="ionq/...") as es:
    result = es.variational_minimize(hamiltonian, initial_params, hosted=True)
    Hosted mode has specific configuration requirements; see variational_minimize for details.
  • Persistent IBM Runtime sessions: When you run on a remote IBM backend inside a single ExecutionSession, successive primitives (sample, observe, estimate_cost, variational_minimize, and non-blocking counterparts) now reuse one IBM Quantum Runtime session rather than each opening its own. On busy hardware, where each session waits in the queue, keeping the session open across a multi-step workflow means you queue once instead of at every step. No flag needed; the session reuse happens automatically: 
    with ExecutionSession(qprog, backend="ibm/...") as es:
    counts = es.sample()              # opens one IBM Runtime session
    energy = es.observe(hamiltonian)  # reuses the same session

​
Per-Call Shot and Routing Overrides

Within an execution session, ExecutionSession.sample(), observe(), and variational_minimize() (and their submit_* counterparts) now accept optional num_shots and run_via_classiq keyword arguments that override the session defaults for that invocation only. This lets the session hold your shared defaults while you vary shot counts or execution routing per primitive call. Code Example: 
with ExecutionSession(qprog, num_shots=1000) as es:
    quick = es.sample()                 # uses the session default of 1000 shots
    precise = es.sample(num_shots=8000) # overrides for this call only

​
Visualizer Label Management

The quantum program visualizer now keeps large circuits readable with finer control over variable labels. Previously, the same variable name repeated down every wire added visual noise that could obscure the circuit’s architecture. What has been updated:
  • Adjacent repeating labels are suppressed automatically, cutting the clutter.
  • A suppressed label is never lost: hover over the wire for a tooltip with the hidden name.
  • A right-click context menu on each variable wire lets you show or hide individual labels as needed.
For example, a circuit with label repeats suppressed: Quantum program visualizer after label suppression, with repeated labels hidden for a cleaner view As opposed to the previous circuit visualization: Quantum program visualizer before label suppression, with repeated variable names cluttering every wire

​
LaTeX Export for Large Circuits

LaTeX export on the Quantum Program page now also handles very large circuits, rendering them as publication-quality diagrams.

​
Documentation Additions

  • Quantum Engineer Plugin: Install and set up the plugin in your AI coding agent, with a breakdown of the skills for each development phase and worked examples to start from.
  • Classiq Assistant: Getting Started: Access the platform assistant, generate and refine a program from a prompt, and learn the best practices for prompting it well.
  • M2M Authentication: Authenticate backend services to the Classiq platform with no human intervention required, using the non-interactive machine-to-machine flow built on the OAuth 2.0 client credentials grant.

​
Bug Fixes

  • Loops and controls that reuse variables now compile correctly: foreach/power loops that modified quantum-numeric variables used in later comparisons, and control statements whose bodies reused their condition variables, could previously produce incorrect circuits (the latter by leaking a phase onto the controlled state).
  • subscript now accepts a quantum expression as its index: Indexing a subscript with a quantum expression (for example res ^= subscript(table, a + b)) previously raised an internal error; such expressions are now lowered and synthesized correctly.
  • Classical expressions can now reuse a variable: A classical expression that reuses a variable, such as the exponent k + k in power(k + k, ...), no longer fails with “both sides of the operation are identical”; that restriction now applies only to in-place quantum arithmetic.
  • Clearer error message when exporting parametric programs to QASM 2: Exporting a parametric program with the default target_language=TargetLanguage.QASM2 now raises an indicative error suggesting QASM 3, rather than an unclear internal one.
  • The visualizer stays responsive on oversized function blocks: Running Expand All on a function block with too many child operations to render could previously freeze or crash the browser tab. It now stops with a warning that the block is too large to visualize, and the same warning appears when expanding a single oversized block.

​
Deprecations

  • exponentiation_with_depth_constraint removed: This function exponentiated a Pauli operator (Hamiltonian simulation) while automatically selecting Suzuki-Trotter parameters to fit a target maximum circuit depth. It has now been removed after a deprecation period. Use exponentiate for Hamiltonian exponentiation, or the suzuki_trotter family and qdrift when you need explicit control over the decomposition order and repetitions.
For the technical entries behind these changes, see the Changelog.