Skip to main content
Glama

Quantum Expectations

by com.quantum-expectations
OverviewDiscussionsAdmin

Compute Fault-Tolerant Resources

compute_fault_tolerant_resources
Read-onlyIdempotent

Given an algorithm stated as (numLogicalQubits, tCount) and a physical error rate (or hardwareId), derive the full surface-code + magic-state-distillation footprint from the general laws of the Litinski lattice-surgery cost model (no per-scenario constants): distillation factory choice, tile layout, required code distance, total physical qubits, and wall-clock time. Results are reported under TWO published logical-error fits (conservative + optimistic) because they disagree by 13-268x (d=7 to d=25) - always state both. Returns an explicit infeasible block when no cataloged factory or code distance can satisfy the error budget. Computes numbers only: comparing against classical alternatives and concluding "should this run on a quantum computer" stays with you, the calling agent (state the caveats when you do).

Input Schema

NameRequiredDescriptionDefault
tCountYesTotal number of T gates (magic states consumed). Convention: state Toffoli-counted algorithms in T gates before calling (1 Toffoli ≈ 4–7 T depending on decomposition).
dataBlockNoData-block layout (Litinski §2): compact = fewest qubits, fast = shortest time per T gate.compact
hardwareIdNoAlias for qubitErrorRate: resolves to the 2-qubit error rate of the given SOTA hardware entry from list_current_quantum_computers. Use this, not a generic qubitErrorRate such as 0.001, whenever the question names a platform without stating its own error rate (superconducting, trapped-ion, neutral-atom). Supply exactly one of qubitErrorRate or hardwareId.
qubitErrorRateNoPhysical 2-qubit error rate p in (0, 0.1]. Supply exactly one of qubitErrorRate or hardwareId.
cycleTimeSecondsNoSurface-code cycle time in seconds. Default 1 µs (Litinski convention; Google 2024 measured 1.1 µs on superconducting hardware). Trapped-ion/neutral-atom cycles are orders of magnitude slower.
numLogicalQubitsYesNumber of logical data qubits the algorithm needs.
targetSuccessProbabilityNoTarget end-to-end success probability. The failure budget (1 − target) is split evenly between T-state error and logical (memory/surgery) error, matching Litinski §4.

Output Schema

