Skip to main content
Glama

validation_plan

DestructiveIdempotent

Define and freeze task-specific validation criteria and native input dependencies before simulation work, so required checks gate dependent steps and monitoring.

Instructions

Freeze task-specific criteria and native input dependencies. Components: id,scope (static/environment/numerics/outputs/analysis),files,condition_keys,checks; optional required=false for exploratory components, checker_id for a qualified native Python checker. Cover all inputs and conditions. Checks use role=required/advisory/candidate; only required evidence gates dependent work. Node monitor uses actual thermo phase selectors and action=warn (default) or explicit stop; no global physical tolerance. Changes retain rationale and parents. reuse_from or reuse_sources merges identical, valid components; changing a monitor preserves unrelated checks. Compare variants with validation_compare before selecting final criteria. variations: path,variable,min,max for seeds. Confirm policy.preflight_core_hours and preflight_budget_authorization; budget_core_hours defaults to that cap. runtime_id comes from environment_capture. Production requires static/environment/numerics/outputs; only missing checks need accounted preflight.

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": {
      "task_id": "<task_id>",
      "revision": "<revision>",
      "snapshot_id": "<snapshot_id>",
      "entry": "<entry>",
      "components": "<components>",
      "op_id": "<op_id>"
    },
    "name": "validation_plan"
  }
}

Input Schema

NameRequiredDescriptionDefault
entryYes
op_idYes
tokenNo
monitorNo
task_idYes
revisionYes
rationaleNo
componentsYes
reuse_fromNo
runtime_idNo
variationsNo
snapshot_idYes
reuse_sourcesNo
budget_core_hoursNo

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv1.0.0

TDQS

B3.2/5.0
Behavior3/5

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

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=false, so the safety profile is partly covered. The description does add behavior beyond them: merge semantics for reuse_from/reuse_sources, that changing a monitor preserves unrelated checks, and that only required-role evidence gates dependent work. It never says what the destructive mutation actually overwrites, whether a frozen plan can be unfrozen, or what authorization token is needed, so the destructive nature remains under-explained.

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

Conciseness2/5

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

After a reasonable first sentence the text degrades into a long semicolon-separated run of clauses that mix parameter docs, policy rules, and domain constraints with no grouping or ordering. Little is wasted, but the lack of front-loading and structure makes it hard for an agent to extract the operative rules quickly.

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

Completeness3/5

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

An output schema exists, so return values need not be described. For a 14-parameter, destructive, revision-tracked tool the description covers a lot of domain ground but leaves the core lifecycle opaque: what entry/op_id/token/snapshot_id control, what happens on a revision conflict, and whether a frozen plan is immutable are all unaddressed.

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 0% across 14 parameters, so the description carries the whole burden. It does define nested semantics for components (scope enum values, required=false for exploratory, checker_id), checks roles, monitor selectors/action, variations keys (path, variable, min, max), and the budget_core_hours default. But roughly half the top-level parameters (entry, op_id, token, task_id, revision, snapshot_id) are never explained, and the covered ones are compressed into telegraphic fragments.

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

Purpose4/5

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

The opening sentence gives a specific verb and resource: 'Freeze task-specific criteria and native input dependencies,' and the enumerated component shape (id, scope, files, condition_keys, checks) tells an agent what a plan contains. It also names a sibling boundary ('Compare variants with validation_compare before selecting final criteria'), so it is separable from at least one alternative. It stops short of 5 because the 'freeze' metaphor is never tied to concrete persistence/immutability semantics.

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

Usage Guidelines3/5

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

There is real routing guidance ('Compare variants with validation_compare before selecting final criteria') and a stated precondition set ('Production requires static/environment/numerics/outputs', 'Confirm policy.preflight_core_hours and preflight_budget_authorization'). However, it never says when NOT to use this tool versus validation_check, validation_control, or validation_match, and the preconditions are asserted as jargon rather than explained as a sequence.

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