Skip to main content
Glama

Quantum Expectations

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. With errorCorrectionCode set to a qLDPC code that has architecture data (bb-144-12-12, bb-288-12-18; see the architecture field of list_qldpc_codes), the data is held in that code's modules instead (modules, per-instruction error rates and timesteps per T gate) and only the factory is a surface-code block. Results are reported under TWO published logical-error fits (conservative + optimistic) because they disagree by 13-268x (d=7 to d=25); both are returned. Returns an explicit infeasible block when no cataloged factory or code distance can satisfy the error budget. Computes resource numbers only: it does not compare against classical alternatives or judge whether a problem should run on a quantum computer.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "numLogicalQubits": "<numLogicalQubits>",
      "tCount": "<tCount>"
    },
    "name": "compute_fault_tolerant_resources"
  }
}

Input Schema

NameRequiredDescriptionDefault
tCountYesTotal number of T gates (magic states consumed). The count is in T gates, not Toffolis (1 Toffoli ≈ 4–7 T depending on decomposition).
dataBlockNoData-block layout (Litinski §2): compact = fewest qubits, fast = shortest time per T gate.compact
hardwareIdNoPlatform alternative to qubitErrorRate, one of trapped-ion, superconducting, neutral-atom: resolves to the 2-qubit error rate of that platform's entry in the current quantum computers table (list_current_quantum_computers). It sets the error rate only; cycleTimeSeconds keeps its 1 µs (superconducting) default unless given. Supply exactly one of qubitErrorRate or hardwareId.
qubitErrorRateNoPhysical 2-qubit error rate p in (0, 0.1]. Supply exactly one of qubitErrorRate or hardwareId.
cycleTimeSecondsNoSyndrome-cycle time in seconds (surface-code cycle, or one syndrome cycle of the selected qLDPC code). 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.
errorCorrectionCodeNoCode that stores and processes the logical data: "surface" (default; alias "surface-code") for the Litinski lattice-surgery footprint, or a qLDPC id with published instruction-level architecture data (bb-144-12-12, bb-288-12-18) for the Tour de gross bicycle-architecture footprint. The magic-state factory is a surface-code module in both cases.surface
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
qldpcYesNull for the surface code. For a qLDPC code: modules, module qubit breakdown, instruction error rates at the scenario p and error per T gate by instruction (on the published architecture of the code).
layoutYes
caveatsYes
factoryYes
resultsYesBoth fits bracket the model uncertainty and are returned together; null when no cataloged factory meets the T-error budget (see infeasible).
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. Changed7 schema fields changed
    • changedInput schema / properties / cycleTimeSeconds / description
      Previous value: -"Surface-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."New value: +"Syndrome-cycle time in seconds (surface-code cycle, or one syndrome cycle of the selected qLDPC code). Default 1 µs (Litinski convention; Google 2024 measured 1.1 µs on superconducting hardware). Trapped-ion/neutral-atom cycles are orders of magnitude slower."
    • addedInput schema / properties / errorCorrectionCode
      Added value: +{
      +  "default": "surface",
      +  "description": "Code that stores and processes the logical data: \"surface\" (default; alias \"surface-code\") for the Litinski lattice-surgery footprint, or a qLDPC id with published instruction-level architecture data (bb-144-12-12, bb-288-12-18) for the Tour de gross bicycle-architecture footprint. The magic-state factory is a surface-code module in both cases.",
      +  "type": "string"
      +}
    • addedOutput schema / properties / qldpc
      Added value: +{
      +  "anyOf": [
      +    {
      +      "additionalProperties": {},
      +      "properties": {
      +        "architecture": {
      +          "type": "string"
      +        },
      +        "assumedRates": {
      +          "items": {
      +            "type": "string"
      +          },
      +          "type": "array"
      +        },
      +        "caveats": {
      +          "items": {
      +            "type": "string"
      +          },
      +          "type": "array"
      +        },
      +        "codeId": {
      +          "type": "string"
      +        },
      +        "dataModuleQubits": {
      +          "type": "number"
      +        },
      +        "dataQubitsPerModule": {
      +          "type": "number"
      +        },
      +        "errorPerTGate": {
      +          "additionalProperties": {},
      +          "properties": {
      +            "inModule": {
      +              "type": "number"
      +            },
      +            "injection": {
      +              "type": "number"
      +            },
      +            "interModuleChain": {
      +              "type": "number"
      +            }
      +          },
      +          "required": [
      +            "interModuleChain",
      +            "inModule",
      +            "injection"
      +          ],
      +          "type": "object"
      +        },
      +        "fittedRates": {
      +          "items": {
      +            "type": "string"
      +          },
      +          "type": "array"
      +        },
      +        "instructionErrorRates": {
      +          "additionalProperties": {},
      +          "properties": {
      +            "idle": {
      +              "type": "number"
      +            },
      +            "inModule": {
      +              "type": "number"
      +            },
      +            "interModule": {
      +              "type": "number"
      +            }
      +          },
      +          "required": [
      +            "idle",
      +            "inModule",
      +            "interModule"
      +          ],
      +          "type": "object"
      +        },
      +        "label": {
      +          "type": "string"
      +        },
      +        "meanMeasurementsPerPauli": {
      +          "type": "number"
      +        },
      +        "memoryFitRatePerCycle": {
      +          "type": "number"
      +        },
      +        "moduleQubits": {
      +          "additionalProperties": {},
      +          "properties": {
      +            "adapter": {
      +              "type": "number"
      +            },
      +            "code": {
      +              "type": "number"
      +            },
      +            "lpu": {
      +              "type": "number"
      +            }
      +          },
      +          "required": [
      +            "code",
      +            "lpu",
      +            "adapter"
      +          ],
      +          "type": "object"
      +        },
      +        "modules": {
      +          "type": "number"
      +        },
      +        "publishedRange": {
      +          "items": {
      +            "type": "number"
      +          },
      +          "type": "array"
      +        },
      +        "source": {
      +          "type": "string"
      +        },
      +        "withinPublishedRange": {
      +          "type": "boolean"
      +        }
      +      },
      +      "required": [
      +        "codeId",
      +        "label",
      +        "architecture",
      +        "modules",
      +        "dataQubitsPerModule",
      +        "moduleQubits",
      +        "dataModuleQubits",
      +        "instructionErrorRates",
      +        "memoryFitRatePerCycle",
      +        "errorPerTGate",
      +        "meanMeasurementsPerPauli",
      +        "publishedRange",
      +        "withinPublishedRange",
      +        "assumedRates",
      +        "fittedRates",
      +        "caveats",
      +        "source"
      +      ],
      +      "type": "object"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "description": "Null for the surface code. For a qLDPC code: modules, module qubit breakdown, instruction error rates at the scenario p and error per T gate by instruction (on the published architecture of the code)."
      +}
    • changedOutput schema / properties / results / anyOf
      Previous value: -[
      -  {
      -    "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"
      -  }
      -]New value: +[
      +  {
      +    "additionalProperties": {},
      +    "properties": {
      +      "conservative": {
      +        "additionalProperties": {},
      +        "description": "Litinski logical-error fit.",
      +        "properties": {
      +          "distance": {
      +            "description": "Required surface-code distance (odd): of the whole machine for surface, of the magic-state factory only in qLDPC mode; 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"
      +            ]
      +          },
      +          "qldpcDetail": {
      +            "additionalProperties": {},
      +            "description": "qLDPC mode only: the fit-dependent part of the footprint; durations in physical timesteps (the code's timestepsPerCycle per syndrome cycle, see list_qldpc_codes).",
      +            "properties": {
      +              "codeFactoryAdapterQubits": {
      +                "type": "number"
      +              },
      +              "factoryMemoryExposure": {
      +                "type": "number"
      +              },
      +              "factoryPhysicalQubits": {
      +                "type": "number"
      +              },
      +              "factoryTimestepsPerState": {
      +                "type": "number"
      +              },
      +              "idleErrorPerTGate": {
      +                "type": "number"
      +              },
      +              "instructionErrorTotal": {
      +                "type": "number"
      +              },
      +              "timestepsPerTGate": {
      +                "type": "number"
      +              }
      +            },
      +            "required": [
      +              "timestepsPerTGate",
      +              "factoryTimestepsPerState",
      +              "factoryPhysicalQubits",
      +              "codeFactoryAdapterQubits",
      +              "idleErrorPerTGate",
      +              "instructionErrorTotal",
      +              "factoryMemoryExposure"
      +            ],
      +            "type": "object"
      +          },
      +          "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): of the whole machine for surface, of the magic-state factory only in qLDPC mode; 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"
      +            ]
      +          },
      +          "qldpcDetail": {
      +            "additionalProperties": {},
      +            "description": "qLDPC mode only: the fit-dependent part of the footprint; durations in physical timesteps (the code's timestepsPerCycle per syndrome cycle, see list_qldpc_codes).",
      +            "properties": {
      +              "codeFactoryAdapterQubits": {
      +                "type": "number"
      +              },
      +              "factoryMemoryExposure": {
      +                "type": "number"
      +              },
      +              "factoryPhysicalQubits": {
      +                "type": "number"
      +              },
      +              "factoryTimestepsPerState": {
      +                "type": "number"
      +              },
      +              "idleErrorPerTGate": {
      +                "type": "number"
      +              },
      +              "instructionErrorTotal": {
      +                "type": "number"
      +              },
      +              "timestepsPerTGate": {
      +                "type": "number"
      +              }
      +            },
      +            "required": [
      +              "timestepsPerTGate",
      +              "factoryTimestepsPerState",
      +              "factoryPhysicalQubits",
      +              "codeFactoryAdapterQubits",
      +              "idleErrorPerTGate",
      +              "instructionErrorTotal",
      +              "factoryMemoryExposure"
      +            ],
      +            "type": "object"
      +          },
      +          "unreachableReason": {
      +            "type": "string"
      +          },
      +          "wallClockSeconds": {
      +            "type": [
      +              "number",
      +              "null"
      +            ]
      +          }
      +        },
      +        "required": [
      +          "fit",
      +          "distance",
      +          "physicalQubits",
      +          "wallClockSeconds",
      +          "errorBudget"
      +        ],
      +        "type": "object"
      +      }
      +    },
      +    "required": [
      +      "conservative",
      +      "optimistic"
      +    ],
      +    "type": "object"
      +  },
      +  {
      +    "type": "null"
      +  }
      +]
    • addedOutput schema / properties / scenario / properties / errorCorrectionCode
      Added value: +{
      +  "type": "string"
      +}
    • changedOutput schema / properties / scenario / required
      Previous value: -[
      -  "numLogicalQubits",
      -  "tCount",
      -  "qubitErrorRate",
      -  "hardwareId",
      -  "targetSuccessProbability",
      -  "dataBlock",
      -  "cycleTimeSeconds"
      -]New value: +[
      +  "numLogicalQubits",
      +  "tCount",
      +  "qubitErrorRate",
      +  "hardwareId",
      +  "targetSuccessProbability",
      +  "dataBlock",
      +  "cycleTimeSeconds",
      +  "errorCorrectionCode"
      +]
    • changedOutput schema / required
      Previous value: -[
      -  "scenario",
      -  "infeasible",
      -  "factory",
      -  "layout",
      -  "effectiveStepsPerTGate",
      -  "totalTimeSteps",
      -  "results",
      -  "formulas",
      -  "assumptions",
      -  "caveats",
      -  "sources"
      -]New value: +[
      +  "scenario",
      +  "qldpc",
      +  "infeasible",
      +  "factory",
      +  "layout",
      +  "effectiveStepsPerTGate",
      +  "totalTimeSteps",
      +  "results",
      +  "formulas",
      +  "assumptions",
      +  "caveats",
      +  "sources"
      +]
  2. Changed3 schema fields changed
    • changedInput schema / properties / hardwareId / description
      Previous 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."New value: +"Platform alternative to qubitErrorRate, one of trapped-ion, superconducting, neutral-atom: resolves to the 2-qubit error rate of that platform's entry in the current quantum computers table (list_current_quantum_computers). It sets the error rate only; cycleTimeSeconds keeps its 1 µs (superconducting) default unless given. Supply exactly one of qubitErrorRate or hardwareId."
    • changedInput schema / properties / tCount / description
      Previous value: -"Total 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)."New value: +"Total number of T gates (magic states consumed). The count is in T gates, not Toffolis (1 Toffoli ≈ 4–7 T depending on decomposition)."
    • changedOutput schema / properties / results / description
      Previous value: -"Both fits bracket the model uncertainty; report both."New value: +"Both fits bracket the model uncertainty and are returned together; null when no cataloged factory meets the T-error budget (see infeasible)."
  3. 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."
  4. 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"
      +}
  5. 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"
  6. Added