NameRequiredDescriptionDefault
layoutYes
caveatsYes
factoryYes
resultsYesBoth fits bracket the model uncertainty; report both.
sourcesYes
formulasYes
scenarioYes
infeasibleYesNon-null when the scenario is infeasible as modeled: no cataloged factory meets the T-error budget (factory and layout are then null) or no distance up to the cap meets it under either fit (per-fit distance, qubits and wall clock are then null).
assumptionsYes
totalTimeStepsYes
effectiveStepsPerTGateYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed1 schema field changed
    • changedInput schema / properties / hardwareId / description
      Previous value: -"Alias for qubitErrorRate: resolves to the error rate of a SOTA hardware entry."New value: +"Alias for qubitErrorRate: resolves to the 2-qubit error rate of the given SOTA hardware entry from list_current_quantum_computers. Use this, not a generic qubitErrorRate such as 0.001, whenever the question names a platform without stating its own error rate (superconducting, trapped-ion, neutral-atom). Supply exactly one of qubitErrorRate or hardwareId."
  2. Changed1 schema field changed
    • changedOutput schema / (root)
      Previous value: -nullNew value: +{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": {},
+  "properties": {
+    "assumptions": {
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
+    "caveats": {
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
+    "effectiveStepsPerTGate": {
+      "type": [
+        "number",
+        "null"
+      ]
+    },
+    "factory": {
+      "anyOf": [
+        {
+          "additionalProperties": {},
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "outputErrorRate": {
+              "type": "number"
+            },
+            "stepsPerOutputState": {
+              "type": "number"
+            },
+            "successProbability": {
+              "type": "number"
+            },
+            "tiles": {
+              "type": "number"
+            }
+          },
+          "required": [
+            "id",
+            "tiles",
+            "outputErrorRate",
+            "successProbability",
+            "stepsPerOutputState"
+          ],
+          "type": "object"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "formulas": {
+      "additionalProperties": {
+        "type": "string"
+      },
+      "propertyNames": {
+        "type": "string"
+      },
+      "type": "object"
+    },
+    "infeasible": {
+      "anyOf": [
+        {
+          "additionalProperties": {},
+          "properties": {
+            "reason": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "reason"
+          ],
+          "type": "object"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "description": "Non-null when the scenario is infeasible as modeled: no cataloged factory meets the T-error budget (factory and layout are then null) or no distance up to the cap meets it under either fit (per-fit distance, qubits and wall clock are then null)."
+    },
+    "layout": {
+      "anyOf": [
+        {
+          "additionalProperties": {},
+          "properties": {
+            "dataBlockTiles": {
+              "type": "number"
+            },
+            "factoryTiles": {
+              "type": "number"
+            },
+            "storageTiles": {
+              "type": "number"
+            },
+            "totalTiles": {
+              "type": "number"
+            }
+          },
+          "required": [
+            "dataBlockTiles",
+            "factoryTiles",
+            "storageTiles",
+            "totalTiles"
+          ],
+          "type": "object"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "results": {
+      "anyOf": [
+        {
+          "additionalProperties": {},
+          "properties": {
+            "conservative": {
+              "additionalProperties": {},
+              "description": "Litinski logical-error fit.",
+              "properties": {
+                "distance": {
+                  "description": "Required surface-code distance (odd); null when no cataloged distance suffices.",
+                  "type": [
+                    "number",
+                    "null"
+                  ]
+                },
+                "errorBudget": {
+                  "additionalProperties": {},
+                  "properties": {
+                    "logicalContribution": {
+                      "type": [
+                        "number",
+                        "null"
+                      ]
+                    },
+                    "tStateContribution": {
+                      "type": "number"
+                    },
+                    "totalFailureUpperBound": {
+                      "type": [
+                        "number",
+                        "null"
+                      ]
+                    }
+                  },
+                  "required": [
+                    "logicalContribution",
+                    "tStateContribution",
+                    "totalFailureUpperBound"
+                  ],
+                  "type": "object"
+                },
+                "fit": {
+                  "enum": [
+                    "litinski",
+                    "repo"
+                  ],
+                  "type": "string"
+                },
+                "physicalQubits": {
+                  "type": [
+                    "number",
+                    "null"
+                  ]
+                },
+                "unreachableReason": {
+                  "type": "string"
+                },
+                "wallClockSeconds": {
+                  "type": [
+                    "number",
+                    "null"
+                  ]
+                }
+              },
+              "required": [
+                "fit",
+                "distance",
+                "physicalQubits",
+                "wallClockSeconds",
+                "errorBudget"
+              ],
+              "type": "object"
+            },
+            "optimistic": {
+              "additionalProperties": {},
+              "description": "Willow-2024-calibrated fit.",
+              "properties": {
+                "distance": {
+                  "description": "Required surface-code distance (odd); null when no cataloged distance suffices.",
+                  "type": [
+                    "number",
+                    "null"
+                  ]
+                },
+                "errorBudget": {
+                  "additionalProperties": {},
+                  "properties": {
+                    "logicalContribution": {
+                      "type": [
+                        "number",
+                        "null"
+                      ]
+                    },
+                    "tStateContribution": {
+                      "type": "number"
+                    },
+                    "totalFailureUpperBound": {
+                      "type": [
+                        "number",
+                        "null"
+                      ]
+                    }
+                  },
+                  "required": [
+                    "logicalContribution",
+                    "tStateContribution",
+                    "totalFailureUpperBound"
+                  ],
+                  "type": "object"
+                },
+                "fit": {
+                  "enum": [
+                    "litinski",
+                    "repo"
+                  ],
+                  "type": "string"
+                },
+                "physicalQubits": {
+                  "type": [
+                    "number",
+                    "null"
+                  ]
+                },
+                "unreachableReason": {
+                  "type": "string"
+                },
+                "wallClockSeconds": {
+                  "type": [
+                    "number",
+                    "null"
+                  ]
+                }
+              },
+              "required": [
+                "fit",
+                "distance",
+                "physicalQubits",
+                "wallClockSeconds",
+                "errorBudget"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "conservative",
+            "optimistic"
+          ],
+          "type": "object"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "description": "Both fits bracket the model uncertainty; report both."
+    },
+    "scenario": {
+      "additionalProperties": {},
+      "properties": {
+        "cycleTimeSeconds": {
+          "type": "number"
+        },
+        "dataBlock": {
+          "enum": [
+            "compact",
+            "intermediate",
+            "fast"
+          ],
+          "type": "string"
+        },
+        "hardwareId": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "numLogicalQubits": {
+          "type": "number"
+        },
+        "qubitErrorRate": {
+          "type": "number"
+        },
+        "tCount": {
+          "type": "number"
+        },
+        "targetSuccessProbability": {
+          "type": "number"
+        }
+      },
+      "required": [
+        "numLogicalQubits",
+        "tCount",
+        "qubitErrorRate",
+        "hardwareId",
+        "targetSuccessProbability",
+        "dataBlock",
+        "cycleTimeSeconds"
+      ],
+      "type": "object"
+    },
+    "sources": {
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
+    "totalTimeSteps": {
+      "type": [
+        "number",
+        "null"
+      ]
+    }
+  },
+  "required": [
+    "scenario",
+    "infeasible",
+    "factory",
+    "layout",
+    "effectiveStepsPerTGate",
+    "totalTimeSteps",
+    "results",
+    "formulas",
+    "assumptions",
+    "caveats",
+    "sources"
+  ],
+  "type": "object"
+}
  3. Changed1 schema field changed
    • changedInput schema / $schema
      Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
  4. Added

TDQS

A4.4/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations only cover the read-only/idempotent safety profile; the description adds substantive behavior the agent could not otherwise know: results are reported under two logical-error fits that disagree by 13-268x, an explicit `infeasible` block is returned when the error budget cannot be met, and the model uses no per-scenario constants. It also states plainly that no judgment about quantum vs classical is included.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the verb, inputs, and outputs in the first sentence, then adds the dual-fit caveat and the infeasible case. It is dense but nearly every clause carries information; the closing scope-boundary sentence is slightly parenthetical yet still useful for correct use.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present and full parameter documentation, the description supplies exactly the missing pieces: which error fits are reported and how much they diverge, the existence of an infeasible result, and the division of labor between the tool and the calling agent. Nothing needed to invoke or interpret it correctly is absent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and every parameter carries a substantive description (including the hardwareId-vs-qubitErrorRate exclusivity and the Toffoli-to-T convention), so the schema does the heavy lifting. The description restates the input shape as a tuple but adds no syntax or semantics beyond what the schema already provides, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific action verb ('derive the full surface-code + magic-state-distillation footprint') plus the exact input form (numLogicalQubits, tCount, error rate/hardwareId) and enumerates the outputs (factory choice, tile layout, distance, physical qubits, wall-clock time). This clearly separates it from siblings like compare_hardware_scenarios or compute_required_error_rate, which do not produce a full resource footprint.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit parameter-selection guidance ('Use this, not a generic qubitErrorRate such as 0.001, whenever the question names a platform'), a reporting mandate ('always state both' fits), and a scope boundary ('comparing against classical alternatives... stays with you'). It stops short of naming sibling tools or stating when a different compute_* tool is the better call, so it is clear context without full alternative routing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

All Quantum Expectations toolsInspect
Try in Browser
One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources