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 at least establish that this is a read operation, which is the key safety signal. Beyond that it discloses nothing about cost, permissions, or freshness of the configuration data, so the disclosure is minimal rather than rich.

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 positive statement first and the disambiguation second; nothing is wasted. The trailing clause about CAD execution is slightly cryptic in isolation but earns its place as the main misuse guard.

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 is trivial (no inputs, output schema present, so return values need not be explained), which lowers the bar considerably. However, "backend configuration" remains vague about what configuration domain is returned, leaving the agent unable to judge relevance before calling.

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 no parameter semantics to explain and the baseline of 4 applies. Nothing in the description contradicts or obscures the empty 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 gives a specific verb and resource ("Read backend configuration") and explicitly negates the most likely misreading of the name backend_status, namely that it is a health check. It does not name or contrast with any sibling tool, but the sibling set (cabinet/design/material/CAD tools) contains no close analogue, so differentiation is less critical here.

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 one useful exclusion ("not a health check of CAD execution"), which prevents a plausible misuse, but no positive statement of when an agent should call this rather than another tool. Usage is only implied by the negation rather than 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, and it discloses almost nothing beyond units: not whether the call persists state, what a "revision" implies about versioning or duplication, whether permissions are required, or whether defaults apply to omitted spec fields. For a mutation tool with destructiveHint unset and no readOnlyHint, 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?

Two short sentences, front-loaded with the operation and followed by the unit convention, with no filler. The brevity is appropriate, though the ambiguous term "revision" consumes part of a very small budget that would have been better spent on the spec fields.

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 output schema exists, so return values need not be explained, but the tool is a nested-object creation call with 0% schema description coverage and zero annotations. Given that complexity, the definition should say what a revision is relative to an existing design and roughly what panel_mm, back_mm, and shelves control; none of that 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 description coverage is 0% across a nested spec with seven sub-properties (back_mm, shelves, depth_mm, material, panel_mm, width_mm, height_mm), so the description needs to compensate. It does add real meaning by stating that all dimensions are in mm and mapping axes as X=width, Y=depth, Z=height, which the schema does not say. However, back_mm, panel_mm, shelves, and material remain undefined beyond their names and ranges.

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: "Create a cabinet revision." That distinguishes it from update_cabinet at a basic level (create vs. update), but the word "revision" is never explained, so it is unclear whether this creates a new cabinet, a version of an existing one, or both. An agent can identify the operation but not the precise object being created.

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 instead of update_cabinet, no prerequisites, and no indication of whether an existing cabinet must exist first or whether the revision needs to reference a parent design. The only usage-adjacent content is the unit convention, which is not a when-to-use rule.

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, and it only reveals that a worker process is launched and which file types come back. It says nothing about execution time, whether the job is synchronous or queued, side effects or artifacts written to storage, failure modes, or permission requirements for a heavyweight export 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 compact sentence with the action front-loaded and the outputs listed after, with no filler. The terseness borders on underspecification, but every clause conveys 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?

Because an output schema exists, the enumeration of return artifacts is supportive rather than essential, and the missing pieces are around inputs and preconditions. For a tool that launches a CAD worker and takes a design identifier, an agent still lacks the information needed to know when the call is safe and what design_id should reference.

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 required parameter design_id is never mentioned in the description, so nothing explains where that identifier comes from (e.g., from create_cabinet or list results) or what it identifies. The description adds no meaning beyond the bare string type in the schema, which is a real gap at this coverage level.

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 concrete action ('Run configured FreeCAD worker') and enumerates the concrete artifacts produced (FCStd, STEP, CAD mesh, measured report), which lets an agent tell it apart from render_preview or inspect_design. It is clear but leans on jargon ('configured worker') rather than stating plainly that it exports CAD geometry for a design.

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 choose this over render_preview or inspect_design, no mention of prerequisites (what 'configured' means, whether the backend must be ready), and no note on whether it can be re-run or called repeatedly. The agent must infer the selection criteria entirely from the tool 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 supplied, so the description carries the full disclosure burden. It implies a read operation but says nothing about permissions, whether analysis is computed on demand or cached, failure modes for invalid design_ids, or whether results are paginated — an output schema exists, so return shape is covered, but the behavioral profile is 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?

