Agent skills
← Index/Agent skillv0.4.11 · built 2026-08-27
Free download · 33 reference cards

The Quantinuum skill, packaged for your agent

Everything this programme learned about writing and running quantum circuits with Quantinuum's Guppy language on the Selene emulator, compressed into one skill pack: v1 API rules, halfturn angle conventions, the noise models that actually exist, resumable per-row sweeps, unitary equivalence oracles, the offline TKET compile lane, and a gotcha list where every entry cost a debugging session.

It assumes Python 3.12+ and pip install "guppylang>=1.0" — Selene ships inside guppylang. The TKET lane needs pytket and pytket-quantinuum, runs fully offline, and never spends HQCs. The three downloads hold the same cards; only the manifest, install path and host notes differ.

Going online as well? The Nexus field guide covers login from a sandbox, the failures worth avoiding, cost guards and a costed dry run on H2-1LE.

Auditing an online run afterwards? The saved-Ref ledger shows every job this project has submitted and paid for, and which of them can still be re-attached to a sweep cell.

Pick your runtime

Lovable

Hosted agent that builds and edits a web project in place.

Download · 133 KB
Installs to
.agents/skills/quantinuum/
unzip quantinuum-lovable.zip -d .agents/skills/
# then: Settings → Skills → activate "quantinuum"

Carries the Lovable-specific cards: the .pydeps vendoring convention and why it must be gitignored, the Cloudflare Worker limits that force results to ship as committed JSON, and the gated-authoring protocol for turn rollbacks.

Verify — ask the agent to compile and run the 1-qubit smoke kernel at 64 shots. If it reaches for result() instead of output(), the skill is not loaded.

Hermes Agent

Self-hosted CLI/desktop agent from Nous Research, optionally on a local model.

Download · 124 KB
Installs to
~/.hermes/skills/quantinuum/ · or a skills.external_dirs entry
unzip quantinuum-hermes.zip -d /tmp/qn
cp -r /tmp/qn/quantinuum-hermes/skills/quantinuum ~/.hermes/skills/

Also ships the three research-team profiles — runner, analyst, scribe — as SOUL.md files, a mem0 MCP snippet for shared memory, and a daily frontier-digest cron prompt. One process per profile; hand-offs between roles are files, never chat summaries.

Verify — ask the agent to compile and run the 1-qubit smoke kernel at 64 shots. If it reaches for result() instead of output(), the skill is not loaded.

OpenClaw

Resident gateway daemon with a fenced workspace and 50+ messaging channels.

Download · 134 KB
Installs to
<workspace>/skills/quantinuum/ · or ~/.openclaw/skills/ for a managed copy
unzip quantinuum-openclaw.zip -d /tmp/qn
openclaw skills install /tmp/qn/quantinuum          # workspace
openclaw skills install /tmp/qn/quantinuum --global # managed

The OpenClaw CLI does not install from zip or archive paths — unzip first and install the directory. Instructions load on demand: OpenClaw advertises the path and a sha256 marker, and the model reads SKILL.md when the frontmatter description matches the task.

Verify — ask the agent to compile and run the 1-qubit smoke kernel at 64 shots. If it reaches for result() instead of output(), the skill is not loaded.

A skill folder is executable trust: an agent will follow whatever it says. Read SKILL.md and the references/ cards before pointing an agent at them — that goes for this pack and every other one you install.

Quickstart notebooks

Four runnable notebooks — Guppy, Selene, tket and lambeq — assembled from the crawled upstream documentation rather than written from memory. Every code cell carries the page title and source URL it came from, each notebook closes with the pitfalls that apply to that library, and nothing in them touches credentials or spends a single HQC.

Guppy quickstart

The language every kernel here is written in: qubits, arrays, structs, control flow, measurement and the v1 API.

What you’ll learn
  • · Getting Started
  • · Functions
  • · Arrays
  • · Structs
+ 9 more pages
4 pitfalls
  1. `@guppy` functions must live in a real `.py` file on disk — `inspect.getsource` cannot read a REPL, `exec()` string, or notebook cell. Parameterise by generating a temp module and importing it with `importlib.util`.
  2. `angle(x)` is in **halfturns**, not radians. `angle(0.5)` is π/2 (an S gate). For a radian θ write `angle(theta / math.pi)`; when a source formula already contains an explicit π, divide it out first.
  3. Guppy v1 renamed the result API: `output(...)` replaces `result(...)`, and `measure(q)` returns a `Measurement`, so read it with `measure(q).read()`.
  4. v1 optimises on compile — pin `OptimizationLevel.Classical` for any gate-count or rewriter benchmark, or the compiler's own peepholes get credited to your rewriter.
28 code cells · 13 source pages
Download .ipynb · 21 KB

lambeq quickstart

Sentences to string diagrams to parameterised circuits, with lambeq's own training loop.

What you’ll learn
  • · Parse the sentence and convert it into a string diagram
  • · Parse the sentence
  • · Get a string diagram
  • · Define atomic types
+ 4 more pages
3 pitfalls
  1. lambeq is not installed in this repo's `.pydeps`; these cells are syntax-checked, not executed.
  2. The parser downloads a model on first use — the first cell that parses a sentence needs network access and is slow.
  3. Only Clifford segments of a generated ansatz may go through our rule-(N/M/P) canonicaliser; leave `Ry(θ)`/`Rz(θ)` cores opaque and verify them with the dense matrix oracle.
25 code cells · 8 source pages
Download .ipynb · 16 KB

Selene quickstart

The emulator that runs those kernels: simulators, error models, seeds, logs and runtime debugging.

What you’ll learn
  • · Basic Usage
  • · Simulation
  • · Error Model
  • · Runtime
+ 3 more pages
5 pitfalls
  1. No coherent / T1-T2 noise model ships with `selene_sim`. Only `IdealErrorModel`, `DepolarizingErrorModel` and `SimpleLeakageErrorModel` exist.
  2. Vendor-realistic H2 targets: `p_2q = 1.29e-3`, `p_r_01 = 0.9e-3`, `p_r_10 = 1.8e-3`.
  3. Long sweeps must be resumable via a per-row JSON cache — a single sandbox timeout otherwise wipes the whole run.
  4. Ship results as committed JSON under `src/data/demos/`, never as a live server function: the Worker runtime stubs `child_process` and blocks arbitrary filesystem reads.
  5. Compare probabilities against `4*sqrt(0.5/shots)`, not `3σ·sqrt(p(1-p)/n)` — the textbook form produces false FAILs near p = 0 or p = 1.
25 code cells · 7 source pages
Download .ipynb · 24 KB

tket (pytket) quickstart

The compiler lane: circuit construction, compilation passes, routing and backend compile.

What you’ll learn
  • · Getting Started
  • · Circuit Construction
  • · Circuit analysis
  • · Compilation
+ 6 more pages
5 pitfalls
  1. TKET **drops idle wires**. Pad with `add_blank_wires` before comparing circuits or sampling, or the TVD reads 1.0 for a perfectly correct circuit.
  2. `Ry`/`Rz`/`ZZPhase` parameters are half-turns, exactly like Guppy's `angle()`. Verify in one line: `Circuit(1).Ry(0.5).get_unitary()`.
  3. Gate every reported gate count on a global-phase-free unitary equivalence oracle at 1e-9.
  4. Never score approximation families (AQFT band truncation) against a compiler — a correctness-preserving compiler cannot find them, so the comparison is meaningless.
  5. Native ops (`PhasedX`, `Rz`, `ZZPhase`, `ZZMax`) map one-to-one onto `guppylang.std.qsystem`, both in half-turns, so a compiled circuit round-trips onto Selene with no angle conversion.
22 code cells · 10 source pages
Download .ipynb · 16 KB

All four in one archive: quantinuum-notebooks.zip 15 KB. They are generated, not hand-written — a docs refresh re-emits them, and the diff shows which upstream example moved.

Running a local model instead

No agent, no network, no API key — just a model on your own machine. This is the whole programme flattened into one plain-text file: the 77 public pages with their descriptions, the 33 method cards, the design notes, and a digest of all 61 result files with their shot counts and column names. Load it once and the model can answer across the lot.

llms-full.txt

333 KB · roughly 85k tokens · built 2026-08-27. Fits whole into a 128k-context local model; chunk it for smaller ones.

Download · 333 KB
curl -O https://arunquantum.lovable.app/llms-full.txt
ollama run llama3.1 "Answer only from this corpus. $(cat llms-full.txt)"

In LM Studio or Open WebUI, add it as a document to the chat instead of pasting it.

llms.txt

The short index in the llmstxt.org shape: one line per public page, for crawlers and for agents that would rather fetch pages than swallow the corpus.

View /llms.txt

Note — both files are generated from the repository at build time, so the numbers in them are the same numbers on the pages. Nothing was written twice by hand.

What's inside

One SKILL.md with the install steps and the numbered gotcha list, plus 33 reference cards loaded on demand so the agent only pays for what the task needs.

Language and runtime
  • guppy-language — types, angles in halfturns, control flow
  • guppy-v1-migration — output(), measure().read(), emulator builder
  • selene-runtime — simulators, noise models, seeds, H2 parameters
  • selene-run-schema — the JSON contract every driver emits
  • driver-pattern — parameterised kernels via generated .py files
  • live-sampler — interactive shot sampling
Method and verification
  • tomographic-equivalence — the 4·√(0.5/shots) threshold
  • rewriter-composition — which segments may be canonicalised
  • cross-platform-validation — independent compilers and estimators
  • pytket — the offline TKET compile lane and its idle-wire trap
  • sweep-runner — resumable per-row JSON caches
  • circuit-patterns — reusable kernel shapes
Algorithms
  • qsp-qsvt — signal processing and singular value transformation
  • shor-modexp — modular exponentiation cost
  • qpde — the ethylene QPDE circuit and the k-aliasing rule
  • laplacian-moments-tda — moment estimators and their conditioning
  • adapt-gqe — generative circuit synthesis
  • encoded-circuits — recursive gate teleportation, pFT rotations
Programme and platform
  • hardware-roadmap — Helios / Sol / Apollo / Lumos
  • nadarasa-v042-stack — how the gates fit together
  • frontend-integration — shipping results as static JSON
  • lovable-orchestration — gated authoring, rollback recovery

Where it came from

The skill is the working residue of the Nadarasa Reduction programme — a sequence of emulator gates (G1–G24) on Quantinuum's stack, and an NHS-facing arm applying the same instruments to discharge-flow and rota problems. Nothing in the pack is aspirational: each card describes something that was run.

Free to use and adapt, attribution appreciated. Guppy, Selene, TKET, H2 and Helios are Quantinuum products; this skill is an independent third-party pack and is not endorsed by Quantinuum.