Weapon Lab

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it says nothing about side effects, whether the figure is mutated, what coordinate/unit assumptions exist, or what the result is. A mutation-capable alignment operation with zero behavioral context is a serious gap.

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

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

It is short, but short because it is under-specified rather than economical. The single fragment is not front-loaded with an action or outcome, so no sentence earns its place by conveying usable information.

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

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

For a tool with 7 parameters (5 required), no annotations, no output schema, and 43% schema description coverage, the description provides almost none of the missing context. An agent has no basis to invoke it correctly.

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

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

Schema coverage is only 43%, so the description must compensate for undocumented parameters such as gun, figure_id, reference_figure, and note. Instead it adds no meaning for any parameter and only obliquely evokes 'part' and 'trace' via the trigger-guard phrasing.

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

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

The description is a noun phrase fragment ('A figure's scale and frame matched to a framed figure...') with no verb and no explicit statement of what the tool does to its inputs. It gestures at aligning a figure to a reference figure, but an agent cannot confidently distinguish it from siblings like blueprint_calibrate, blueprint_frame, or rig_align.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of any alternative tool. The fragment hints at a comparison operation but never states the condition under which this tool should be chosen.

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

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

With no annotations, the description carries the full behavioral burden for what is evidently a write/build operation. It mentions that renders and labelled pictures are produced, which hints at outputs, but says nothing about side effects, whether it overwrites existing models, dependencies on prior steps, or permissions/runtime.

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

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

It is a single sentence with no padding, so it is not bloated, but the compressed grammar ('the model (one object a part) and its parts map') makes it hard to parse rather than front-loading a clear action.

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

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

For a multi-stage Blender build/render tool with no annotations, no output schema, and 0% parameter coverage, the description is far too thin. It should explain ordering, required inputs, produced artifacts, and side effects, none of which are adequately covered.

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

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

Schema coverage is 0% and neither of the two parameters (gun, render) is described in the schema. The description only obliquely maps to 'render' via 'with render, labelled pictures,' and gives no meaning at all for the required 'gun' parameter, leaving half the surface undocumented in both places.

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

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

The phrasing 'the model (one object a part) and its parts map for Gun Kit' is cryptic and requires decoding; the verb ('build') is only inferable from the name. It gestures at producing a model plus labelled renders but never states plainly what operation it performs on what input, and it is not clearly separable from siblings like blueprint_showcase, blueprint_parts_list, or blueprint_to_gunkit.

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

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

The only usage signal is the positional note 'Step 6 in Blender,' which implies a pipeline ordering but names no alternative tool and no condition for choosing this one over the other blueprint_* tools. No prerequisites or when-not-to-use guidance is given.

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

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

No annotations are provided, so the description carries the full burden. It never discloses whether calibration mutates or persists state on the figure, what happens if the two points disagree with the fact, whether the operation is reversible, or what the caller receives. For a tool that presumably writes a scale onto a figure, this is a substantial disclosure gap.

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

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

It is a single compact sentence with no filler, but it is dense jargon and poorly front-loaded — it opens with the abstract concept "A figure's scale" and buries the operative mechanism in parentheticals. Compact enough, but hard to parse on first read and not structured around the action.

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

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

Seven parameters, no output schema, and no annotations means the description needs to do a lot of work. It explains the input model for the primary path but omits what the tool produces or changes after calibration, the roles of gun/figure_id/cm, and any error cases. Inadequate for the complexity of the tool.

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

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

Schema coverage is 57% (a, b, fact, extent_of are described; cm, gun, figure_id are not), so the description must add meaning. It does explain the model: a and b are two points a known length apart, fact supplies that known length, and extent_of is a kept outline whose bore length substitutes for a and b. However, it leaves cm, gun, and figure_id entirely unexplained, so it only partially compensates for the coverage gap.

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

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

The description frames the tool as establishing "a figure's scale," which is a recognizable purpose, but it is written as a noun phrase rather than a verb+resource statement and never says explicitly that it calibrates/sets the scale of a blueprint figure. It gestures at the mechanism (two points, or a kept outline) rather than stating the action. An agent can guess the intent but cannot cleanly distinguish it from siblings like blueprint_measure or blueprint_fact_add.

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

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

There is no when-to-use guidance, no prerequisites (e.g., that a figure must already exist), and no routing to alternatives such as blueprint_measure or blueprint_grid. The only alternatives mentioned (fact vs. a/b, extent_of in place of a and b) are input-mode choices, not tool-selection guidance. The agent gets no signal about when this tool is the right choice.

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

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

With no annotations, the description carries full behavioral burden. It discloses that overlays are placed on every framed figure and says to look at them, but does not state whether it mutates the blueprint, writes files, what permissions are needed, or what the result looks like.

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

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

The text is short and front-loads the step number, but it is structured as a sentence fragment with awkward punctuation. It is concise without being well-formed, so it only partially meets the structure requirement.

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

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

For a 3-parameter tool with no output schema and no annotations, the description is incomplete. It does not cover the required parameter, most optional parameters, return behavior, or prerequisites, leaving significant gaps for correct invocation.

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

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

Schema coverage is only 33%, and only the reference parameter has a schema description. The description does not explain the required gun parameter or reference_holes, nor does it add semantics beyond the single schema-described parameter.

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

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

The description enumerates what is checked: contract, reference outline overlap/edge gaps, length/weight facts, and overlays on framed figures. However, it is a fragment missing an explicit verb and does not clearly differentiate this check from siblings like contract_check or blueprint_measure.

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

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

"Step 5" implies a workflow position, so some usage context is conveyed. But there is no explicit when-to-use, when-not-to-use, or alternative-tool guidance, leaving the agent to infer the call context.

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

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

With no annotations, the description carries the full burden, yet it does not say whether facts are deduplicated, whether fact_id must be unique, whether a bad unit is rejected, or what is returned on success. The only behavioral hint is that values are 'kept in cm, kg, deg or count'.

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

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

A single front-loaded sentence with no filler, which is good, but for a tool with seven required parameters the terseness crosses into under-specification rather than discipline.

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

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

Seven required parameters, 29% schema coverage, no annotations and no output schema — the description answers almost none of the questions an agent needs resolved before calling this write tool (source linkage, fact_id semantics, unit mismatch, error behavior).

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

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

Schema coverage is only 29% (unit and quote documented), so the description should compensate for gun, fact_id, value, page and source_id — it does not. Worse, its unit list ('cm, kg, deg or count') is narrower than and inconsistent with the schema's 'as printed: in, mm, cm, lb, oz, kg, count...', which could mislead an agent about valid inputs.

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

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

The verb+resource are explicit: it records a fact alongside the page and quote it came from. It does not, however, distinguish itself from look-alike siblings such as blueprint_source_add, blueprint_figure_add or blueprint_measure, so an agent must infer the boundary from the name alone.

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

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

There is no statement of when to add a fact versus calling blueprint_numbers, blueprint_measure or blueprint_figure_add, and no prerequisites (e.g. a source must exist first). Usage is only implied by the name.

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

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

With no annotations, the description carries the full behavioral burden, yet it never says whether this mutates the blueprint, persists to disk, requires a prior part, or is reversible. The parenthetical describes feature kinds rather than behavior, so it adds little beyond domain vocabulary.

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

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

A single compact sentence with the scoping phrase front-loaded and a parenthetical of concrete examples. It is efficient, though 'the detail pass' is opaque enough that the brevity borders on under-specification.

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

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

For a 3-parameter, nested-object, mutation-style tool with no annotations and no output schema, one cryptic sentence is insufficient. Nothing tells the agent what the call produces or what state it changes.

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

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

Schema description coverage is 33%, and the description partially compensates by naming grooves/screws/texture that map to the 'feature' kind field. However, gun and part_id receive no explanation in either the description or the schema, so the coverage gap is only half-closed.

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

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

It identifies the resource (a surface feature on a part) and gives domain examples (grooves, screws, patterns), but there is no clear action verb — 'the detail pass' is jargon that leaves ambiguous whether it adds, edits, or renders the feature. Close siblings like blueprint_part, blueprint_hole, and blueprint_mark are not referenced, so an agent cannot confidently separate this from them.

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

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

No when-to-use statement, no prerequisites (e.g. an existing part_id), and no alternatives named. The agent is left to infer that this is the step after blueprint_part from the phrase 'detail pass' alone.

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

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

No annotations are supplied, so the description carries the full disclosure burden. It says it cuts a figure and stands it upright, but does not state permissions, reversibility, side effects, error conditions, or return behavior for this mutation.

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

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

It is a single front-loaded sentence with no wasted words, but for a 10-parameter tool it is too terse to be considered appropriately sized. The 'Step 3' preamble consumes space without clarifying the operation for an agent.

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

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

For a tool with 10 parameters, 5 required fields, no output schema, and no annotations, the description is far too thin. It omits prerequisites, parameter meaning, sequencing details, and return behavior, leaving the agent unable to invoke it correctly from the description alone.

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

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

Schema description coverage is only 40%, and the description adds no parameter-level meaning beyond what little the schema already provides. With 10 parameters (only 5 required) and low coverage, the description should compensate but does not.

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

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

States a specific action (cuts a figure) and outcome (stands it upright) on a page, and marks it as Step 3 in a pipeline. It is clear enough for an agent to identify the operation, but it does not differentiate itself from sibling blueprint_* tools such as blueprint_views or blueprint_part.

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

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

The 'Step 3' prefix implies a sequence but gives no explicit when-to-use, prerequisites, or alternatives. No guidance on when this tool should be chosen over blueprint_views, blueprint_page, or blueprint_part is provided.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about side effects, persistence, whether it creates or reads a frame, or what permissions/state it needs. It does disclose the geometric semantics (bore line runs rear-to-muzzle, origin is the bolt face), which is the only behavioral value present.

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

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

It is a single short sentence with no padding, so nothing is wasted. However, the brevity reflects under-specification rather than disciplined conciseness, and it is not clearly front-loaded around an action.

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

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

With five required parameters, 20% schema coverage, no annotations, and no output schema, the description is far too thin to let an agent call this correctly. It omits the operation itself, the meaning of two parameters, and any behavioral or return context.

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

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

Schema description coverage is only 20% (just origin: 'px: the bolt face'), so the description must compensate for four undocumented parameters. It partially clarifies bore_rear/bore_front via the bore-line explanation and origin via the bolt face, but leaves 'gun' and 'figure_id' entirely unexplained.

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

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

The description gestures at the domain concept ('how a figure lies in gun space') but never states an action verb, so it is unclear whether the tool defines, returns, or mutates a frame. It is more conceptual explanation than a statement of what the tool does, and it does not differentiate itself from the many other blueprint_* siblings.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of any alternative tool among the large blueprint_* family. The agent is given no basis for choosing this over blueprint_align, blueprint_calibrate, or blueprint_views.

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

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

No annotations are provided, so the description carries the full behavioral burden. It hints that output changes conditionally ('once framed, its bore line, origin and cm grid'), which is modestly useful, but says nothing about whether it mutates rig state, what it returns (image? coordinates?), or what happens if the figure is not yet framed.

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

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

It is a single, short sentence with no padding, which is good. However, it is structured as an awkward noun phrase whose key content (framing state, overlays) is parenthetically buried, so it is under-specified rather than genuinely concise.

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

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

With 5 parameters, zero schema descriptions, no annotations, and no output schema, the description is the only information source and it is grossly insufficient. An agent cannot determine required inputs, what the tool returns, or the framing prerequisite with confidence.

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

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

Schema description coverage is 0% across 5 parameters, and the description never mentions gun, figure_id, zoom, region, or step_px. Terms like 'pixel grid' faintly gesture at step_px/zoom but give no mapping or units, so the description fails to compensate for the entirely undocumented schema.

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

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

The description is a noun phrase ('The figure with a labelled pixel grid...') rather than a verb+resource statement, so it never says whether blueprint_grid generates, renders, or fetches something. It restates the tool name's 'grid' concept and adds only a hint about framing-dependent overlays, leaving the actual action ambiguous.

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

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

There is no explicit when-to-use guidance and no mention of any sibling (e.g., blueprint_page, blueprint_measure, blueprint_trace) that an agent should pick instead. The only usable cue is the incidental phrase 'once framed', implying blueprint_frame is a prerequisite, but this is inference rather than stated guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies a mutation by saying 'a cut in a part', but it does not state whether the change is persisted, reversible, permission-gated, or what side effects occur. The geometric modes are described, but operational behavior is essentially absent.

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

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

The description is a single compact sentence with no filler, and it front-loads the core notion ('a cut in a part'). It could be structured more helpfully by separating the three modes, but it is not verbose. As written, every phrase attempts to do work.

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

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

The tool has 7 parameters, nested object inputs, no annotations, no output schema, and no parameter descriptions in the schema. One terse sentence cannot cover the required semantics for gun and part_id or clarify source. The description is too incomplete for an agent to call this tool reliably without further inference.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate. It adds meaning for trace, circle, x, and bore, but never explains the required gun and part_id parameters, nor the source object. The mapping of mode to parameters is also overly terse, leaving key semantics unresolved.

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

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

The description states a resource ('a cut in a part') and mode variants (trace outline, circle across x, bore along y), but it never gives a clear verb like 'create' or 'add'. It is more specific than a tautology, yet the agent must infer that this tool creates a hole-type feature in a blueprint. Sibling differentiation is only implied through the word 'hole' and the mode vocabulary.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as blueprint_feature, blueprint_mark, or blueprint_trace. The description only says which input shape selects which mode, and even that is cryptic. No prerequisites, exclusions, or sibling routing are provided.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about whether this is a mutation, required permissions, reversibility, or return format. It adds only domain flavor (units in cm, gun-space coordinates, source options), which is data semantics rather than behavior.

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

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

It is a single short sentence, but the brevity stems from under-specification and jargon rather than efficient front-loading. The one sentence does not orient the agent to the operation being invoked.

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

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

For a tool with 7 parameters, 4 required, nested objects, no annotations, and no output schema, the description is far too thin. An agent has almost nothing to decide whether or how to call it.

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

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

Schema description coverage is only 14% across 7 parameters, so the description should compensate but barely does. It hints at 'source' (hand placement or check point) and 'normal' ('the way its surface faces'), but never explains 'gun', 'name', 'at', 'rides', or 'magazine_lips'.

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

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

The description defines the resource ('a mark in gun space') and its attributes, but never states the action the tool performs. It reads as a noun-phrase data definition rather than a verb+resource statement, and it does not distinguish itself from siblings like blueprint_part, blueprint_hole, or blueprint_feature.

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

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

There is no guidance on when to use this tool, when not to, or which sibling to prefer. An agent cannot infer from the text whether this creates, reads, or updates a mark.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It implies a read-only measurement operation, but does not disclose permissions, whether it mutates state, how figure_id is resolved, what the return format is, or any limitations. The phrase 'by the tools, not by eye' adds only a vague behavioral hint and no operational detail.

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

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

The description is a single concise sentence fragment, so it does not waste words. However, it is not front-loaded with a clear subject or verb, and its poetic phrasing ('ink's span', 'faint marks') sacrifices immediate clarity for style. It is adequately sized but under-specified rather than richly concise.

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

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

The tool has six parameters, no annotations, no output schema, and very low schema description coverage, so the description should compensate heavily. Instead, it provides only a high-level list of measurement types and omits parameter explanations, usage context, return behavior, and safety profile. It is insufficient for an agent to invoke the tool reliably without additional inference.

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

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

Schema description coverage is only 17%, with just the 'how' parameter documented in the schema. The description loosely maps to the 'how' options (distance, span, ticks, peaks), but does not explain the required a, b, gun, figure_id, or optional light parameters. It adds little operational meaning for the four undocumented parameters that an agent must supply.

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

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

The description names the resource (a figure) and enumerates the kinds of readings: distance, ink span, scale bar ticks, and faint marks. It is clear that the tool measures geometry on a figure, though the phrasing 'Readings off a figure by the tools, not by eye' is less direct than a standard verb+resource statement. It does not distinguish this tool from siblings such as blueprint_read or blueprint_numbers.

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

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

There is no explicit guidance on when to use blueprint_measure versus alternatives, nor any prerequisites or exclusions. The description only implies that the tool performs measurement, leaving the agent to infer its role among many blueprint_* siblings. No context about coordinate systems, figure_id requirements, or suitable use cases is provided.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing. It does not say whether this creates persistent state, whether it is idempotent, what happens if the blueprint already exists, what permissions are needed, or what the result is.

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

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

It is a single front-loaded sentence with no filler, so it is structurally tight. However, the brevity reflects under-specification rather than economical expression, leaving almost nothing actionable for the agent.

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

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

For a tool with three parameters, zero schema descriptions, no annotations, and no output schema, the description is completely inadequate. There is no information about inputs, side effects, or return values to guide a correct invocation.

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

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

Schema description coverage is 0% across three parameters, so the description must compensate and largely does not. It references 'gun' and loosely 'action family' (matching the required 'gun' and 'action'), but adds no format, expected values, or constraints, and never mentions the optional 'title' parameter.

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

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

The description says it 'starts the gun's blueprint for its action family,' which gestures at creating/initializing a blueprint, but the verb 'starts' is weak and the domain jargon ('gun', 'action family') is never defined. It gives no basis for distinguishing it from siblings like blueprint_build, blueprint_read, or blueprint_to_gunkit.

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

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

The 'Step 4' prefix implies this sits in a workflow sequence, which is a faint hint about when to call it, but no prerequisites, ordering rules, or alternatives are stated. An agent cannot tell from this text why it would pick blueprint_new over other blueprint_* tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says nothing about side effects, permissions, reversibility, return behavior, or whether the operation is a read or a write, despite the required 'numbers' input strongly implying a mutation.

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

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

The single sentence is short but grammatically awkward and fails to front-load a clear action or outcome. Its brevity reflects under-specification rather than efficient communication, leaving the agent without the core information needed to invoke the tool.

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

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

Given three required parameters, 0% schema description coverage, no annotations, and no output schema, the description is far too incomplete. An agent lacks the purpose, usage context, parameter meaning, and behavioral profile required to call this tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate for all three parameters. It loosely relates 'numbers' to source part numbers and 'part_id' to a blueprint part, but leaves 'gun' completely unexplained and provides no format, type, or role information for any parameter.

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

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

The description is a noun phrase that gestures at a relationship ('source's part numbers a blueprint part stands for') but never states an action verb such as get, set, or assign. It does not distinguish the tool from the many blueprint_* siblings, and an agent cannot tell whether it reads or writes data.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the numerous blueprint_* or rig_* sibling tools. The description offers no context for selecting this tool over blueprint_part, blueprint_parts_list, or similar operations.

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

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

With no annotations, the description carries the full burden. It does disclose the output artifact (rendered pictures / contact sheet) and 'to read' implies a non-mutating render, but it says nothing about permissions, side effects, output format details, or limits.

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

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

A single front-loaded sentence with no wasted words; the two modes are stated compactly. The terseness is efficient even if it borders on being too terse to be clear.

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

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

For a 4-parameter tool with 0% schema coverage, no annotations, and no output schema, the description is too thin. It does not explain the required 'gun'/'source_id' inputs or clarify what the rendered result actually is.

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

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

Schema coverage is 0%, so the description must compensate. It touches on dpi and the pages concept, but the required parameters 'gun' and 'source_id' are never explained, leaving half the inputs undocumented in both schema and description.

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

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

The description conveys that pages are rendered as images and distinguishes two modes (single page at a dpi, or several side by side as a contact sheet). However, the phrasing 'Pages as pictures to read' is cryptic and never states a clean verb+resource, and there is no differentiation from the many blueprint_* siblings (blueprint_read, blueprint_text, blueprint_views).

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

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

It implies two usage contexts: 'to read' a single page and 'to find the figures' via a contact sheet. That is useful implied guidance, but no alternative sibling is named and there are no when-not conditions.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one genuinely useful trait: every number requires a source and blueprint_check will fail a part lacking one, which explains the coupling to the *source params. It says nothing about overwrite/idempotency semantics for a repeated part_id, required permissions, or what the call returns.

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

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

Two tight sentences with the core action front-loaded and the validation consequence second; no filler. It is arguably too terse for a 19-parameter tool, but that is a completeness issue rather than a structural one.

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

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

For a 19-parameter mutation tool with no annotations, no output schema and under half schema description coverage, two sentences are not enough. The description never defines what a 'part' is, how parts relate via parent/part_id, or what happens on re-set, leaving the agent to infer most of the calling contract from the schema alone.

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

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

Schema coverage is only 47%, so the description should compensate. It adds one meaningful cross-parameter rule ('every number needs its source'), which explains why x_source, axis_source, motion_sources and profile_source exist, but it leaves the remaining undocumented parameters (gun, finish, bore_r, bevel_cm, parent, axis, name, part_id) unexplained.

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

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

States a specific verb and resource: 'Sets one part of the blueprint.' An agent can tell it is the per-part write/upsert operation, distinct from reads like blueprint_parts_list or validators like blueprint_check. It does not, however, name or contrast any sibling explicitly.

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

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

There is no when-to-use guidance, no prerequisites, and no routing to alternatives such as blueprint_parts_list (read) or blueprint_check (validate). The only context offered is a validation rule about sources, which is a constraint rather than usage guidance.

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

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

With no annotations, the description carries the full burden. It usefully discloses the matching rule (by number, or by name when the source gives none) and that visibility distinguishes parts, but it says nothing about what the check does on mismatch, what "replace" mutates or destroys, permission needs, or the return shape — significant gaps for a tool that appears to write.

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

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

It is compact and front-loads the resource, which is good, but the opaque "detail pass" framing and the merged list/check clauses add ambiguity rather than value. Size is fine; clarity per sentence is weak.

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

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

For a 3-parameter tool with a mutation flag, no annotations, and no output schema, the description leaves critical behavior unspecified: the meaning of gun, the effect of replace, and what a successful check returns. It is not complete enough for an agent to invoke this confidently.

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

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

Schema description coverage is only 33%: entries is documented but gun and replace are bare. The description never explains gun or the mutation semantics of replace, so it fails to compensate for the coverage gap, and the entries field detail lives in the schema, not the description.

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

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

The phrase "the source's parts list" does identify the resource, but "The detail pass" is unexplained internal jargon and the sentence conflates listing with checking ("the check holds every visible one to a blueprint part"). An agent cannot cleanly tell whether this lists parts, validates them, or both, nor distinguish it from siblings like blueprint_part, blueprint_check, or blueprint_read.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative-tool routing despite ~50 blueprint_* siblings. The only implicit signal is that it operates on a source's parts list, which is insufficient to choose between this and blueprint_part/blueprint_check.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not that this is a read-only operation, not what happens when the gun is unknown, and not whether the default 'what' value affects behavior. 'As it stands' hints at current-state retrieval but never explains it.

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

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

A single short sentence with no padding, which is structurally clean, but its brevity comes from under-specification rather than economy. The front-loaded content is a noun phrase with no actionable verb.

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

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

With no annotations, no output schema, and only half the parameters documented, the description is far too thin for an agent to invoke this correctly. It says nothing about return format, the gun identifier, or how the default 'what' value changes the result.

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

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

Schema description coverage is only 50%, and the undocumented 'gun' parameter is the required one. The description's mention of 'blueprint or sources' loosely echoes the 'what' enum values already given in the schema, adding no syntax, format, or identifier guidance for 'gun'.

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

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

The description is a noun phrase ('The gun's blueprint or sources document as it stands') that restates what the tool's name already implies rather than stating a verb and scope. It offers no differentiation from the many sibling blueprint_* tools (blueprint_text, blueprint_page, blueprint_specs), so an agent cannot tell what makes this read distinct.

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

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

There is no guidance on when to use this tool versus alternatives such as blueprint_text, blueprint_page, or blueprint_source_add. No preconditions, no exclusions, no mention of what 'as it stands' implies about freshness or state.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose the output classification scheme and that captions are returned, which is genuinely useful, but it omits permission requirements, whether processing is synchronous or long-running, and any dependency on a prior source-add step.

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

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

A single front-loaded sentence with no wasted words; it delivers the essential output contract compactly. It reads as a fragment with no stated subject or action verb for the tool itself, but it earns its length.

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

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

For a 2-parameter required-input tool with no annotations and no output schema, the description covers the return categories but leaves the crucial 'gun' parameter, prerequisites, and error behavior unexplained. Incomplete for its complexity.

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

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

Schema coverage is 0% and neither parameter is mentioned in the description. 'gun' is entirely opaque — an agent cannot infer its format or meaning from name, schema, or description. This is a severe gap for a required parameter.

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

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

The description states a specific verb and resource: sorting every page of a source into five named categories plus captions. It is concrete enough to distinguish from siblings like blueprint_page or blueprint_text, though it doesn't explicitly say how it differs from blueprint_read or blueprint_specs.

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

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

There is no guidance on when to call this versus blueprint_read, blueprint_page, blueprint_text, or blueprint_source_add. No prerequisites (e.g. must the source be ingested first?) and no exclusions are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a time-consuming rendering operation (the 'minutes in Blender' parenthetical) but does not state cost, duration, permissions, side effects, or whether outputs are written to disk or returned inline. It also does not clarify what happens if the gun has not completed the Gun Kit pipeline. The parenthetical about Blender time is a useful hint but insufficient for a tool with no annotation coverage.

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

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

The description is a single long run-on sentence dense with visual element lists ('a title card, the source beside the copy, a turn round it, its clips (fire slowed, the reloads, the checks)'). It is not front-loaded with the core purpose and buries the actual output formats (GIF, MP4) at the end. The prose style prioritizes flavor over efficiency.

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

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

For a tool with no output schema, no annotations, four parameters at 25% schema coverage, and a complex rendering pipeline, the description is inadequate. It does not specify the return value (file paths? URLs?), the required state of the gun, expected runtime, or how to handle errors. It leaves critical gaps an agent needs to invoke the tool correctly.

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

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

Schema description coverage is 25% — only compare_figure has a schema description. The description mentions 'a title card' and 'the source beside the copy,' which loosely map to title and source_note/compare_figure parameters, but it does not explain what gun should be (a name? a path? an ID?) or what format title and source_note accept. With three undocumented parameters, the description does not compensate for the low coverage.

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

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

The description states what the tool produces — a showcase render with a title card, source/copy comparison, turntable, and clips, output as GIF and MP4. However, it never states a clear verb+resource like 'renders a showcase video of a built gun' in a direct way, instead using a descriptive list of visual elements. An agent can infer it generates showcase media, but the phrasing is more evocative prose than precise function definition. It does distinguish itself from siblings like blueprint_page or gunkit_export by describing a unique multi-element video output.

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

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

There is no explicit when-to-use guidance, no prerequisites stated (e.g., does the gun need to have been through Gun Kit first?), and no exclusions or alternatives named. The phrase 'has been through Gun Kit' implies a precondition but does not state it as a requirement. With many sibling tools related to blueprints and gunkit, the agent is left to infer when this tool is appropriate.

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

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

With no annotations, the description carries the full behavioral burden. 'Registers' implies a mutation and 'opens it as data only' hints at safe handling, but it says nothing about permissions, idempotency of source_id, behavior on duplicate registration, or failure modes for a 12-parameter write.

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

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

Two short sentences with no filler, and the key scope ('registers a file ... as one of a gun's sources') is front-loaded. It is arguably under-specified rather than over-long, but it is tight and well ordered.

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

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

No output schema and no annotations, so the description must do all the work for a 12-param (6 required) tool — yet it leaves the return value, the multi-step context it hints at, and most parameter meanings unspecified. An agent could invoke it, but with substantial guessing.

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

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

Schema description coverage is only 25% — kind, distribution and license_basis are documented in-schema, while url, file, year, credit, gun_title, publisher, title and source_id are bare. The description adds only 'PDF or picture' for file and 'with its license', leaving most parameters unexplained in either place.

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

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

Names a specific verb (registers) and resource (a file as one of a gun's sources with its license), which is far more informative than a tautology. It also signals a workflow position ('Step 1'), helping distinguish it from siblings like blueprint_fact_add or blueprint_figure_add, though it never names an alternative explicitly.

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

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

'Step 1' implies this must run first in a sequence, which is genuine sequencing guidance. However, it never says what step 2 is, when not to use this tool, or how it relates to the other blueprint_*_add siblings, so usage is only implied.

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

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

With no annotations, the description carries the full disclosure burden, and it fails to say whether this is a read or a write operation, whether candidates are persisted or merely returned, or what permissions/state it touches. The phrase 'before adding it' further muddies whether this tool mutates state or not.

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

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

It is short, but the colon-chained phrasing ('...weights...): the line, the numbers near it') is cryptic and hard to parse, so brevity comes at the cost of clarity rather than trimming waste.

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

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

With no annotations and no output schema, the description must be self-sufficient, yet it omits what the tool returns, how candidates are represented, and how the parameters map to behavior. For a 2-param tool in a dense blueprint_* family, this is inadequate.

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

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

Schema description coverage is 0% and the description never mentions either parameter ('gun' or 'source_id'). Param names are somewhat self-evident, but the description adds no meaning, format, or constraints—leaving the required 'gun' input entirely unexplained.

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

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

The description conveys that the tool surfaces candidate values for data-table quantities (overall length, barrel length, weights) tied to a line and nearby numbers, which gives a rough sense of the resource. However, there is no clear verb—it never states whether it retrieves, extracts, or registers candidates—and it does not distinguish itself from closely named siblings like blueprint_numbers, blueprint_measure, or blueprint_fact_add.

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

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

'Step 2' signals a position in a workflow, and 'Check a candidate on the page picture before adding it' implies a verification-then-add sequence, which is mild procedural guidance. But there is no explicit when-to-use vs alternatives, no mention of which sibling performs the actual 'adding', and no prerequisites are stated.

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

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

With no annotations, the description must carry the full behavioral burden, and it does not. It implies a read operation but says nothing about the return format, whether results are truncated or paginated, auth/permission needs, or any error behavior. Only the bare notion of 'text' is disclosed.

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

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

It is a single front-loaded sentence with no padding, which is good, but the trailing parenthetical is more confusing than clarifying and the sentence is under-specified for a four-parameter tool. Appropriately short but the words spent don't earn their place.

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

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

A four-parameter tool with a required 'gun' argument, no annotations, no output schema, and 25% schema coverage needs far more description than this. The required parameter is entirely unexplained and the two operating modes are only gestured at, so the definition is not complete enough to call the tool reliably.

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

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

Schema coverage is only 25%, so the description must compensate, but it explains only 'page' and 'pattern' (the latter already documented in the schema). The required parameter 'gun' and 'source_id' receive no explanation at all, leaving the agent unable to infer their meaning or format.

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

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

The fragment identifies a concrete resource (a page's text) and a second mode (regex-matched lines across sources), which is more than a tautology. But it lacks a clear verb and never distinguishes itself from siblings like blueprint_page, blueprint_read, or blueprint_figure. An agent can guess it's a text-retrieval tool but cannot confidently separate it from the other blueprint_* readers.

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

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

There is no explicit when-to-use, no condition under which to choose page mode over pattern mode, and no named alternative. The parenthetical ('where a part or a number is named') hints at intent but is too cryptic to serve as routing guidance.

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

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

With no annotations, the description carries the full burden, and it does disclose that this runs in Blender and takes several minutes, plus the outputs it produces. However, it omits whether the operation overwrites existing rigs/clips, what auth or setup is required, and other side effects.

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

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

The description is a single compact sentence that front-loads the step number and duration, which is efficient. But the telegraphic phrasing is cryptic and sacrifices clarity for brevity, making it less useful than a slightly fuller statement.

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

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

Given no annotations, no output schema, and zero schema description coverage for two parameters, the description is too thin. It hints at the pipeline stage and duration but leaves parameter semantics, prerequisites, and behavioral safety details entirely unexplained.

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

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

Schema description coverage is 0% for both parameters. The description does not explain what the required 'gun' argument should contain or what 'grip_steps' controls. It offers only the incidental phrase 'gun clips', which does not clarify the parameter's meaning or format.

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

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

The description names a pipeline step and lists operations (rig, hand clips, gun clips, read-back), but it uses no clear verb and does not distinguish this from siblings like gunkit_build, gunkit_rig, or blueprint_build. An agent can infer it processes a built model through Gun Kit, but the exact action remains vague.

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

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

The phrase 'Step 7' implies a position in a sequence, which gives some implied usage context, but it never states when to use this versus alternatives or what prerequisites must be met. No exclusions or alternative tool names are provided.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Kept for the plan' and 'Look at the picture it writes' hint at a persistent write and an image output, but nothing is said about permissions, side effects, error behavior, or what exactly gets stored. For a 15-parameter tool this is a significant gap.

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

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

Only two sentences, so it is not bloated, but the writing is oblique and front-loads atmosphere over the concrete action. The key verb and return behavior are buried or absent, so brevity here costs clarity rather than earning it.

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

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

With 15 parameters, no annotations, no output schema, and only 53% schema coverage, the description should do far more. It omits return format, persistence semantics, and most parameter behavior, leaving an agent without enough to invoke it confidently.

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

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

Schema coverage is 53%, and the description partially compensates by tying each method mode to its scenario, which clarifies method plus the region/seed/rough/box parameters. It adds no meaning for the many tuning parameters (light, eps_px, gap_px, close_px, radius_px), leaving the coverage gap only partly filled.

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

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

The description implies the tool produces an outline/trace from a figure ('An outline from a figure, kept for the plan'), but the phrasing is poetic and never states a clear verb like 'extract' or 'vectorize'. It does not distinguish the tool from siblings such as blueprint_figure_add or blueprint_mark, so an agent must infer the purpose.

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

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

The four listed modes (whole silhouette, closed area round a seed, rough outline snapped onto the ink, patch in a halftone) map onto the method values silhouette/region/snap/blob, which gives implicit guidance for choosing a method. However, there is no explicit when-to-use vs siblings or statement of preconditions.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing. It does not say whether views are persisted, whether omitted optional views cause failure, what 'source' implies about provenance, or what side effects occur. The single clause 'each with its source' is the only operational hint.

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

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

It is a single front-loaded sentence with no padding, so it is structurally clean. But conciseness here shades into under-specification -- trimming has removed the verb and any actionable content, so brevity is not an unalloyed virtue.

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

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

For a geometry tool with six parameters (four optional/nested-ish), no annotations, and no output schema, the description is far too thin. It omits the action performed, what is produced, how the three views interact, and how the required gun/part_id scope the operation, leaving an agent unable to call it confidently.

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

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

Schema description coverage is 33%, so the description must compensate and only partly does: it lends meaning to top, front, top_source, and front_source ('side outline, front sections, a top outline, each with its source'). However, gun and part_id -- both required -- are entirely unaddressed, and 'side outline' does not map to any schema parameter, actively introducing confusion about which fields are expected.

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

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

The description conveys the conceptual action -- shaping a part from three orthogonal views (side outline, front sections, top outline) -- but the actual operation (create? add? update?) is never stated, so it reads more like a poetic label than a describable verb+resource. It gestures at distinguishing content from siblings but never names or contrasts them, leaving an agent unsure how it differs from blueprint_part, blueprint_trace, or blueprint_frame.

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

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

There is no when-to-use, when-not-to-use, or alternative routing. With a large family of blueprint_* siblings, this is exactly the tool that needs routing guidance, and it supplies none. 'The detail pass' vaguely implies a stage, but no condition selects it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It never says whether the check is read-only, what 'contract' means concretely, what a failure looks like, or whether it mutates/downgrades the file. Only the accepted input categories are disclosed.

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

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

A single front-loaded sentence with the verb and resource first, then the enumeration. Nothing is wasted, though the parenthetical kind list carries most of the sentence's weight.

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

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

With no annotations and no output schema, the description should explain what a 'check' returns (pass/fail verdict, diagnostics, exit condition) and the read-only nature of the call. Neither is covered, leaving an agent unable to predict the result of invoking it.

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

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

Schema coverage is 67% and the schema itself already enumerates 'kind' values and explains job_path ('for rows: the job they answer'). The description's kind list largely restates the schema's own description, adding no format, default, or constraint detail beyond it.

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

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

States a specific verb ('Checks') and resource ('a file against its contract') and enumerates the accepted file kinds (probe job, rows, parts, digitizer sources/blueprint/partsmap). It is much more specific than a sibling like blueprint_check or gunkit_verify, though it never explicitly contrasts itself with them.

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

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

There is no guidance on when to run this versus blueprint_check, gunkit_verify, spec_validate, or gunkit_inspect, all of which sound like validation tools in the same family. The kind list implies usage but no condition, sequencing, or exclusion is stated.

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

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

With no annotations, the description carries the full burden. It does disclose one important trait — that an add can replace an existing case (upsert by id) — but says nothing about what gets overwritten, whether the replacement is destructive or reversible, or whether approval/validation follows.

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

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

A single five-word sentence with no filler and the key behavior (add-or-replace) front-loaded. It is efficient, though its brevity shades into under-specification rather than disciplined conciseness.

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

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

For a mutation tool with no annotations, no output schema, and a structured nested object parameter, the definition is far too thin. It never explains the effect of the call, what happens on conflict with an existing case id, or what the caller gets back, all of which the agent must guess.

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

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

Schema description coverage is 100% and the nested object field lists its members ({id, weapon, action, metric, rule, about, source}), so the schema does the heavy lifting. The description adds nothing about the single `case` parameter, so the baseline of 3 applies.

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

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

"Adds or replaces a case" gives a specific verb pair and a resource, and the "or replaces" wording usefully signals upsert semantics. However, "case" is domain jargon left undefined (the schema reveals it is a rule/weapon/action/metric bundle), and nothing distinguishes it from the many sibling gate_* tools such as gate_cases.

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

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

There is no when-to-use guidance, no prerequisites, and no named alternative among the roughly 50 sibling tools. An agent cannot tell from the description whether this is the right entry point versus gate_cases, gate_propose, or gate_set_baseline.

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

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

With no annotations, the description carries the full burden. It does disclose one important trait: approval requires human authorization and is not an automatable write. It omits what the approval actually changes (does it unlock a gate, freeze a proposal, notify anyone?) and whether the action is reversible.

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

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

Two short sentences with the core action front-loaded, so nothing is wasted. But the brevity borders on under-specification rather than disciplined conciseness for a mutation tool with two required parameters.

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

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

No annotations, no output schema, and a mutation tool whose side effects, post-conditions, and permission requirements are all absent. For an approval action in a gated workflow, an agent lacks nearly everything needed to invoke it responsibly.

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

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

Schema coverage is only 50%, so the description must compensate, and it largely does not. 'proposal' is never explained (identifier, name, or ID?) and 'approved_by' adds nothing beyond the schema's own 'who approved, in their words'.

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

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

States a specific verb and resource ('Marks a passed proposal approved') plus a precondition ('passed'), which is more than a tautology. It does not, however, distinguish itself from siblings such as gate_verdict or gate_propose, which an agent must choose between in this crowded gate_* family.

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

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

'Only on a person's word' implies the trigger condition — a human has authorized approval — but never states when to call this versus gate_verdict or gate_proposals, nor any exclusion or ordering requirement. Usage is inferable but not spelled out.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about whether this is a read or write, what permissions are needed, or what happens on invocation. It only restates the domain concept of a 'case'.

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

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

It is short and has no filler, but that is because it is under-specified rather than concise. A fragment with no leading verb leaves nothing usable front-loaded.

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

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

For a tool with two undocumented parameters, no annotations, and no output schema in a dense sibling namespace, the description supplies almost nothing an agent needs to call it correctly. It is effectively a glossary entry, not a tool description.

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

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

Schema coverage is 0% and the description never addresses the two parameters (status, weapon), not even to say whether they act as filters. 'Weapon' appears only in the definitional parenthetical, not as parameter guidance, so the agent cannot infer how to use either argument.

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

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

The description is a noun-phrase fragment ('The cases...') that defines what a case is but never states a verb or what the tool actually does with them (list? fetch? filter?). It does not distinguish gate_cases from siblings like gate_add_case, gate_metrics, or gate_weapons.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of any alternative such as gate_add_case for creating cases or gate_metrics/gate_weapons for the related resources. The agent is given no routing information.

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

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

With no annotations, the description carries the full behavioral burden and largely fails: it does not say whether this is a read or a compute/trigger operation, whether it requires a prior run or baseline, or what 'trusted' means as a returned signal. It does hint at the shape of the result (per-provider counts plus a trust flag), which is the only behavioral content present.

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

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

It is short, but this is under-specification rather than concision: a single elliptical fragment with a colon-led field list and no subject, verb, or front-loaded statement of function. Every word is terse but the sentence does not earn its place as a complete tool definition.

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

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

With no annotations, no output schema, and no parameters, the description is the only carrier of meaning, and it omits whether the tool runs or reads evals, what 'trusted' gates, and how results relate to gate_verdict/baseline. For a tool in a dense gate_* family, that is insufficient.

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

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

The schema has zero parameters, so per the rubric the baseline is 4. There is nothing for the description to clarify, and it does not misdescribe any input.

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

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

The fragment names a resource area ('each provider's eval') and enumerates three output fields (faults caught, good cases passed, trusted), so an agent can guess this surfaces per-provider eval outcomes. But there is no verb — it never says whether it reads stored results, triggers an evaluation, or summarizes a prior run — leaving the purpose vague against siblings like gate_cases, gate_metrics, gate_run and gate_verdict.

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

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

No when-to-use guidance at all: nothing states when to call gate_evals rather than gate_run, gate_metrics, or gate_verdict, and no prerequisites or exclusions are given. The agent must infer the routing from the name alone.

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

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

With no annotations the description carries the full burden, and it does disclose the shape of the returned data (provider, unit, direction-of-improvement, tolerance) — useful since there is no output schema. However, it never states that this is a read/list operation, nor anything about scope, side effects, or auth, so the behavioral picture is only half-drawn.

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

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

Nine words with zero filler and no repetition. The telegraphic, verb-less phrasing costs some clarity, but not enough to call it padded or poorly structured.

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

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

For a zero-param, no-output-schema list tool the description usefully enumerates the return fields, but with no annotations and no schema to lean on it should also say what a 'gate metric' is, that the call is a safe read, and how it relates to the surrounding gate_* family. Adequate but with clear gaps.

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

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

The tool takes zero parameters, so per the baseline rule a 4 applies; there is nothing for the description to add on this dimension.

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

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

The description names the resource (metrics) and enumerates the fields returned, but as a bare noun-phrase fragment with no verb it never says what action the tool performs (list? get definitions?). It is distinguishable from siblings like gate_cases/gate_weapons by the 'metric' subject, but the operation itself must be inferred.

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

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

There is no when-to-use, when-not-to-use, or alternative routing guidance at all. The agent cannot tell from the text why it would call gate_metrics versus gate_cases or gate_verdict.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about what the tool actually does, mutates, or returns. The phrase 'passed, approved' is ambiguous and could imply approval mutation, which would be a serious undisclosed side effect.

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

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

It is short, but it is under-specified rather than concise. A four-word fragment is not front-loaded with actionable meaning; it reads like a slogan, not a tool description.

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

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

For an operation sitting among gate_* siblings with no annotations and no output schema, the description is completely inadequate. An agent cannot tell whether calling this mutates state, what it returns, or how it relates to gate_propose/gate_approve/gate_verdict.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. The baseline for a 0-param tool is 4, and there is no parameter-related gap to penalize.

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

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

The description 'Every proposal: passed, approved.' is a fragment that restates outcomes rather than stating what the tool does. It reads as a status summary or a tautology, not a specific verb+resource, and gives no way to distinguish it from siblings like gate_propose, gate_approve, or gate_verdict.

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

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

There is no when-to-use guidance, no condition selecting this tool over gate_propose/gate_approve/gate_verdict, and no exclusions. Nothing tells the agent when to invoke it.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the proposal is staged, measured, judged, and waits for a person's approval, but it omits permissions, side effects, mutation scope, and what the call returns.

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

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

The single sentence is short but cryptic and not front-loaded with a clear action. Its brevity reflects under-specification rather than efficient communication for a 6-parameter tool.

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

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

Given 6 parameters, no annotations, no output schema, and dense sibling tooling, the description is far from complete. It adds only a high-level approval lifecycle hint and leaves parameters, usage, and behavior unexplained.

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

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

There are 6 parameters with 0% schema description coverage, and the description explains none of them. Terms like targets, providers, actions, staging, and weapons are left entirely undefined.

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

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

The description hints at a proposal that is staged, measured, judged, and approved, but it never states a clear verb+resource (e.g., 'create a gate proposal'). It is too metaphorical and vague to let an agent distinguish it confidently from gate_approve, gate_proposals, or gate_run.

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

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

It implies the tool is used when a change needs human approval, but it gives no explicit when-to-use, when-not-to-use, or alternative tools. The many gate siblings make this omission costly.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that a run is stored (a mutation/side effect), which is useful, but omits permissions, idempotency, whether it overwrites or appends, concurrency behavior, and what 'measuring' entails. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, front-loaded sentence with no wasted words, which is structurally efficient. However, its brevity reflects under-specification rather than helpful conciseness, since essential context about usage, parameters, and behavior is missing.

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

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

Given a 4-parameter tool with no annotations, 0% schema description coverage, no output schema, and many sibling tools, the description is far too thin. It leaves the agent without the usage guidance, parameter semantics, or behavioral details needed to invoke the tool correctly. It is not entirely empty, but it has major gaps.

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

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

Schema description coverage is 0% across 4 parameters. The description only name-drops 'weapons' and 'providers' without explaining their meaning, expected values, or relationship. The 'actions' and 'staging' parameters are completely undocumented in both the schema and the description, leaving half the inputs opaque.

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

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

The description contains a verb ('Measures') and a resource ('weapons with the providers'), plus a side effect ('stores the run'). However, the domain terms 'weapons' and 'providers' are opaque, and it does not differentiate gate_run from sibling tools like gate_evals, gate_metrics, or probe_run. An agent would struggle to know what a 'gate run' actually does.

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

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

There is no guidance on when to use this tool versus alternatives like gate_evals, gate_metrics, gate_verdict, or probe_run. No prerequisites, no exclusions, and no context about when a gate run is appropriate. The description provides no when-to-use information.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one behavioral trait beyond the schema – the new baseline is merged over rather than replacing the old – but it omits whether the operation is reversible, what permissions it needs, and what happens to existing baseline data not present in the run.

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

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

A single short sentence with no padding, so nothing is wasted. But the terseness borders on cryptic and the parenthetical merge note is buried rather than front-loaded as a key semantic.

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

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

For a mutation tool with no annotations, no output schema, and an undocumented parameter, the description is far too thin. An agent cannot determine prerequisites, side effects, or expected outcome from this definition alone.

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

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

Schema description coverage is 0% for the single run_id parameter, so the description must compensate. 'A run's rows' implies run_id selects the source run, but it gives no format, identifier scheme, or constraint on which run is valid, leaving the parameter largely unexplained.

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

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

The description conveys that a run's rows are promoted to become the baseline and that the old baseline is merged over, which is a specific state-changing action on a named resource. However, it relies on undefined domain jargon ('rows', 'baseline', 'merged over') and gives no hint of how this differs from siblings like gate_run, gate_verdict, or gate_approve.

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

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

There is no when-to-use guidance, no prerequisite (e.g. whether the run must be completed or approved first), and no mention of alternatives despite a large set of gate_* siblings. The agent must infer the trigger condition entirely.

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

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

With no annotations, the description carries the full burden. It discloses the pass/fail decision logic, which is genuinely useful, but says nothing about whether the tool is read-only or records/writes a verdict, whether it requires a baseline or approval, what happens on failure, or any auth constraints.

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

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

A single tight sentence with three parallel conditions; nothing is padded. It is under-specified rather than overwritten, but structurally it is front-loaded and wastes no words.

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

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

For a verdict/mutation-capable tool with no annotations, no output schema, and zero parameter documentation, the description is far too thin. An agent cannot determine what it returns, what state it changes, or how to populate run_id and targets correctly.

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

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

Schema description coverage is 0% across two parameters. The phrase 'target cases' loosely hints that the optional 'targets' parameter supplies case identifiers, but run_id is entirely unexplained and no format, defaults, or null-vs-array behavior is described.

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

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

The description conveys the criteria that make a verdict 'pass' (target cases pass, no regressions past tolerance, checks trusted), which is distinctive relative to siblings like gate_metrics or gate_cases. However, it never states the actual action — evaluating a run and returning a verdict — so the verb is left for the agent to infer from the name alone.

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

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

There is no guidance on when to call this versus gate_run, gate_cases, gate_metrics, gate_propose, or gate_approve, and no stated prerequisites or sequencing within the gate pipeline. Usage can only be inferred from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether the call is a read or a mutation, not what 'weapons' refers to, not whether it needs auth, and not what it returns. The fragmentary noun phrase gives the agent no behavioral signal at all.

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

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

It is short, but this is under-specification rather than conciseness — a single ambiguous noun phrase that consumes minimal space while conveying almost nothing. No useful information is front-loaded because there is essentially no information.

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

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

With no annotations, no output schema, and no parameters, the description is the only channel available, and it supplies no indication of purpose, return shape, or effect. For a zero-argument tool in a large gate_* family, this leaves the agent unable to determine its behavior.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The schema is trivially complete with 100% coverage and there are no arguments whose semantics need explaining.

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

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

The description is a noun fragment ('The project's weapons') with no verb, so it does not say what the tool does — list them, count them, configure them, or something else. It restates the tool name in vague terms rather than defining an action, and it does nothing to distinguish itself from siblings like gate_cases, gate_metrics, or gate_run.

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

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

There is no when-to-use guidance, no exclusions, and no mention of any alternative tool. An agent has no basis for choosing gate_weapons over the many other gate_* siblings.

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

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

With no annotations, the description carries the full burden. It does useful work by enumerating the conceptual return contents (parts, marks, clip events, manuals), implying a read-only lookup, but it never states read-only nature, permission needs, behavior for an unknown action, or result shape in any structural sense.

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

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

A single dense sentence that front-loads the core scope ('one action in full') before enumerating contents. No filler, though the domain jargon makes it less immediately scannable.

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

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

With no output schema, the description is the only source of return information, and it does list the main content categories. However, it omits error/not-found behavior, parameter expectations, and any pointer to the sibling list tool, leaving real gaps for a lookup tool with one undocumented parameter.

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

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

The single parameter 'action' has 0% schema description coverage and is never addressed in the description. While the name makes its intent reasonably inferable, there is no indication of expected format (name, ID, path) or valid values, so the description fails to compensate for the coverage gap.

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

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

The description names a specific resource and scope – a single action returned 'in full' – and enumerates exactly what is included (parts, marks, gun-clip beats, hand events, reasons/sources, manuals). This distinguishes it from the plural sibling gunkit_actions by implication, but the retrieval verb is only implied and the sibling is never named or contrasted.

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

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

There is no when-to-use guidance, no exclusions, and no mention of alternatives such as gunkit_actions (list) or gunkit_inspect. The agent must infer from the name alone that this is the single-item detail lookup rather than the list.

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

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

No annotations are provided, so the description carries the full burden. It hints at payload shape ('each one's guns, parts and clips') but never states that this is a read-only static reference, whether results are cached or large, or how it relates to the parameterized gunkit_action lookup. That is thin disclosure for an unannotated tool.

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

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

A single front-loaded sentence states the purpose, then spends the remainder on the enumeration it returns. The parenthetical list is long but earns its place by telling the agent which action categories exist, which is the point of the tool.

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

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

With zero parameters, no annotations and no output schema, the description is nearly sufficient: it says what is returned and roughly with what granularity. It still omits any structural detail of the response beyond 'guns, parts and clips', and gives no relationship to gunkit_action or the other gunkit_* tools.

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

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

The input schema declares zero properties, so there are no parameters to document; the baseline for a 0-parameter tool is 4. The parenthetical action names do double duty as informal vocabulary, but no formal parameter semantics exist to clarify.

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

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

The description names a specific resource (the catalogue of gun action kinds Gun Kit knows) and enumerates the categories it covers, so an agent knows this is a static enumeration lookup rather than an operation. It does not distinguish itself from the singular sibling gunkit_action, leaving the list-vs-single relationship to inference.

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

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

There is no when-to-use statement, no mention of the sibling gunkit_action for looking up one action, and no indication of whether this is a discovery step before gunkit_build or gunkit_rig. Usage is only implied by the noun phrase.

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

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

No annotations are provided, so the description carries the full disclosure burden. It offers one useful hint ('Minutes per gun' → long-running) and mentions checks performed (clearance, anatomy, grip), but says nothing about what it writes, whether it overwrites existing clips, auth/permission needs, or failure modes for a mutation/build operation.

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

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

It is a single run-on sentence with a nested parenthetical that buries the actual action; the purpose is not front-loaded and the phrasing is opaque rather than efficient. Size is short, but structural clarity is poor.

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

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

For a minutes-long build/mutation tool with no annotations and no output schema, the description omits prerequisites, what it produces, file side effects, and relationship to the rest of the gunkit pipeline. An agent cannot tell what resources it needs or what it will return.

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

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

Schema coverage is only 50%: 'facts' is described in the schema, but 'grip_steps' (default 3) has no description anywhere. The prose never mentions either parameter or explains what 'facts'/'gunfacts.json' should contain or how grip_steps affects output, so it fails to compensate for the coverage gap.

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

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

The description gestures at a domain ('Every clip of one gun', hand clips, gun clips, checks, sights) but never states a clear verb+resource, e.g. 'generates animation clips for a rigged gun.' It reads as jargon-laden restatement rather than a definition an agent can act on, and it does nothing to distinguish gunkit_build from siblings like gunkit_rig, gunkit_draft, or gunkit_verify.

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

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

There is no when-to-use, when-not-to-use, prerequisite, or alternative-tool guidance. With 50+ sibling tools (gunkit_rig, gunkit_verify, gunkit_export, gunkit_draft), the absence of routing is a real gap, though the text is not actively misleading.

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

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

With no annotations, the description carries full behavioral burden. It does disclose a dual read/write mode tied to the add flag, which is genuinely informative. However it says nothing about permissions, what 'writing into the Gate' overwrites, whether the write is reversible, or what a read returns — critical gaps for an operation that mutates state.

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

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

It is a single compact sentence with no filler and the subject is front-loaded, so it is efficiently sized. The density of unexplained metaphor, however, means the brevity is achieved at the cost of comprehensibility, and the parenthetical clause is hard to parse.

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

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

No output schema, no annotations, and 0% parameter documentation mean the description is the only information source, and it is too thin. For a tool whose add flag triggers a write, it should at minimum describe the return shape and the write's effect.

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

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

Schema coverage is 0%, so the description must compensate for all three parameters. It loosely maps 'weapon' to 'gun', refers to 'an action', and explains that add writes the cases in — but it gives no format, accepted values, or identity semantics for weapon/action, so an agent still cannot confidently populate them.

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

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

The description gestures at a verb+resource pair (retrieve the Gate cases attached to a gun of an action, and optionally write them when add is set), so it is not pure tautology. But the vocabulary — 'gun', 'Gate', 'clip's read-back', 'hand clip's checks and sights' — is opaque jargon that an agent cannot map onto a concrete resource without external domain knowledge, leaving the actual purpose ambiguous.

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

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

There is no guidance on when to call this versus the many closely named siblings (gate_cases, gate_add_case, gunkit_action, gunkit_inspect). The only implicit usage signal is that setting add changes read into write, which is a behavioral note rather than a when-to-use rule. No prerequisites or exclusions are given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose that the tool writes a confirmed map to a file, which is one side-effect signal, but it says nothing about permissions, reversibility, file format, overwrite behavior, or whether the confirmation step has side effects. The garbled phrasing further reduces clarity.

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

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

The description is two sentences but is poorly structured: the first sentence is a fragmented noun phrase with an unhelpful parenthetical list, and the second jumps to writing a file. It is not excessively long, but the wording is garbled and the key action is buried. Front-loading and clarity are both weak.

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

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

For a tool with three parameters, no annotations, no output schema, and 0% schema coverage, the description is far too thin. It omits prerequisites, expected inputs, output format, and relationship to gunkit_rig beyond a single mention. An agent has almost no basis for calling this tool correctly.

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

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

The schema description coverage is 0% and there are three parameters: name, model, and action. The description mentions 'a model' and 'to confirm', but does not explain what 'action' accepts, what 'name' refers to, or how 'model' should be formatted. With no enum hints either, parameter semantics are effectively undocumented.

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

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

The description gestures at a purpose ('first parts map', 'write the confirmed map to a file for gunkit_rig') but never states a clear verb+resource. The parenthetical 'forward, units, the bolt face, each part, each mark' is cryptic and does not help distinguish gunkit_draft from siblings like gunkit_rig or blueprint_part. An agent cannot reliably infer what the tool actually does.

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

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

There is no when-to-use guidance, no exclusions, and no named alternative. The only hint is the destination mention 'for gunkit_rig', which implies a downstream consumer but not when this tool should be chosen. With dozens of sibling tools, this absence leaves the agent with no routing information.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that files are staged and that a build is registered (a side effect), but says nothing about permissions, idempotency, whether staging overwrites existing files, failure modes, or return behavior. This is a significant gap for a tool with an implicit write/registration side effect.

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

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

Two sentences that are dense and front-load the artifact list, with no obvious filler. However, the run-on enumeration of artifacts is hard to parse and pushes the actionable 'registers the build' clause to the end, weakening front-loading.

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

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

With no annotations, no output schema, and 33% parameter coverage, the description is the only source of behavioral and argument context – and it is inadequate. It never explains the required 'facts' and 'game_id' inputs, and omits any guidance on workflow placement, so an agent cannot confidently invoke it correctly.

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

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

Schema description coverage is only 33% – only 'base' is documented, while 'facts' and 'game_id' (both required) have no schema description. The prose description adds no meaning for any parameter, leaving two of three arguments, including a required one, unexplained in both structured and unstructured data.

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

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

The description enumerates the artifacts staged (FBX with clips, hand clips, import plan, draft data file, trial copy) and mentions registering the build, so the resource is fairly specific. However, the core action verb 'export' appears only in the tool name; the description reads as a noun phrase about outputs rather than stating 'exports the gun's files for a game'. It also does not distinguish the tool from siblings like gunkit_build, gunkit_draft, or gunkit_proxy.

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

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

There is no explicit when-to-use guidance, no prerequisites, and no mention of alternatives among the many gunkit_* siblings. The mention of 'Registers the build for the Gate's gunkit provider' hints at a workflow role but leaves the agent to infer when this should be called versus gunkit_build or gunkit_draft.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the shape of the returned data (moving parts, travel, hinges, hand marks), which is useful, but says nothing about whether it is read-only or mutating, permission/auth needs, error behavior when build_folder is invalid, or any side effects.

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

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

It is a single, compact sentence with no filler, and the key content (the parts map) is front-loaded. The noun-phrase phrasing is slightly indirect, but nothing is wasted.

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

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

With no output schema and no annotations, the description should carry more weight. It partially describes the return content but leaves the input parameter unexplained and the tool's mutation/read behavior, preconditions, and downstream handoff to gunkit_rig underspecified for a one-param tool.

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

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

There is a single required parameter, build_folder, with 0% schema description coverage, so the description must compensate. The phrase 'A Model Lab build's' loosely hints that build_folder identifies a Model Lab build, but the parameter itself is never named or explained — no format, expected path structure, or validity constraints are given.

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

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

The description names a specific resource (a Model Lab build's parts map) and enumerates its contents (moving parts, travel, hinges, hand marks), which distinguishes it from siblings like blueprint_to_gunkit. The verb is only implicit — it is a noun phrase describing the output rather than stating 'extract/produce the parts map' — but an agent can reasonably infer the tool derives a parts map from a build.

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

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

The phrase 'ready for gunkit_rig' is a downstream pointer, implying this tool feeds into gunkit_rig, which is a faint workflow hint. But there is no explicit when-to-use condition, no prerequisites (e.g. the build must exist), and no comparison to alternatives such as blueprint_to_gunkit or gunkit_build.

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

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

No annotations are provided, so the description carries the full behavioral burden. It helpfully enumerates the return contents (objects, vertex groups, bounds, longest axis, units guess), which is real disclosure, but it never states that the operation is non-destructive/read-only, nor anything about permissions, side effects, or whether the import it describes alters state.

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

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

It is a single sentence with no padding, but the opening clause 'What a model holds as Blender shows it after import' is awkward and front-loads a confusing noun phrase rather than the action. Compact, but the structure costs comprehension.

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

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

With no output schema, the description does useful work by listing the returned fields, and with no annotations it partially covers behavior by implying a read. However it leaves the required parameter undefined and gives no safety profile or workflow placement, so it is only partially complete for the tool.

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

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

Schema description coverage is 0% and the single 'model' parameter has no schema description. The description refers to 'a model' only as the subject of inspection and never clarifies what form the parameter takes (file path, asset name, ID) or its expected format, so it fails to compensate for the coverage gap.

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

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

The description identifies the resource (a model as Blender sees it after import) and enumerates the data revealed (objects, vertex groups, bounds, longest axis, units guess), but never states an explicit verb — 'inspect' only lives in the name. An agent can infer it is a read/inspection operation, yet the sentence's framing as a noun phrase makes the action itself vague, and it does not distinguish it from siblings like gunkit_verify or gunkit_proxy.

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

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

There is no when-to-use or when-not-to-use guidance and no named alternative among the many gunkit_* and rig_* siblings. The trailing phrase 'the starting point of its parts map' weakly implies it belongs first in a pipeline, but that is inference rather than stated guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing concrete: no side effects, no permission/auth requirements, no reversibility, no output or state impact. The metaphorical phrasing ('label every picture of it') actively obscures rather than informs.

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

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

It is short, but the two sentences are jargon-dense and front-load an unclear metaphor rather than the operation. Size is not the problem; the content is opaque and non-actionable.

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

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

With no annotations, no output schema, an undocumented required parameter, and a metaphorical description, an agent has essentially nothing needed to invoke this tool correctly. This is inadequate for even a single-parameter tool.

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

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

The single required parameter 'action' has 0% schema description coverage, and the description never explains what 'action' means, its allowed values, or its format. The burden falls entirely on the description and it does not deliver.

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

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

The description gestures at creating a low-fidelity proxy/test model of a gun ('simple shapes with its real moving parts'), but the prose is metaphorical and never states a clean verb+resource. An agent cannot reliably tell what operation this performs versus siblings like gunkit_build, gunkit_rig, or gunkit_draft from this text alone.

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

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

There is no when-to-use, when-not-to-use, or alternative guidance. The clause 'the whole chain runs on it before a real model exists' hints at a pipeline position but names no sibling and gives no selection criteria.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it delivers almost nothing: no side effects, no file/asset mutations, no error or validation behavior beyond the vague 'facts checked against the action'. Nothing tells the agent whether this writes files or what it returns.

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

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

It is short, but this is under-specification rather than conciseness: the single clause 'one bone a moving part' is opaque and consumes the space where actionable detail should be. The sentence is not front-loaded with a clear action.

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

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

For a tool with no annotations, no output schema, and a pipeline role among many rig_* siblings, the description omits everything an agent needs: output/return behavior, prerequisites, and how it differs from rig_facts or gunkit_verify. Only the input file concept is recoverable, and that comes from the schema.

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

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

Only one parameter, and schema coverage is 100% with the partsmap field documented as a 'weaponlab-partsmap/1' file. The description echoes the parts map concept but adds no format or sourcing detail beyond the schema, so baseline 3 is appropriate.

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

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

The phrase 'A gun rigged for its action from its parts map' gestures at a verb (rig) and a resource (gun), but the inverted grammar and jargon like 'action' make the actual operation hard to pin down. It does not distinguish itself from nearby siblings such as rig_facts, gunkit_verify, or gunkit_build.

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

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

There is no when-to-use statement, no prerequisites, and no naming of alternatives despite many overlapping siblings (rig_facts, rig_pieces, rig_align, gunkit_verify). The agent is left to infer the entire selection context.

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

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

With no annotations, the description carries the full behavioral burden, and it delivers almost nothing. The phrase 'the worst gap a clip, cm' hints that the tool reports a maximum deviation in centimeters, which is a small scrap of output/behavioral context, but permissions, side effects, and whether it mutates rig state are all unstated.

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

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

It is short, but brevity here is under-specification rather than conciseness. The garbled, comma-spliced phrasing ('the worst gap a clip, cm') is hard to parse and buries any usable signal behind unexplained jargon.

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

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

For a 1-required-param tool with no annotations and no output schema, the description must carry everything: what it verifies, what 'facts' is, and what a result looks like. It provides none of this, leaving the agent unable to construct a valid call.

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

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

Schema description coverage is 0% for the single required parameter 'facts', and the description never explains what 'facts' means, its format, or where it comes from (gunkit_draft? gunkit_actions? rig_facts?). Nothing compensates for the schema gap.

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

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

The sentence gestures at a verification action ('read back from Blender against the timeline's sums') but the noun-phrase fragments ('the gun's own clips', 'the worst gap a clip, cm') never resolve into a clear verb+resource statement. It is not a pure tautology of the name, but an agent cannot confidently say what gunkit_verify actually does or how it differs from gate_verdict, contract_check, or spec_validate.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of any alternative among the ~60 siblings (gate_*, contract_check, spec_validate all plausibly overlap). The description offers no condition under which this tool should be selected over those.

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

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

No annotations are provided, so the description must carry behavioral disclosure. It doesn't state whether this is a read-only visualization, a file-writing operation, required permissions, side effects, or output format. The cryptic note about 'dev views' vs 'game's view' doesn't clarify behavior.

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

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

It's a single short sentence, so it is concise, but it is not front-loaded with actionable information and the vague phrasing wastes the limited space on an unclear distinction.

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

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

With no annotations, no output schema, and 0% schema description coverage, the description is critically incomplete. An agent cannot determine what the tool does, what the parameters mean, or what the result will be.

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

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

Schema description coverage is 0%. The description provides no information about the 'objs' array or 'out_folder' parameter—what objects are expected, what format, or what the output folder receives. It fails to compensate for the schema gap.

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

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

The description 'Dev views of parts dumps (not the game's view)' is cryptic and doesn't state a clear verb+resource. It vaguely references rendering but the phrase 'parts dumps' is jargon and the tool name 'motion_render' is not explained.

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

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

No guidance on when to use this tool versus the many sibling motion_* tools (motion_roll, motion_track, etc.) or when not to use it. The parenthetical '(not the game's view)' hints at a distinction but doesn't name an alternative or condition.

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

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

With no annotations, the description carries the full behavioral burden, yet it only hints that twist bones 'share' the rotation. It does not disclose that this writes an output FBX, whether source files are modified, or how the auto degrees behavior affects results.

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

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

A single short sentence, so there is no bloat, but for a 4-parameter file-producing tool with no annotations it is under-specified rather than appropriately sized. The one sentence does not earn its place as sufficient guidance.

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

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

For a mutation-style tool that produces an output FBX, with no annotations, no output schema, and only 25% parameter coverage, the description is far too thin. Nothing about side, source/output paths, or the auto-degrees behavior is resolved.

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

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

Schema coverage is only 25%: degrees has a description but side, src_fbx, and out_fbx do not, and the description adds nothing about them (e.g., what 'r'/'l' mean or that out_fbx is the generated file). The description fails to compensate for the coverage gap.

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

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

The description gestures at a specific operation ('hand turned about its forearm, the twist bones sharing it'), so it is more than a tautology, but it is phrased as imagery rather than a machine-actionable statement of what the tool does. It never says it applies a roll rotation to a hand in a clip or distinguishes itself from siblings like motion_roll_set or motion_roll_profile.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the closely related motion_roll_set and motion_roll_profile siblings. The agent is left to infer that this is the roll-application step and not one of the other motion_roll tools.

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

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

With no annotations, the description carries the full burden, and it discloses only one behavioral fact — that values past 80 degrees exceed the forearm's range. It never states whether this is a read or write operation, what it returns, or what the fbx input must be, leaving most behavior opaque.

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

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

It is a single compact sentence with no filler, and the core concept is front-loaded. However, the parenthetical is cryptic rather than clarifying, so brevity comes at the cost of comprehensibility.

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

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

For a two-parameter tool with no annotations, no output schema, and 0% schema coverage, the description does not supply enough for an agent to invoke it correctly. It neither explains the fbx input nor the side default, and omits return behavior entirely.

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

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

Schema description coverage is 0% and the description never mentions the two parameters (fbx, side). The '0 thumb up' phrasing references a roll value, not a parameter, so neither parameter gains any meaning from the description.

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

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

The description identifies the subject — the hand's roll about its forearm through a clip — but offers no explicit verb or action (profile? measure? return?), so an agent cannot tell what the tool actually does versus merely names its domain. It also fails to distinguish itself from siblings motion_roll and motion_roll_set, which likely operate on the same concept.

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

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

There is no when-to-use guidance, no prerequisites, and no reference to the obvious alternatives motion_roll or motion_roll_set despite their presence in the sibling list. The 80-degree note implies a constraint but not when this tool should be chosen.

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

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

With no annotations, the description carries the full behavioral burden. It says clips are saved under new names but doesn't disclose whether originals are preserved, whether this requires an existing FBX file, what permissions are needed, or whether the operation is reversible. For a mutation tool with 5 parameters, this is a significant gap.

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

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

The single sentence is concise and front-loaded, stating the main action. However, it's so terse that it omits necessary details for correct invocation, making it under-specified rather than optimally concise.

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

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

For a tool with 5 parameters, 0% schema coverage, no annotations, and no output schema, the description is far from complete. It doesn't explain parameter usage, behavioral safety, or expected results. An agent would struggle to invoke this correctly without guessing.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'suffix' and the naming pattern (<name>_<suffix>), which adds some meaning for one parameter. But 'side', 'degrees', 'fbx_files', and 'out_folder' are not explained at all. The description doesn't clarify what 'rolled' means with respect to 'degrees' or 'side'.

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

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

The description states a specific operation on clips ('a set of clips rolled, each from its own start, saved under new names'), which is more specific than the name alone. However, it does not differentiate from sibling motion_roll or explain what 'rolled' means operationally. It's vague enough that an agent can't be sure of the exact transformation.

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

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

There is no indication of when to use this tool versus motion_roll, motion_track, or motion_roll_profile. No prerequisites, no alternatives, no context. The description implies a batch operation but doesn't say when it's appropriate.

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

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

No annotations are provided, so the description carries the full behavioral burden and delivers none of it. It does not say whether src_fbx is read-only or mutated, whether out_fbx is overwritten, what happens when axis or seat are omitted (both default to null), or whether the operation is reversible.

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

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

It is a single short sentence, which would be praiseworthy for a well-scoped tool, but here the brevity reflects under-specification rather than economy. There is no front-loaded statement of action or outcome.

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

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

For a six-parameter, four-required tool that consumes and produces FBX files with no annotations and no output schema, the description is completely inadequate. An agent has no basis for constructing a correct call or interpreting the result.

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

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

Schema description coverage is 0%, so all six parameters are undocumented. The description alludes to 'axis' and 'seat', which correspond to two optional parameters, but gives no format, unit, or default semantics, and says nothing about src_fbx, out_fbx, bone, or root.

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

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

The phrase 'A sliding part's track rebuilt on its axis from its seat' is a fragmented noun phrase rather than a verb+resource statement. It hints at a rebuild operation on a track along an axis, but an agent cannot confidently say what motion_track does or how it differs from motion_roll, motion_roll_set, or rig_part_line.

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

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

There is no when-to-use, when-not-to-use, prerequisite, or alternative-tool guidance anywhere in the description. With roughly ten sibling motion/rig tools, the absence of any routing signal is a serious gap.

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

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

With no annotations, the description carries the full disclosure burden, and it discloses nothing: not whether this is a read-only computation or a mutation, not whether it requires a provisioned job, not what happens on missing actions/weapons. The noun-phrase wording actively obscures the operation.

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

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

It is short, but brevity here comes from under-specification rather than economy; the single clause is a dangling fragment with no verb or subject clarity. There is no front-loaded action statement for the agent to anchor on.

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

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

No output schema, no annotations, and two undocumented optional parameters leave the agent with nothing actionable. Despite the tool being in a dense sibling cluster (probe_*, gate_*), the description provides no grounding to distinguish it or call it correctly.

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

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

Both parameters (actions, weapons) have 0% schema description coverage, so the description must compensate and instead says nothing about their format, string vocabulary, or role. 'weapons' appears in the description but is never explained as an input versus an output field.

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

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

The fragment 'The job's weapons the probe would get' gestures at a planning/inspection operation returning weapons, but it has no verb and no stated resource relationship to siblings like probe_run or probe_status. An agent cannot tell from this whether it plans, previews, or mutates a probe job.

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

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

No when-to-use guidance, no exclusions, and no reference to the related siblings probe_status / probe_run that an agent would naturally confuse this with. Nothing indicates when a plan should be requested versus executing a probe.

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

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

With no annotations, the description carries the full behavioral burden, yet it only hints that screenshots and part dumps are produced. It does not disclose side effects, permission needs, cost, or whether state is mutated by running a probe.

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

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

A single terse fragment with no waste, but it is under-specified rather than concise. The output hints are not front-loaded into a clear purpose statement.

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

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

An 8-parameter execution tool with no annotations, no output schema, and low parameter documentation needs far more than one cryptic sentence. Nothing an agent requires to invoke it correctly is present.

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

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

Schema coverage is only 38%; parameters like parts, shots, slomo, actions, and weapons have no descriptions. The phrase "screenshots and parts dumps at the moments" loosely gestures at shots/parts/at but adds no syntax or format detail, so it fails to compensate for the coverage gap.

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

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

"One probe run" essentially restates the tool name, and the trailing fragment "rows, and screenshots and parts dumps at the moments" is too cryptic to state what the run actually does. It does not distinguish this tool from its probe_status/probe_plan siblings.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as probe_plan or probe_status. An agent has nothing to decide whether to call this versus its siblings.

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

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

With no annotations, the description carries the full disclosure burden, and it fails: it does not say whether this is a read-only diagnostic, what it returns, whether it has side effects, or how 'must not run' conflicts are determined. The only faint signal is that the output concerns currently-running conflicting processes.

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

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

It is very short, which is a virtue, but the brevity comes from under-specification rather than economy — the single fragment is not front-loaded with a verb and reads as a truncated sentence.

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

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

For a zero-parameter tool with no output schema and no annotations, the description is the only source of information about behavior and return content, and it supplies almost none. An agent cannot predict what it will receive or when calling it is appropriate.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. Schema description coverage is 100% trivially.

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

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

The description is a noun phrase with no verb ('The processes that must not run with the probe, running now'), so it never states what the tool actually does — list, check, or report. It gestures at a subject matter (processes conflicting with the probe) but an agent cannot confidently say what action it performs, and it is not distinguished from siblings probe_plan/probe_run.

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

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

There is no when-to-use statement, no prerequisites, and no mention of alternatives such as probe_plan or probe_run. The agent is left to infer the tool's role entirely from its name.

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

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

No annotations exist, so the description carries the full burden. It does disclose the payload contents (folder, data, specs, probe command, Blender) which implies a read-only informational retrieval, but it never states side effects, permissions, or whether it mutates anything. This is partial disclosure only.

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

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