01Overview · Documentation

Talk to a quantum computer.

Ask a question in plain words. Qora turns it into a quantum circuit, runs the circuit, and reads the measured result back to you in words. Claude does the translating, both ways.

Sign-in

Solana wallet

Price

Free, 20 a day

Backend

Statevector sim

Translator

Claude

What you can ask

Anything a small quantum circuit can show: superposition, entanglement, interference, a Grover search, a quantum Fourier transform, a random number drawn from qubits. Questions that don't need a circuit, like “what is a qubit?”, get a direct answer.

What you get back

Every answer arrives as a run card. It shows the five pipeline stages as they happen, the plan and the answer. When a circuit ran, four tabs sit under the answer:

• Result: a histogram of the measured counts.
• Circuit: the circuit diagram and its OpenQASM source.
• State: every amplitude: height is probability, colour is phase (circuits up to 6 qubits).
• Verify: re-runs the circuit in your browser and checks that the counts match.

02How it works

Five stages, from words to words.

Claude sits at both ends of the pipeline. In the middle, the engine does the physics: it never guesses, it computes. Each stage streams its status to the run card as it finishes, with the real time it took.

1. 01

   Translate Claude

   Claude reads your question, plus the last four turns of the session for context, and returns a structured plan: whether a circuit is needed, a short public title, the algorithm, a one- or two-sentence plan, an OpenQASM 2.0 program and a shot count.

   Typical: a few seconds · Output: plan + OpenQASM

2. 02

   Compile Engine

   The program is parsed into a gate list and checked against the limits. If it doesn't compile, the error goes back to Claude for one repair attempt. If that fails too, the run stops, and it doesn't count against your daily limit.

   Typical: milliseconds · Output: gate list, depth, gate count

3. 03

   Execute Engine

   The engine starts every qubit in |0⟩ and applies each gate to the full statevector: 2ⁿ complex amplitudes in double precision. No noise, no shortcuts.

   Typical: milliseconds · Output: amplitudes and probabilities

4. 04

   Measure Engine

   Measurement samples the final probabilities for the requested number of shots, driven by a seeded pseudo-random generator. The seed is stored with the run, so the counts can be reproduced exactly.

   Typical: milliseconds · Output: counts per bitstring

5. 05

   Interpret Claude

   Claude receives the question, the plan, the circuit, the real counts and the exact probabilities, and explains what they mean in plain words, usually in under 200 words. The answer streams in as it is written.

   Typical: a few seconds, streamed · Output: the answer

Direct mode. When a question needs no circuit, stages 02–04 show as skipped and Claude answers directly.

OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q;              // all four boxes at once
cz q[0], q[1];    // oracle: flip the phase of |11⟩
h q;              // diffusion: reflect about the mean
x q;
cz q[0], q[1];
x q;
h q;
measure q -> c;

03The idea

Quantum computing, in plain words.

Quantum computers are programmed in circuits (gates applied to qubits, written in a language like OpenQASM), and they answer in probabilities. That is a high wall for anyone who just wants to ask a question.

Qora puts a translator on both sides of the machine. Claude turns your words into a circuit, and turns the measured counts back into words. You never have to read a circuit, but every one is there when you want to.

From Qubix to Qora. Qubix ran circuits on real IBM quantum hardware. Qora is its lighter, faster sibling: it keeps the conversation and runs every circuit on its own exact engine, so it is available at any hour and every result can be reproduced bit for bit.

Built to take real hardware. The boundary between Claude and the machine is narrow: a circuit goes in, counts come out. A real quantum processor speaks the same language, so changing the backend changes where the circuit runs, not how you talk to it.

04Wallet sign-in

Your wallet is your account.

No email, no password. Qora uses Sign-In With Solana: your wallet signs a short text message that proves you own the address. That is the whole account.

1. 01

   Connect wallet

   Pick your wallet. Qora reads your public address and nothing else.

2. 02

   Sign message

   The server writes a one-time message with a fresh nonce. You approve the signature.

3. 03

   Session opened

   The server checks the Ed25519 signature, marks the nonce as used and signs you in.

This is the exact message your wallet shows you:

{host} wants you to sign in with your Solana account:
{your address}

Sign in to Qora. This proves you own this wallet. It cannot move funds or send a transaction.

URI: {origin}
Version: 1
Chain ID: mainnet
Nonce: {one-time nonce}
Issued At: {time}
Expiration Time: {time + 10 minutes}

• A signature is not a transaction. Signing this message cannot move funds, approve tokens or spend fees. If a wallet ever asks you to approve a transaction to sign in to Qora, reject it.
• One-time and short-lived. Each nonce works once and expires after 10 minutes.
• 30-day session. You stay signed in through an HttpOnly cookie for 30 days. The server stores only a SHA-256 hash of the session token. Disconnect ends the session.
• No secrets, ever. Qora never asks for your seed phrase or private key.
• On mobile, open Qora inside your wallet's built-in browser. The connect dialog offers direct links for Phantom and Solflare.

Supported wallets

• Phantom
• Solflare
• Backpack

05Limits

Free, with sensible limits.

Qora is free to use. Limits keep it fast and available for everyone during the test phase.

The composer shows how many questions you have used today. There is also a shared daily capacity for the whole service; if it is reached, Qora tells you and you can try again later. Limits may change during the test phase.

06Models

Claude is live. More are coming.

