Quantinuumclaw

Enables building and deploying quantum computing applications with Quantinuum, Guppy, Selene, and Fly.io. Use for the OpenClaw Clinical Hackathon, clinical o...

Security Scan

The skill and its files are coherent with its stated purpose (scaffolding, running, and deploying Guppy/Selene quantum apps to Fly.io); there are no obvious attempts to exfiltrate secrets or perform unrelated actions, but the package lacks provenance and has a few minor documentation/metadata inconsistencies you should review before use.

Purpose & Capability

The repository contents (scripts to scaffold backends/frontends, a Selene FastAPI template, Fly.io deploy helpers, and a Lovable React frontend) match the skill's declared purpose of building and deploying Quantinuum/Guppy/Selene apps. No unrelated binaries or credentials are requested in the metadata.

Instruction Scope

SKILL.md instructs the agent and user to run local Python scripts, edit generated code, set Fly.io secrets for hardware access, and deploy to Fly.io. The instructions stay within the expected scope (scaffolding, running quantum circuits, deployment). They explicitly warn about PHI and recommend storing API keys in Fly.io secrets. No instructions ask the agent to read arbitrary host files or exfiltrate unrelated data.

Install Mechanism

The skill is instruction-only (no registry install spec), so nothing is automatically downloaded by the platform. The docs recommend installing external tools (flyctl via curl install script) and Python/Node dependencies when you run the templates locally; those are normal but carry the usual risk of running install scripts obtained at the time of user execution. Review any remote install commands (e.g., curl | sh) and the scripts that invoke CLI tools before running them.

Credentials

Registry metadata lists no required environment variables, which is reasonable for a template skill. However the templates and docs reference optional secrets/env vars (QUANTUM_API_KEY, VITE_API_KEY, API_KEY, PORT, QUANTUM_HARDWARE) that are needed when targeting real hardware or enabling auth. This is not malicious but is a small inconsistency between metadata and file contents—users must still supply these secrets when using hardware or production deployments.

Persistence & Privilege

The skill does not request always:true and does not appear to modify other skills or system-wide settings. It is user-invocable and can be run by the agent, which is the platform default and expected for a scaffolding/deployment skill.

Assessment

This bundle appears to do what it says — scaffold a FastAPI backend (Selene), example Guppy circuits, a React frontend, and helpers to deploy to Fly.io. Before you use it: 1) Verify provenance — the README points to a GitHub repo (arunnadarasa/quantinuumclaw); check that upstream source and commits. 2) Inspect scripts that run automatic actions (scripts/flyio_deploy.py, scripts/create_quantum_app.py, scripts/setup_selene_service.py) for any network calls or shell execution you don’t expect. 3) Don’t put PHI in inputs; follow the SKILL.md admonition to use synthetic/de‑identified data. 4) Secrets: when targeting real hardware set QUANTUM_API_KEY via Fly.io secrets (do not commit keys or put them in frontend code). Also review the frontend proxy and CORS settings (templates allow_origins=["*"]) and restrict them for production. 5) When told to install tools (flyctl via curl|sh or pip/npm), prefer installing from trusted package sources or review the install script first. If you want higher assurance, run the templates locally in an isolated dev environment, review Dockerfile and deploy scripts, and scan the repository with your standard supply-chain/security tooling.

QuantinuumClaw – Quantum Guppy/Selene Stack

This skill provides everything needed to build production-ready quantum applications using Quantinuum (hardware/emulator), Guppy (quantum language), Selene (FastAPI backend), and Fly.io (deployment), with optional Lovable frontend. It is tuned for the OpenClaw Clinical Hackathon and general quantum web apps.

When to Use This Skill

Use when:

• Building for the OpenClaw Clinical Hackathon or any clinical/healthcare quantum project
• Building web applications that use quantum computing (optimization, chemistry, ML, random, crypto)
• Deploying quantum algorithms as REST APIs or creating dashboards for quantum results
• User mentions: clinical, healthcare, drug discovery, treatment optimization, patient stratification, molecular simulation, clinical trials, Guppy, Selene, Fly.io

Example requests: "Build a quantum portfolio optimizer with a web interface" · "Deploy my Guppy algorithm to the cloud" · "Create a clinical molecular simulation demo" · "Set up a quantum ML service on Fly.io"

Stack at a Glance

Component	Role
Quantinuum	Quantum hardware (H-series) or emulator
Guppy	Quantum programming (circuits, gates, measurement)
Selene	FastAPI backend that runs Guppy and exposes REST API
Fly.io	Hosts the Selene backend in the cloud
Lovable	React/TS frontend template; use assets/lovable-template/ or any app that calls the Selene API

Quick Start (One Command)

From the repo root:

python3 scripts/create_quantum_app.py \
  --app-name "clinical-demo" \
  --use-case "chemistry" \
  --description "Clinical molecular simulation" \
  --deploy

Then set VITE_API_URL in the frontend to your Fly.io app URL (e.g. https://clinical-demo.fly.dev).

Clinical use-case → --use-case mapping:

Clinical idea	--use-case	Notes
Drug discovery / molecular sim	chemistry	Molecules, energy, properties
Treatment / resource optimization	optimization	QAOA-style optimization
Patient stratification / ML	ml	Quantum ML models
Trial randomization	random	Quantum RNG
Secure keys / protocols	crypto	Quantum-safe crypto

General use cases (portfolio, finance, etc.) also use optimization, chemistry, ml, random, crypto, or finance. See references/clinical-use-cases.md for detailed clinical mappings.

Full Workflow: Creating a Quantum Application

Step 1: Define the use case

Identify the problem (optimization, simulation, ML, cryptography, clinical, etc.).

Step 2: Create Selene backend

python3 scripts/setup_selene_service.py \
  --app-name "my-quantum-app" \
  --use-case "chemistry" \
  --description "Quantum chemistry simulator"

This creates a backend dir with FastAPI, health check, Dockerfile, and fly.toml.

Step 3: Implement your Guppy circuit

Edit my-quantum-app/main.py → QuantumService._run_real_quantum(). Use references/guppy_guide.md for syntax. For clinical: chemistry (molecule, shots, precision), optimization (objective, constraints), ML (features, epochs).

Step 4: Deploy to Fly.io

python3 scripts/flyio_deploy.py --app-name "my-quantum-app" --service-dir "my-quantum-app" --region "lhr"

Set secrets with fly secrets set; use emulator for demos if preferred.

Step 5: Frontend

Use assets/lovable-template/ or run:

python3 scripts/lovable_integrate.py \
  --app-name "my-frontend" \
  --backend-url "https://my-quantum-app.fly.dev" \
  --quantum-use-case "chemistry"

Then npm install and npm run dev in the frontend dir.

Step 6: Connect and test

Point frontend VITE_API_URL to the Fly.io backend; hit /health to verify.

Clinical Use Case Cheat Sheet

• Drug discovery / molecular simulation: chemistry — VQE-style energy/property in Guppy; expose molecule type and params via API.
• Treatment / resource optimization: optimization — Define objective (cost, wait time); run QAOA in Selene; display results in UI.
• Patient stratification / classification: ml — Map patient features to model inputs; return risk/stratum or classification.
• Randomization (e.g. trials): random — Quantum RNG from Guppy; expose bits/shots in API.
• Security / key material: crypto — Key generation or quantum-safe primitives; keep keys on backend only.

Data and Compliance (Clinical / Hackathon)

• Demos: Use synthetic or de-identified data only. Do not send real PHI to quantum backends or store in Fly.io without a compliance plan.
• API keys: Store in Fly.io secrets (fly secrets set), never in code or frontend.
• Production: Add auth, rate limiting, and consider HIPAA/DPA; restrict CORS in Selene.

Resources

scripts/

• create_quantum_app.py — All-in-one: backend + deploy + frontend
• setup_selene_service.py — Scaffold Selene backend
• flyio_deploy.py — Deploy to Fly.io
• lovable_integrate.py — Frontend wired to backend URL

references/

• guppy_guide.md — Guppy syntax, gates, circuits, examples
• selene_api.md — Endpoints, request/response, errors, jobs
• flyio_config.md — Fly.io scaling, regions, secrets, monitoring
• lovable_patterns.md — Frontend patterns, dashboard, API client
• clinical-use-cases.md — Detailed clinical use-case mappings and compliance notes

assets/

• selene-template/ — Backend boilerplate (main.py, Dockerfile, fly.toml, .env.example)
• lovable-template/ — React/TS frontend with QuantumDashboard and API client

Advanced: Multi-Quantum Use Cases

• Optimization dashboard: Selene + QAOA/VQE; Lovable with sliders; Fly.io with scaling.
• Chemistry explorer: Guppy molecular simulations; 3D viewer; optional persistent storage.
• Quantum ML API: Selene exposing QNN/QSVM; Lovable for training/predictions; Fly.io (GPU if needed).

Performance, Cost, and Security

• Queuing: Use job queues for long-running quantum jobs; WebSockets or polling in frontend.
• Caching: Cache identical computations to reduce quantum hardware cost.
• Fly.io: Scale to zero when idle (min_machines_running = 0); use references/flyio_config.md for VM sizing.
• Security: No API keys in frontend; rate limiting on Selene; HTTPS in production; see references/selene_api.md for auth patterns.

Troubleshooting

• Guppy import error: pip install guppy in backend; or use mock mode for demos.
• Selene not starting: Check fly.toml, fly logs, and env vars.
• Frontend can’t connect: Verify VITE_API_URL, CORS in Selene, and curl .../health.
• Fly.io deploy fails: fly deploy --clean; fly logs --phase build; ensure fly auth login.
• Quantum results wrong: Validate circuit logic and measurement; test with emulator first.

Next Steps

After initial setup: monitor quantum usage/costs; add auth to Selene if public; improve error handling and logging; consider persistence for job history.

---

For detailed clinical use-case specs and compliance reminders, see references/clinical-use-cases.md.