TDQS

A4.4/5.0
Behavior4/5

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

Annotations already declare read-only/idempotent/non-destructive, so the description's contribution is the interesting part: results under two published logical-error fits that disagree by 13-268x, an explicit `infeasible` block, and the absence of per-scenario constants. It omits cost/latency expectations for the computation itself, so it stops short of a 5.

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-loaded with the input signature and output footprint, then mode variants, then the two-fit caveat, then the scope exclusion. Densest sentences carry real information (13-268x disagreement, infeasible block), though the qLDPC sentence and parenthetical asides are heavier than needed.

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?

For an 8-parameter computational tool with full schema coverage and an output schema, it covers inputs, mode switching, the normal and infeasible return shapes, and the boundaries of the tool's remit. Nothing an agent needs to invoke or interpret it correctly is missing.

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

Parameters4/5

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

Schema coverage is 100%, so 3 is the baseline; the description earns a bump by explaining what errorCorrectionCode selection actually changes (data held in qLDPC modules, only the factory remains a surface-code block) and by naming the valid qLDPC ids and where to find them. qubitErrorRate/hardwareId exclusivity is already in the schema, so no extra credit there.

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 verb and resource (derive surface-code + magic-state-distillation footprint from (numLogicalQubits, tCount) and an error rate) and explicitly delimits scope: 'Computes resource numbers only: it does not compare against classical alternatives or judge whether a problem should run on a quantum computer.' That separates it from comparison siblings like compare_hardware_scenarios and compute_expectation.

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 clear conditional guidance for the two modes: default surface-code Litinski path versus a qLDPC id that has architecture data, pointing to list_qldpc_codes' architecture field. It also flags the infeasible outcome and the two-fit reporting, but it never explicitly names a sibling to use instead when comparison is the actual goal.

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

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources