Skill Invocation Guide

Overview

This chapter covers the CLI’s Skills system, and applies to the following scenarios:

You want to browse the set of skills available in the current CLI.
You want to directly invoke a specific quantum algorithm or PDE solver workflow.
You are not sure whether to invoke a top-level index skill or a specific leaf skill.
You want to use Tab autocomplete to quickly locate a skill by name.

This chapter covers the following topics: the concept of a skill, the /skills multi-level directory tree, direct invocation via /<skill>, Tab autocomplete, viewing skill details with /info and /cat, the distinction between index skills and leaf skills, and typical invocation examples.

What Is a Skill

A skill is a built-in Agent capability unit in the CLI, used to define how the Agent should behave for a specific kind of task.

Every skill corresponds to a SKILL.md description file, which defines:

The goal and scope of the skill.
Which tools the Agent should invoke, and in what order.
The input and output conventions.

Skills are organized as a file-system hierarchy. For example, the directory structure of the current release looks like this (the exact contents may vary across versions):


quantum-skills/                 [index]
  algorithms/                   [index]
    cryptography/               [index]
      shor                      Shor's algorithm
      discretelog               Discrete logarithm
      simon                     Simon's algorithm
    primitives/                 [index]
      amplitude-amplification   Amplitude-amplification's algorithm
      amplitude-estimation      Amplitude-estimation's algorithm
      hadamard-test             Hadamard-test's algorithm
      hadamard-transform        Hadamard-transform's algorithm
      hamiltonian-phase         Hamiltonian-phase-estimation's algorithm
      -estimation
      quantum-phase-estimation  Quantum-phase-estimation's algorithm
    linear-systems/             [index]
      hhl                       HHL's algorithm
      lcu                       LCU's algorithm
      quantum-signal-processing Quantum-signal-processing's algorithm
    hamiltonian-simulation/     [index]
      qdrift                    Qdrift's algorithm
      trotter                   Trotter's algorithm
    schrodingerization/         [index]
      advection-schrodinger     Advection-schrodingerization's algorithm
      -ization
      backward-heat-1d          Backward-heat-1d-schrodingerization's algorithm
      -schrodingerization
      heat-1d-schrodinger       Heat-1d-schrodingerization's algorithm
      -ization
      heat-2d-schrodinger       Heat-2d-schrodingerization's algorithm
      -ization
    quantum-machine-learning/   [index]
      qaoa                      QAOA's algorithm
      qcbm                      QCBM's algorithm
      qnn                       QNN's algorithm
      vqc                       VQC's algorithm
      vqe                       VQE's algorithm
    quantum-error-correction/   [index]
  simulators/                   [index]
    pennylane                   Pennylane's simulator
    qiskit                      Qiskit's simulator
    unitarylab                  Unitarylab's simulator
create_pde_task                 PDE solving task
submit-algorithm-library-task   Submit an algorithm task

Index Skills vs. Leaf Skills

Every skill document belongs to one of the following two categories:

Leaf skill: A directly executable capability, such as shor or create_pde_task.
Index skill: A directory entry point that organizes and aggregates sub-skills; it still contains finer-grained skills underneath. When you invoke an index skill, the Agent will use the references declared inside it to resolve and locate an appropriate sub-skill, layer by layer.

The type of a skill is not determined by the wording of its description — it is determined by the actual file-system structure. Whether the document uses See reference:, Reference:, or some other custom reference format, the CLI will correctly identify the type based on the directory layout.

When you are unsure which level to invoke, it is generally recommended to invoke the higher-level index skill first, and let the Agent recursively locate a more specific capability node on its own.

`/skills`: Browsing the Multi-Level Directory Tree

/skills displays the full skill tree according to the real file hierarchy, without any additional grouping or merging. For example:


[agent│deepseek-v4-pro] › /skills
? Select a skill:
  » quantum-skills            [index] · 2 items  Root entrypoint for the quantum-skills package. Us…
  create-pde-task           Create a partial differential equation (PDE) solving task. U…
  submit-algorithm-library-task  Submit a computation task from the algorithm library when th…
  Cancel

After entering quantum-skills:


? Select a skill [quantum-skills]:
» ← Back
  ★ Invoke this index directly: quantum-skills    Root entrypoint for the quantum-skills package. Use this ski…
  algorithms                [index] · 7 items  A collection of quantum algorithms implemented usi…
  simulators                [index] · 3 items  A collection of quantum simulators for quantum pro…
  Cancel

Continue into algorithms:


? Select a skill [quantum-skills/algorithms]:
» ← Back
  ★ Invoke this index directly: algorithms    A collection of quantum algorithms implemented using Unitary…
  cryptography              [index] · 3 items  Quantum algorithms that attack classical cryptogra…
  hamiltonian-simulation    [index] · 2 items  Quantum Hamiltonian simulation methods for approxi…
  linear-systems            [index] · 3 items  A set of quantum algorithms for solving linear sys…
  primitives                [index] · 6 items  A collection of fundamental quantum computing prim…
  quantum-machine-learning  [index] · 5 items  Variational quantum algorithms for optimization an…
  schrodingerization        [index] · 4 items  Quantum PDE solvers using Schrodingerization, tran…
  quantum-error-correction  A clear and practical skill guide for learning and running a…
  Cancel

Continue into cryptography:


? Select a skill [quantum-skills/algorithms/cryptography]:
» ← Back
  ★ Invoke this index directly: cryptography    Quantum algorithms that attack classical cryptographic proto…
  discretelog               Use when users ask about solving the discrete logarithm prob…
  shor                      Use this skill when the user asks for Shor integer factoriza…
  simon                     Use for implementing, explaining, running, or debugging Simo…
  Cancel

At every level the directory follows these conventions:

[index] · N items: This directory is an index skill — it contains its own SKILL.md, and there are N child entries beneath it.
[dir] · N items: This directory exists only as a path node — it does not contain a SKILL.md of its own, but there are still sub-skills beneath it.
Each leaf skill displays the first paragraph of its description as a short summary.
★ Invoke this index directly: Hand off the entire index skill to the Agent, which will follow the reference chain to locate a more specific sub-skill.
← Back and Cancel are always available.

In --no-interactive mode or in non-terminal environments, /skills degrades to a hint message that directs you to use /<skill> [request] to invoke a skill directly.

`/<skill>`: Direct Invocation

The more common pattern is to invoke a skill directly by name:


[agent│deepseek-v4-pro] › /shor Explain Shor's algorithm and demonstrate it with a minimal example
(The Agent loads the shor skill and follows the tool-invocation conventions declared inside it.)

You can also invoke an index skill directly and let the Agent locate a more specific sub-skill automatically:


[agent│deepseek-v4-pro] › /cryptography Compare the applicable scenarios of Shor / discretelog / Simon attacks for me
(The Agent loads the cryptography index and follows the reference chain to resolve the relevant sub-skills.)

When invoked without a request:


[agent│deepseek-v4-pro] › /shor
? Additional request (press Enter to skip):

Enter a request: Equivalent to invoking the skill with arguments.
Press Enter directly: Only the skill summary is displayed (equivalent to /info), and the model is not invoked.

A bare / followed by Enter no longer triggers implicit skill navigation. The CLI will print the following hint:
`/` is a command prefix. Press `Tab` to browse commands, use `/skills` to enter skill navigation, or type `help` for the full help.

Viewing Skill Details

In addition to invoking a skill so that the Agent executes a task, the CLI provides two commands for quickly inspecting a skill description locally. Both commands read files locally only — they do not trigger any model network call:

/info <skill> Extracts and prints the overview and summary section of the target skill. This is useful when you are not sure what a skill is for, but do not want to read its full text. (Note: As mentioned above, typing /<skill> and pressing Enter without supplying a request has the same effect as /info.)
/cat <skill> Prints the full, unformatted contents of the target skill’s SKILL.md directly in the terminal. If you want to understand the underlying logic — that is, the exact prompt instructions and tool-invocation conventions the Agent will receive when executing the skill — use this command.

Examples:


[agent│deepseek-v4-pro] › /info shor
(The terminal prints only a short description of the Shor algorithm skill.)

[agent│deepseek-v4-pro] › /cat create_pde_task
(The terminal prints the full SKILL.md content of create_pde_task, including all rules and constraints.)

This pattern is suitable when you have already identified the target skill and the specific task at hand.

Invoke an Index Skill and Let the Agent Choose


[agent│deepseek-v4-pro] › /algorithms I want to use a quantum algorithm to solve a system of linear equations

This pattern is suitable when you only have a clear problem direction and want the Agent to locate the specific sub-skill on its own.

Browse the Skill Tree First, Then Invoke


[agent│deepseek-v4-pro] › /skills
(Locate the target skill in the multi-level directory tree, then pick either a specific leaf skill or an index skill.)

This pattern is suitable for first-time use, or when you are not familiar with the skill structure of the current release.

Invoke the PDE Solver Workflow


[agent│deepseek-v4-pro] › /create_pde_task Solve the 1D heat equation on the interval [0, 1] with initial value sin(πx)
(The Agent invokes the PDE toolchain and automatically opens the result files once the task completes.)

The visual outputs that are produced (SVG, PDF, etc.) will be opened automatically according to the rules described in the Interactive Conversation Guide.

Recommendations

For first-time use, browse /skills first. Understanding the hierarchical relationships between skills via the directory tree is usually more reliable than guessing based on names alone.
When in doubt, invoke an index skill. A higher-level index skill lets the Agent recursively locate a more specific capability node, which reduces the chance of picking the wrong skill.
Combine Tab autocomplete for efficiency. When you already know part of a skill name, type the prefix and press Tab to complete it quickly.
Be aware of permission and environment constraints. A skill only defines the Agent’s invocation conventions; if a skill depends internally on a remote service or external tool, you still need the corresponding authentication state and network reachability.