The model works at both ends of every run: it translates your question and interprets the result. The picker in the composer lists three model families; in this test phase, only Claude runs.

• Claude

  Anthropic. Translates questions into circuits and reads results back.

  Live

• GPT

  OpenAI. Listed in the picker, not available yet.

  Coming soon

• Gemini

  Google. Listed in the picker, not available yet.

  Coming soon

Answers are grounded in the measured counts: Claude is given the real numbers, not asked to imagine them. It can still word something wrongly, which is why the histogram and the Verify tab sit right under every answer. The footer of each run names the model that produced it.

07Engine

A small, exact statevector engine.

The engine is a single JavaScript module with no dependencies. The same file runs on the server and in your browser. It keeps all 2ⁿ complex amplitudes of the register in double precision (4,096 at 12 qubits), applies gates exactly and models no noise, so results are the ideal ones a perfect quantum computer would give.

Gate set

Gate matrices follow the Qiskit definitions. u2(φ,λ) is u(π/2,φ,λ), and barrier is accepted and ignored.

OpenQASM 2.0 and 3.0 subset

• Header: OPENQASM 2.0; or OPENQASM 3.0;, with include "qelib1.inc"; or include "stdgates.inc";. Comments use // or /* */.
• Registers: qreg/creg (2.0) and qubit[n]/bit[n] (3.0). Several registers are joined in declaration order.
• Broadcast: h q; applies to every qubit of q; cx a, b; on equal-size registers pairs them up.
• Measurement: measure q -> c; and measure q[i] -> c[j]; (2.0), c = measure q; and c[j] = measure q[i]; (3.0).
• Parameters: numbers, pi or π, + - * / ^, unary minus and parentheses.
• Not supported: custom gate definitions, opaque, if, reset, loops and mid-circuit measurement. Errors report the line they occur on.

Bit ordering

Qora uses the Qiskit convention. Qubit 0 is the least significant bit, and bitstrings are printed with c[n-1] on the left and c[0] on the right. Flipping only the first qubit of three reads as 001:

qreg q[3];
creg c[3];
x q[0];
measure q -> c;   // counts: {"001": shots}

Measurement is terminal: shots are sampled from the final probabilities. If a circuit has no measure, every qubit is measured into the classical bit with the same index.

Seeded sampling

Each run draws a random 32-bit seed. A small deterministic generator (mulberry32) turns that seed into the random numbers used for sampling, so the same circuit, shot count and seed give identical counts in the browser, on the server or in Node.

08Verify

Don't take the counts on trust. Re-run them.

Every run stores its circuit, shot count and seed. The Verify tab loads the same engine module the server used, runs the circuit again on your own machine and compares the result with the stored counts. They must match exactly: you see Counts match ✓, or the mismatch.

You can do the same by hand in the browser console on Qora, with a run's QASM, shots and seed:

const { run } = await import('/js/sim.js');
const { counts } = run(qasm, { shots, seed });

• What it proves: the counts you see came from that exact circuit, sampled with that seed, by this engine. Nothing was edited after the fact.
• What it doesn't prove: that the written answer reads the counts correctly. That part is yours to judge, with the histogram in front of you.

09Token

$QORA

$QORA is Qora's token on Solana. You don't need it to use Qora: the app is free, and your wallet is only used to sign in.

The contract address will be published here and in the app's Network view. Until then, treat any token presented as $QORA as unofficial.

10Risk

Risk disclosure

• $QORA is a speculative token. Its price can fall to zero. Only use money you can afford to lose. Nothing here is an offer, an investment product or a promise of returns.
• AI can be wrong. Claude can pick an unsuitable circuit or misread a result. Check the Result and Verify tabs.
• Not advice. Nothing Qora says is financial, investment, legal or scientific advice.
• Wallet safety. Qora only ever asks for a message signature. Never share your seed phrase, and don't approve transactions you don't understand.
• Test phase. Features, limits and stored data may change or be reset.

11Terms

Terms of use

• Qora is provided as is, in a test phase, without warranties. It may be changed, limited or paused at any time.
• Use it lawfully. Don't abuse the service, try to get around its limits, or use it to produce harmful content.
• Don't put personal or confidential information in your questions. Each run gets a short public title in the live feed.
• You are responsible for your wallet and for any token transactions you make. None of them happen inside Qora.
• Qora currently runs on a classical statevector simulation of a quantum computer, not on quantum hardware. This is a test phase for integrating a real quantum computer, the same path AI took from research demos to everyday tools.
• By signing in, you accept these terms and the risk disclosure above.

12Privacy

Privacy

What Qora stores

• Your wallet address, when you first signed in and when you were last active.
• Your sessions, as a hash of the session token, never the token itself.
• The one-time sign-in messages your wallet is asked to sign, which are cleared after they expire.
• Your conversations: questions, answers, plans, circuits, counts, seeds and stage timings.

What is public

The live feed shows a shortened wallet address (first and last four characters), the run's title, algorithm, qubits, shots and top outcome. Never your question, never the answer.

What Qora doesn't collect

No email, no name, no password. Qora's database stores no IP addresses. The only cookie is the essential session cookie, qora_sid; there are no advertising or tracking cookies.

Who else processes data

Your question, recent turns of the session and the run's results are sent to Anthropic so Claude can answer. The site runs on Cloudflare, and its fonts load from Google Fonts. Circuits run on Qora's own classical simulation of a quantum computer; nothing is sent to a quantum hardware provider.