A single short sentence with no filler, front-loading the returned artifacts. It is efficient, though it spends its only words enumerating outputs rather than clarifying 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?

For a one-parameter read tool with an output schema, the definition is minimally viable: the agent knows it needs a design_id and roughly what comes back. The missing pieces are the undocumented parameter and absent read-only/behavioral confirmation, which matter more here because there are no annotations to fall back on.

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 single parameter design_id is a bare string with no description in the schema. The description does not mention design_id at all, so the agent gets no help on what identifier format is expected or that the design must already exist.

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 resources returned (analytic dimensions, collision report, bill of materials) but the verb is a generic 'Get' and the target object is never stated — only the parameter name implies it inspects a design. Nothing distinguishes it from siblings like render_preview or export_cad, which also presumably operate on a design.

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 other design-related siblings, no prerequisites (e.g. must the design be fully modeled or synced first), and no indication of cost or latency. The agent must infer usage entirely 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 supplied, so the description must imply behavior — 'Read' does signal a non-mutating operation, and the procedural-vs-scanned distinction sets expectations about content. It does not state whether the result is empty when nothing is available, whether it's cached/static, or any permission requirement, leaving gaps for a zero-annotation 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 short sentence with no filler, and the key qualifier (procedural, not scanned) is placed where it will be read. It is arguably too compressed — one extra clause on what 'available' means would cost little.

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 read tool with an output schema, the description only needs to establish intent and content scope, which it does. Return structure is covered by the output schema, so no explanation of return values is required.

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 no parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description adds no parameter-related claims that could conflict with the empty 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 uses a read verb against a specific resource ('Read available ... materials') and narrows scope with 'procedural PBR approximations, not scanned materials.' The only weakness is that 'Read' doesn't explicitly say it returns a list/catalog of available materials rather than material data itself.

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 clause 'not scanned materials' functions as an implicit when-not, steering an agent away from expecting scanned texture assets. There is no positive guidance on when to call this versus other discovery steps, and the sibling tools are unrelated, so no alternative is named.

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?

Annotations are absent, so the description carries the full behavioral burden. It discloses the two output artifacts, but says nothing about whether rendering is synchronous or long-running, whether it fails on a stale/invalid cad_job_id, whether it overwrites prior renders, or what permissions/costs are involved.

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 action front-loaded and the outputs appended; no filler or redundant restatement of the tool name.

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, an undocumented two-parameter schema, and a render step that is likely expensive or asynchronous, the definition is too thin. The output schema covers return shape, but prerequisites, failure modes, and parameter meaning are all missing.

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, so the description needed to compensate and does not. Neither design_id nor cad_job_id is explained, and the link between "existing FreeCAD export" and cad_job_id is only vaguely implied.

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 ("Render an existing FreeCAD export with Blender") and names the artifacts produced (PNG and editable blend). It is distinguishable from siblings like export_cad or inspect_design, though it never explicitly frames itself as the step that follows an export.

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, when-not-to-use, or alternative guidance is given. The word "existing" faintly implies a prior export must exist, but the agent must infer the prerequisite instead of being told to run export_cad first or to choose this over inspect_design.

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 does disclose the most non-obvious trait: edits do not mutate in place, a new design ID is minted and the prior design survives. It says nothing about permissions, whether validation failures abort the call, or how the new ID is surfaced, so coverage is partial rather than complete.

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. Every clause adds information: validation, new ID creation, and preservation of the original.

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 output schema exists, so return values need not be explained, and the core non-destructive semantics are stated. However, the nested untyped `changes` object is the primary thing an agent must construct, and the definition leaves its contents entirely unspecified.

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 `changes` is a free-form object that accepts arbitrary properties, so the description needed to explain what keys belong there. It only gestures at this with 'parameter changes' and says nothing about whether `design_id` refers to the source design being versioned.

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 action and outcome: it validates parameter changes and returns a NEW design ID while preserving the old one. That versioning semantics is more informative than the bare name 'update_cabinet' would suggest, but it never explicitly contrasts itself with the sibling create_cabinet, leaving the agent to infer the difference.

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 named alternative among create_cabinet, inspect_design, or export_cad. The phrase 'preserving the old design' implies this is the non-destructive edit path, but the agent must infer that routing rather than being told it.

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