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

No annotations are provided, so the description carries the entire behavioral burden, and it discloses nothing: not units, not whether the annotation is placed on a layer, not how the offset distances the dimension from the geometry, and not whether p1/p2 are measurement points or extension-line endpoints.

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 wasted words and is front-loaded, but its brevity reflects under-specification rather than disciplined concision.

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 mutating CAD tool with three required parameters, nested objects, zero schema documentation, and no annotations or output schema requires far more explanation than one tautological sentence. Nothing an agent needs in order to call 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 description coverage is 0% across three required parameters, including a nested p1/p2 object with x/y coordinates and an offset scalar. The description explains none of them, so the agent cannot know what geometry p1/p2 reference or how offset is interpreted or oriented.

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 direct restatement of the tool name: 'Add an aligned dimension annotation' for add_aligned_dimension. It adds no distinguishing detail versus siblings such as add_angular_dimension, add_linear_dimension, or add_ordinate_dimension, which share the identical 'Add a ... dimension annotation' pattern.

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 prerequisites, and no mention of when an aligned dimension is preferred over the linear, baseline, or continued dimension siblings. The agent gets no basis for choosing this tool over its near-identical neighbours.

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 discloses nothing: not whether the annotation is committed immediately or requires a transaction, not the units/angle convention (degrees vs radians), not view/drawing prerequisites, and not what is returned. It only restates the creation action.

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 grammatical sentence with zero filler, so it is concise and front-loaded. However, at this level of brevity it is under-specified rather than efficient given the tool's complexity.

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 required nested-object parameters, no annotations, and no output schema, the description supplies none of the context an agent needs to invoke it correctly. It is materially inadequate for the tool's 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 description coverage is 0% for three required parameters (vertex, p1, p2), and the description adds no meaning at all about their roles (which point is the angle vertex, how p1/p2 define the rays, ordering). The description does nothing to compensate for the complete lack of parameter documentation.

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 ('Add an angular dimension annotation'), and the word 'angular' implicitly distinguishes it from the many sibling dimension tools (aligned, radius, diameter, ordinate). It is clear but does not explicitly route the agent away from those siblings, which is what a 5 would require.

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 add_aligned_dimension, add_linear_dimension, add_dimension_angular, or the other dimension variants in the sibling list. The agent must infer applicability 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?

No annotations are provided, so the description must carry the full behavioral burden. It does not disclose mutation side effects, required permissions, how the drawing is affected, whether the operation is reversible, or any constraints. For a 9-parameter mutation tool, this is a severe 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 short and front-loaded, but it is under-specified rather than concise. It wastes the only sentence on a tautology, leaving no room for useful information. The structure does not earn its 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?

Given 9 parameters with 0% schema description coverage, no annotations, no output schema, and nested object parameters, the description is completely inadequate. It omits nearly everything an agent would need 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 0%, and the description mentions none of the 9 parameters. It does not explain scale, center, cut_line, position, solid_id, direction, view_type, parent_view_id, or drawing_id. The description fails to compensate for the absent schema descriptions.

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 essentially restates the tool name: 'Add a add_auxiliary_view to a drawing.' It gives a verb and resource but no meaningful definition of what an auxiliary view is or how it differs from sibling tools such as add_view, add_section_view, and add_detail_view. This is tautological rather than clarifying.

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 description provides no guidance on when to use this tool versus alternatives. Siblings like add_view, add_section_view, and add_detail_view are plausible alternatives, but the description does not mention selection criteria, prerequisites, or exclusions.

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 is created, required drawing/context state, units, or whether the operation is undoable. A single restated noun phrase gives the agent zero behavioral context for a mutation 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?

It is a single short sentence, but the brevity is under-specification rather than conciseness — there is no front-loaded useful information because the sentence contains no information beyond the 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?

For a two-parameter mutation tool with a nested schema, no annotations, and no output schema, the description is completely inadequate. Nothing an agent needs to call 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 description coverage is 0%, and the description adds no meaning for either required parameter. The nested 'points' array of x/y objects (minItems 1) and the numeric 'baseline' value are entirely undocumented, leaving the agent to guess their semantics.

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?

'Add baseline dimensions' merely restates the tool name. It does not explain what a baseline dimension is or how it differs from the many sibling dimension tools (add_linear_dimension, add_continued_dimension, add_ordinate_dimension, etc.), so an agent cannot distinguish it without opening the schema.

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 and no mention of alternatives, despite a crowded sibling set of dimension tools that overlap heavily. The only inference available is that this adds some kind of dimension.

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, whether the annotation is associative, how it interacts with selected entities, or what permissions or context are required. For a mutation tool with zero annotation coverage, this is a critical 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 sentence is short but fails because it is under-specified rather than concise; it omits information an agent needs. The wording 'Add symbol annotation add_center_line' also awkwardly duplicates 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?

This is a complex, 8-parameter tool with nested objects, no annotations, and no output schema, yet the description provides no compensating detail. It is completely inadequate for an agent 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 0% across 8 parameters, including nested objects like position and options, and the description does not mention a single parameter. There is no explanation of what datum, symbol, roughness, tolerance, or circle_id control, leaving the agent entirely dependent on raw property names.

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 essentially a restatement of the tool name, adding only the generic category 'symbol annotation.' It does not specify what a center line is, what the resulting entity looks like, or how it differs from siblings like add_center_mark or the dimension tools. An agent cannot confidently choose this over the many other annotation tools.

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, what prerequisites exist, or which sibling to prefer for related tasks such as center marks or dimensions. The single word 'Add' implies a creation action but provides no 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?

No annotations are provided, so the description bears the full behavioral burden, yet it discloses nothing: not whether the mark is associative to entities, whether it needs a datum or circle reference, whether it is undoable, or what it returns. For an 8-parameter mutation tool this is a complete 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 clause and technically concise, but this is under-specification rather than economy: it is too short to be useful and wastes the space on a restatement of the 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?

Given 8 undocumented parameters, nested objects, zero annotation coverage, and no output schema, the definition is entirely inadequate; an agent could not invoke this tool correctly from the 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% across 8 parameters, and the description supplies no meaning for datum, symbol, options, entities, position, circle_id, roughness, or tolerance. An agent has no way to know what values are expected, especially for the nested position object and the free-form options map.

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 'Add symbol annotation add_center_mark' merely restates the tool name with the word 'symbol annotation' appended; it does not explain what a center mark is or how it differs from siblings such as add_center_line, add_surface_finish_symbol, or add_weld_symbol. It is essentially a tautology.

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 the many other annotation tools (add_center_line, add_gdt_frame, etc.), nor any prerequisites or context of use. Usage is left entirely to inference 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. It implies a mutation ('Add'), but omits whether the assembly must already exist, whether the operation is reversible, what permissions are needed, and what the result looks like. It adds almost no behavioral context beyond the verb.

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 front-loaded and free of filler, clearly stating the action and target. Its terseness is efficient, though it is too sparse to be fully helpful.

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 mutation tool with 4 parameters, 0% schema description coverage, no annotations, and no output schema, one sentence is not enough. An agent lacks parameter meanings, usage conditions, and behavioral expectations needed 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 0% with 4 parameters. The description does not explain assembly_id, file_path_or_id, position, or rotation, nor does it clarify the required 3-item position array, the optional rotation array, or the difference between a file path and an ID. It fails to compensate for the complete lack of schema descriptions.

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 clear verb ('Add') and a specific resource ('component reference to an assembly'). It distinguishes the operation from creating an assembly, but does not explicitly differentiate from siblings like create_assembly, insert_block, or remove_component.

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 is provided. It does not say when an agent should prefer add_component over create_assembly, insert_block, or other assembly/component operations, nor does it mention prerequisites like an existing assembly.

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 says essentially nothing. The term 'coincident' implies that geometry is being made to share a point, but there is no disclosure of preconditions, failure modes, or effects on the model.

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, front-loaded sentence with no wasted wording. However, for a tool with four required parameters, this brevity reflects under-specification rather than genuine 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?

With four required parameters, 0% schema coverage, no annotations, and no output schema, the description is completely inadequate for an agent to invoke this tool correctly. Nothing compensates for the missing parameter and behavioral information.

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 mentions no parameters at all. The four required parameters (entity_a, point_a, entity_b, point_b) are entirely undocumented in both the schema and the description, leaving their expected formats (IDs? point names?) ambiguous.

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 'Add a coincident constraint' is a near-verbatim restatement of the tool name add_constraint_coincident, with no additional detail. It conveys a verb+domain concept but offers nothing to distinguish it from the many sibling constraint tools beyond the word 'coincident' already present in the name.

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 constraint versus alternatives such as add_constraint_concentric, add_constraint_tangent, or the many other add_constraint_* siblings. No prerequisites, no context for selection 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, and it discloses nothing: not what a concentric constraint does to the referenced circles, whether the entities must already exist, whether existing geometry moves, or whether the operation is reversible. For a mutation tool with zero annotation coverage this is a complete 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 the brevity is under-specification rather than economy: a single sentence with no actionable content. It is front-loaded only in the sense that there is nothing else.

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 two-parameter mutation tool with no annotations, no output schema, and no parameter descriptions leaves the agent with nothing beyond the name. Everything needed to invoke it correctly is absent.

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. 'circle_a' and 'circle_b' are undocumented as to whether they are entity handles, names, IDs, or numeric radia, and the description supplies no compensating detail. An agent cannot reliably format these values.

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 near-verbatim restatement of the tool name: 'add_constraint_concentric' -> 'Add a concentric constraint.' It confirms a verb and a resource, but adds no scope, no subject (which two objects get constrained) and no differentiation from the sibling 'mate_concentric', which reads as the same operation.

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. The agent is not told how this differs from mate_concentric, nor whether it applies inside sketches, assemblies, or already-created geometry. Nothing in the text helps choose between it and the other add_constraint_* 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether the entities must already exist, whether the constraint is persistent, what happens on conflict with existing constraints, 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?

The single sentence is short, but it is under-specified rather than concise, and it contains a grammatical error ('a equal'). Brevity here reflects missing information, not 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 mutation tool with no annotations, no output schema, and two entirely undocumented required parameters sitting among a dozen sibling constraint operations, the description is far too thin to let an agent 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?

Both required parameters (entity_a, entity_b) have 0% schema description coverage and the description adds no meaning — it never explains that these are the two entities being constrained equal, nor what form an entity reference takes.

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 essentially a restatement of the tool name ('add_constraint_equal' → 'Add a equal constraint'), with no scope or distinguishing detail beyond the obvious. It does imply two entities are related by equality, but it never says what kind of entity is valid or how this differs from the many sibling add_constraint_* tools.

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 constraint versus add_constraint_coincident, add_constraint_parallel, add_constraint_concentric, or the other constraint siblings, and no mention of prerequisites. An agent gets no basis for selecting this tool over alternatives.

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 says nothing about what a fixed constraint does to the entity (locking it in place), whether it's reversible, what permissions or preconditions are needed, or how it interacts with other constraints. 'Add a fixed constraint' restates the name with zero added context.

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?

Extremely short — only four words. It's front-loaded but so under-specified that brevity reflects omission rather than 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?

A geometry constraint tool with no annotations, no output schema, 0% parameter coverage, and no explanation of the fixed-constraint semantics is far too thin. The description leaves the agent unable to distinguish this from a dozen sibling constraint tools or to know what the constraint actually does.

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, but it doesn't mention entity_id at all. An agent cannot infer from the description that it must supply an entity identifier, nor what value format is 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?

States a verb (Add) and resource (fixed constraint), which is broader than a tautology but adds no differentiation. Among ~15 sibling add_constraint_* tools (coincident, parallel, tangent, etc.), 'fixed' is not explained — the agent can't tell what a fixed constraint does versus the others from the description 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?

No when-to-use guidance, no alternatives named, no prerequisites. The description doesn't mention that the entity must exist or that this anchors geometry in place.

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, yet it says nothing about behavior: whether the constraint is applied immediately, what happens on conflicting constraints, whether it requires a horizontal line, or what the response is. 'Add' implies mutation but no mutation details (permissions, reversibility) are given.

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 one-line description is front-loaded and not padded, but its brevity is under-specification rather than genuine conciseness. There is nothing structurally wrong, only too little content.

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 required parameter, the description omits essentially all the context an agent needs to invoke it correctly. It is markedly under-documented.

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 line_id has 0% schema description coverage, and the description does not mention it at all or explain what it identifies. The description fails to compensate for the documentation 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?

States a specific verb ('Add') and a specific resource ('horizontal constraint'), so the operation is unambiguous. However, it offers no differentiation from the large family of sibling constraint tools (add_constraint_coincident, add_constraint_parallel, etc.), leaving the agent to infer selection.

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 constraint versus the many alternatives, nor any prerequisites (e.g., whether an entity must already be selected or that only line_id is supplied). Usage must be entirely inferred.

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 provided, the description carries the full behavioral burden, yet it discloses nothing: no mutation semantics, no required permissions, no note on whether the constraint is reversible or how it interacts with existing constraints on the point/line.

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, but the brevity stems from under-specification rather than tight editing — there is nothing to front-load because nothing is said.

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, no parameter documentation, and a one-line description for a constraint-creation tool with two required parameters. An agent lacks everything needed to call it correctly — which entity moves, what fails, what is returned.

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 two required parameters. The description adds no meaning: it does not clarify that line_id identifies the line whose midpoint is used or how point_id relates to it, leaving the core semantics of the constraint ambiguous.

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 restates the tool name almost verbatim ("Add a midpoint constraint") without explaining the operation's semantics — e.g. that a point is constrained to the midpoint of a line. It doesn't distinguish itself from the many sibling add_constraint_* tools beyond the word 'midpoint'.

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 constraint versus alternatives such as add_constraint_coincident or add_constraint_symmetric, and no preconditions (e.g. point and line must already exist and be unconstrained) 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 disclosure burden. It does not state that this creates a persistent geometric relation, whether it modifies existing geometry, what selection state is required, or what errors occur when the inputs cannot be made parallel.

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 one-sentence form is brief but under-specified rather than economical. It spends no words on the information needed to invoke the tool and offers only a fragment of the name restated.

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 constraint-creation tool with two undocumented required parameters, no annotations, and no output schema, the description is far too thin. It omits the input contract, behavioral effects, and sibling differentiation that an agent needs 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 description coverage is 0% for the two required parameters, line_a and line_b. The description never mentions them, so an agent cannot learn what the two strings represent (entity IDs, names, handles) or what makes them 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 description 'Add a parallel constraint' merely restates the tool name verbatim. It does not clarify what entity types are constrained, how it differs from siblings like add_constraint_perpendicular or mate_parallel, or what the resulting constraint means. The agent learns nothing beyond the name.

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 alternatives named. The agent cannot tell whether this applies to sketch lines, 3D edges, or assembly components, nor when to choose it over the many other constraint and mate 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, yet it discloses nothing about behavior: not whether it modifies the model, requires selected entities, resolves geometry, or is reversible. For a mutation tool with zero annotation coverage this is a critical 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 short sentence with no padding, but that brevity is under-specification rather than conciseness — nothing is front-loaded because nothing of substance is present.

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 mutation tool with no annotations, no output schema, no parameter documentation, and a large family of near-identical sibling constraint tools, the description is far too thin to support 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% and there are two required parameters (line_a, line_b). The description never mentions them, so the agent must guess what identifiers these expect (handles, names, entity IDs) and how the perpendicular relationship is applied between 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 states a specific verb ('Add') and a specific constraint type ('perpendicular'), which does distinguish it from siblings like add_constraint_parallel or add_constraint_tangent. However, it does not explain what the constraint does or what geometry it relates, so it only marginally exceeds restating the tool name.

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 the many other constraint tools, no prerequisites, and no indication of the state the model must be in. The agent is given nothing to route on.

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, yet it says nothing about what happens to the referenced entities, whether it requires an axis of symmetry, whether it is reversible, or how failures are reported. It merely echoes the name.

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 and front-loaded, so there is no wasted prose. But its brevity reflects under-specification rather than efficient communication — it is minimal to a fault for a 3-parameter mutation 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 no annotations, no output schema, and zero parameter documentation, the description leaves the agent without the minimum information needed to call this tool correctly. The context signals show all three parameters are required, which the description never acknowledges.

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 all three parameters (entity_a, entity_b, axis) are undocumented in both schema and description. The description gives no hint that a symmetric constraint relates two entities about an axis, leaving the semantics of every parameter 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?

States a specific verb (Add) and resource (symmetric constraint), so the operation is identifiable. However, it adds nothing beyond the tool name itself and does not distinguish it from the many sibling constraint tools in any meaningful way.

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 constraint versus alternatives (e.g. concentric, parallel, equal) and no mention of prerequisites or the modelling context in which a symmetric constraint applies. Only implied usage 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 constraint triggers a solver update, whether it can fail on incompatible geometry, whether existing constraints conflict, or what is returned on success.

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 wasted words, but the brevity is under-specification rather than efficiency; there is no structure because there is essentially no content.

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, mandatory-argument mutation tool with no annotations, no output schema, and zero schema documentation, the description is far too thin for an agent 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 description coverage is 0% and the description says nothing about entity_a/entity_b. The agent cannot tell whether these are entity IDs, names, handles, or what geometric types each may reference.

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 verb+resource ('Add a tangent constraint'), which is more than a bare tautology, but it adds nothing the tool name doesn't already convey and does not distinguish it from the many sibling constraints (coincident, parallel, perpendicular, concentric). An agent can identify the operation but gains no discriminating information.

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 use this constraint versus other constraints, no prerequisites, and no mention of which entity combinations are valid. The usage context is implied only by 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?

With no annotations and no output schema, the description carries the full disclosure burden, yet it only implies a mutating 'add' operation. It says nothing about whether the constraint is idempotent, what happens if line_id does not reference a valid line entity, whether the constraint can later be removed, or how failure is reported.

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?

One short, front-loaded sentence with no wasted words, but its brevity stems from under-specification rather than efficiency. It is not padded, yet it conveys almost nothing beyond the title.

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 required parameter, the definition is far too thin. It omits validation rules, error semantics, and any indication of how the new constraint relates to existing geometry, leaving the agent to guess at 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% and the single required parameter line_id is undocumented in the schema. The description does not mention line_id at all, so it neither explains that it must be the ID of an existing line entity nor compensates for the coverage gap. Only the self-evident parameter name carries meaning.

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 ("Add a vertical constraint"), so its purpose is legible. But it essentially restates the tool name verbatim and does no work to distinguish it from the many sibling constraint tools (add_constraint_horizontal, add_constraint_concentric, add_constraint_coincident), all of which share the same 'add_constraint_*' pattern.

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 versus add_constraint_horizontal or the other constraint siblings, no prerequisites (e.g. that the referenced geometry must already exist), and no conditions or exclusions. The agent is left to infer everything 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?

No annotations are provided, so the description must carry the full behavioral burden. It says nothing about side effects, permissions, whether it modifies the drawing, what happens on invalid points, or what is returned. It is merely a restatement of the tool name.

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 short sentence and is front-loaded, but it is under-specified rather than appropriately concise. It omits essential information that an agent would need to invoke the tool correctly.

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 the complexity of the CAD dimensioning domain, the presence of many sibling dimension tools, no annotations, no output schema, and zero schema description coverage, the description is not complete enough for correct tool selection or 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%, and the description adds no meaning for the single required parameter 'points'. It does not explain units, coordinate order, coordinate space, why a minimum of two points is required, or how those points define a continued 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 states a specific verb and resource ('Add continued dimensions'), so the general operation is clear. However, it does not explain what a 'continued dimension' is or how it differs from sibling dimension tools such as add_baseline_dimension, add_linear_dimension, or add_aligned_dimension. The resource term is therefore ambiguous in context.

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 about when to use this tool, when not to use it, or which sibling dimension tool is the alternative. With many dimension-related siblings, the absence of routing guidance is a severe 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 must fully disclose mutation behavior. It says 'Add' but omits what entities are created, whether an active drawing is required, default layer handling, undo implications, and 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?

The description is a single front-loaded sentence with no filler. It is appropriately brief, though its terseness borders on under-specification for a mutation 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?

For a 4-parameter mutation tool with no annotations and no output schema, the description is far too sparse. It does not cover required drawing_id, optional extent or layer semantics, or any behavioral context needed 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 coverage is 0% for four parameters, so the description should compensate. It mentions extent and spacing but omits drawing_id (required) and layer, and does not explain the extent object structure or spacing units.

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 specific verb 'Add' with the resource 'coordinate grid', making the tool's basic action clear. It does not differentiate this tool from other add_* or map-drafting siblings, so it stops short of a 5.

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, no prerequisites, and no exclusions. The phrase 'using the provided extent and spacing' implies inputs but not usage 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: whether the drawing must already exist, whether the view is created immediately or batched, what happens if parent_view_id is omitted, or what is returned. For a mutation tool with 9 parameters this is a complete void.

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 waste, but its brevity comes from under-specification rather than economy. The duplicated article in 'a add_detail_view' also suggests careless generation.

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 9-parameter, mutation-style drawing operation with no annotations, no output schema, and nested coordinate objects, the description supplies none of the information an agent needs to invoke it correctly. It is effectively absent.

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?

With 9 parameters, nested objects (position, cut_line), and 0% schema description coverage, the description mentions zero parameters. An agent cannot know what scale, center, cut_line, direction, view_type, or parent_view_id mean or in what units they are expressed.

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 tautology: 'Add a add_detail_view to a drawing' simply restates the tool name and adds only the banal fact that it targets a drawing. It gives no indication of what a detail view is, how it differs from add_view, add_section_view, or add_auxiliary_view, and contains a grammatical redundancy that signals it was auto-generated.

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 its many siblings (add_view, add_section_view, add_auxiliary_view, create_viewport, update_drawing_views). No prerequisites, no exclusions, no workflow 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 provided, the description carries the full burden of behavioral disclosure, and it discloses nothing: no statement about whether this mutates the drawing, creates an annotation entity, requires a valid circle_id, or is undoable. An 'add' verb implies creation, but nothing about side effects or failure modes is given.

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 short sentence is trim and front-loaded, but its brevity reflects under-specification rather than efficiency — there is no waste because there is almost no content.

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 a nested-object parameter, zero schema description coverage, no annotations, and no output schema, a four-word description is insufficient. An agent cannot reliably construct a valid call 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% and the description documents neither parameter. The agent must infer that circle_id references a circle entity and that leader_point is the nested {x,y} location for the dimension leader, with no help from either the schema or 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?

States a specific verb and resource ('add a diameter dimension'), so the basic action is identifiable. However, it does nothing to distinguish itself from the many sibling dimension tools, most notably the near-identical 'add_dimension_diameter', leaving the agent unable to tell which one to pick.

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. The description does not say when a diameter dimension is preferable to add_radius_dimension, add_aligned_dimension, or the redundant add_dimension_diameter sibling, nor does it state prerequisites such as an existing circle.

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 dimension is associative/parametric, whether entities must already exist, what happens on failure, or what is returned.

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 sentence that adds no information beyond 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?

For a 3-parameter creation tool with no annotations, no output schema, and no parameter documentation, the description is completely inadequate to enable a correct 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?

Three required parameters (line_a, line_b, value) with 0% schema description coverage, and the description explains none of them. An agent cannot tell whether line_a/line_b are entity handles, IDs, or names, nor what units 'value' uses.

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 only restates the tool name, saying it adds a 'dimension_angular constraint' without clarifying what such a dimension measures or what it applies to. Sibling add_angular_dimension exists with an almost identical name and no distinction is drawn between them, leaving the agent unable to disambiguate.

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 add_angular_dimension or the many other add_*_dimension siblings. No prerequisites, no context, no exclusions.

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, and it discloses nothing: not whether an entity must pre-exist, whether the target must be a circle, whether the constraint persists, or what happens on failure. Bare minimum not met.

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 waste, but there is hardly any content to be concise about – the brevity reflects 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?

With no annotations, no output schema, 0% parameter description coverage, and crowded sibling space (multiple add_*dimension and constraint tools), the description leaves an agent unable to determine correct targets, units, or workflow.

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, but it says nothing about what circle_id or value mean (units? edge reference? identifier format?). Schema provides only property names and types.

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 'Add a dimension_diameter constraint' restates the tool name with virtually no added specificity. Among dozens of sibling add_* tools, it does not distinguish what target this dimension applies to (the schema's circle_id hints it, but the description does not).

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 indication of when to use this versus add_radius_dimension, add_diameter_dimension, add_aligned_dimension, or other dimension siblings. No prerequisites, no context for choosing this tool.

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, and it discloses nothing. It does not say whether the constraint is persistent, what happens on failure, whether referenced points must exist, or what is returned.

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 it is under-specified rather than concise — there is no wasted text because there is essentially no content. Brevity here reflects a lack of information, not efficient communication.

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 mutation tool with 0% schema coverage, no annotations, and no output schema, the description is completely inadequate. It offers nothing an agent needs in order 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 coverage is 0% across 4 parameters, and the description adds no meaning for point_a, point_b, value, or label. An agent cannot tell from either source what these parameters should reference or how value is interpreted.

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 only restates the tool name ('Add' + 'dimension_linear constraint') without explaining what a linear dimension constraint does or what geometry it applies to. It is especially unhelpful given siblings like add_linear_dimension, add_aligned_dimension, and the other add_dimension_* tools, none of which are distinguished from this one.

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 the many sibling dimension tools, no prerequisites, and no mention of required selections or sketch context. Nothing tells an agent how to choose between it and add_linear_dimension.

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 behavioral burden, and it discloses nothing: not whether the dimension is associative, whether it requires an existing circle, whether it mutates the drawing, or what errors occur on failure.

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 wasted words, but its brevity comes from under-specification rather than discipline. Short is not the same as concise when nothing informative is conveyed.

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 mutation tool with no annotations, no output schema, and 0% parameter documentation, the description is completely inadequate. Nothing an agent needs 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 0% for both parameters. 'circle_id' and 'value' are undocumented in both schema and description; the agent cannot tell whether circle_id references an entity ID or a named circle, nor whether 'value' is an override or an offset distance.

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 restates the tool name almost verbatim ('Add a dimension_radial constraint'), which is a tautology rather than an explanation of what gets created or where. It gives no hint that this places a radial dimension annotation on a circle entity, and it does nothing to distinguish itself from the sibling 'add_radius_dimension' or 'add_dimension_diameter'.

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 provided at all. With three near-synonymous siblings (add_radius_dimension, add_dimension_diameter, add_aligned_dimension) in the tool list, the absence of routing guidance is actively harmful to tool selection.

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 and discloses nothing. It does not say the tool mutates an existing view, whether the step is appended or replaces existing steps, whether the call is undoable/transactional, or what happens on invalid component or view ids.

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 action is front-loaded. It is concise, but the brevity stems from under-specification rather than efficiency, which caps the score at merely adequate.

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?

This is a mutating CAD operation with five required geometric parameters, no annotations, no output schema, and no parameter documentation. The description supplies none of the prerequisite, side-effect, or return-value context an agent needs 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 description coverage is 0% across five required parameters (assembly_id, view_id, component_ids, direction, distance). The description mentions none of them, so an agent gets no meaning for the 3-vector direction convention, the units/scale of distance, or whether view_id must belong to assembly_id.

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 concrete verb and resource: it adds an explode step, and it scopes that step to an exploded view. An agent can tell roughly what the tool does, but nothing distinguishes it from siblings like create_exploded_view or animate_explode, which occupy the same exploded-view domain.

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 mention of prerequisites (e.g., that an exploded view must already exist), and no routing to alternatives such as create_exploded_view for creating the view or animate_explode for playback. The agent must infer placement in the workflow entirely on its own.

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: no statement of whether the frame is attached to entities, whether it requires a datum, what happens with the 'datum'/'symbol' fields, or any side effects. For an 8-parameter drawing-annotation mutation this 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 the brevity comes from under-specification rather than efficiency. A single sentence that merely echoes the tool name does not earn its 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?

For an 8-parameter annotation tool with no annotations, no output schema, and 0% schema coverage, the description is completely inadequate. Nothing an agent needs to call 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 description coverage is 0% across 8 parameters, including nested objects (position, options) and semantically loaded fields like datum, symbol, roughness, and tolerance. The description adds no meaning for any of them, leaving the agent to guess field formats and valid values.

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 essentially a tautology, restating the tool name with the words 'Add symbol annotation' appended. It never explains what a GDT (geometric dimensioning and tolerancing) frame is, nor distinguishes it from the many adjacent annotation siblings such as add_surface_finish_symbol, add_weld_symbol, or add_center_mark.

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 annotation tool to prefer. The agent is given nothing to route on.

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, and it discloses almost nothing: it does not say whether the leader is attached to existing geometry, whether the operation is reversible, or what the call returns. Only the bare implication of a write operation is conveyed.

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 it is not concise in the useful sense — it is under-specified rather than economical. There is no front-loaded scoping or actionable information beyond 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, no output schema, no parameter descriptions, and a large set of similar sibling tools, the definition is inadequate for correct invocation. An agent cannot determine valid inputs or how this leader differs from the multileader alternative.

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 four parameters, and the description explains none of them. Critical semantics such as requiring at least two points, the meaning of the opaque 'annotation' string, or allowed 'style' values are left entirely 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 states a verb and resource ("Add a leader annotation"), so the basic action is identifiable, but it is essentially a restatement of the tool name and adds no distinguishing detail. Siblings such as add_multileader, add_text, and add_mtext make it important to say what kind of leader this creates, which is not done.

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 add_leader versus add_multileader or the text/dimension tools. No prerequisites (e.g., an existing annotation handle, an active drawing) are mentioned, leaving the agent to infer context 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?

No annotations are provided, so the description carries the full burden. It implies a mutating annotation insert but says nothing about required preconditions (drawing_id must exist), whether the legend is undoable/removable, how layer/title affect placement, or what happens with duplicate or invalid items.

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 first and zero filler. It is appropriately short, though the brevity is partly the cause of the missing detail elsewhere.

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 mutation tool with 5 parameters (3 required, nested position object), no annotations, no output schema, and 0% schema description coverage. One sentence cannot cover the preconditions and parameter meaning an agent needs to call this 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 explain 5 parameters and it explains essentially none. 'domain layers or categories' loosely maps to the items array, but drawing_id, position (x/y), layer, and title are entirely unelaborated.

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+resource ('Add a ... map legend annotation') plus its content scope ('listing domain layers or categories'). It distinguishes itself reasonably from add_north_arrow/add_scale_bar by describing what the annotation contains, though it never names a sibling.

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 prerequisites, no alternatives. The word 'simple' hints at a scope boundary but never says when a different legend approach or tool is warranted, nor whether a drawing/layout must already exist.

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 only restates the action ('Add') without disclosing required inputs, side effects, coordinate system expectations, or whether it modifies an existing drawing/document.

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 short sentence with no wasted words and is front-loaded. However, it is under-specified rather than informative, so its brevity reflects missing content more 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 four undocumented parameters, nested point objects, no annotations, and no output schema, this description is inadequate. It gives the agent almost nothing beyond the tool name 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 0% for four parameters (p1, p2, style, offset), including nested objects with x/y coordinates. The description provides no parameter meaning at all, leaving the agent unable to interpret p1, p2, offset, or style from either the schema or 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 states a clear verb and resource ('Add a linear dimension annotation'), so the basic purpose is understandable. However, it fails to differentiate from near-identical siblings such as 'add_dimension_linear' and 'add_aligned_dimension', leaving the agent unable to choose between them without opening schemas.

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 the many related dimension tools (aligned, angular, radius, diameter, ordinate, baseline, continued). Usage is only implied by the tool name, with no explicit conditions or exclusions.

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 only says 'add', giving no information about whether the new entity is selected/returned, what happens on failure if position/width are invalid, or the coordinate/unit conventions expected for placement.

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 front-loaded and free of filler, but it is under-specified rather than concise for a tool with five parameters and a nested position object. It earns its place but leaves the definition sparse.

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 mutation tool with no annotations, no output schema, 0% parameter coverage, and a nested object parameter needs substantially more description than one sentence. Nothing tells the agent how to call it correctly or what it returns.

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 (content, position, width, height, style). The description only hints that content is text; it says nothing about position being an {x,y} object, that width/height must be positive, or what style accepts.

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 (add + multi-line text annotation), and the word 'multi-line' implicitly distinguishes it from the sibling add_text (single-line). However, it never names or contrasts the sibling explicitly, so the agent must infer the distinction.

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 prerequisites, and no mention of alternatives despite siblings add_text, add_leader, and add_multileader occupying adjacent use cases. The agent is left to guess which annotation tool to pick.

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. 'Add' implies a mutation/creation, but nothing is said about required context (active document/layer), what the new entity is attached to, or side effects; for a 0%-annotated mutation 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?

A single clean sentence with no padding and no wasted clauses, so it is not verbose. But it is essentially a restatement of the tool name and adds almost nothing, so it is terse to the point of 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?

Given four parameters at 0% schema coverage, no annotations, and no output schema, the description is far too thin. An agent has no basis for supplying style, content, annotation, or the points structure 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% and the description adds no parameter meaning whatsoever. The four params -- style, points, content, annotation -- are undocumented, and the meaning of points (minItems 2, arrow vs. landing locations) and the content/annotation overlap are left entirely ambiguous.

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 (Add) and resource (multileader annotation), which is a distinct CAD entity type. However, it does not differentiate this from the very similar sibling add_leader or from related annotation tools like add_text/add_mtext, leaving the agent to infer the distinction.

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 and no mention of when to prefer add_multileader over add_leader, add_text, or the various add_*_dimension tools. The description contains zero 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 must carry the full behavioral burden. 'Add' implies a write/mutation operation, but the description does not disclose whether the drawing is modified in place, what permissions are needed, or what happens to existing annotations.

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 redundant wording. However, it is too sparse to be considered appropriately sized for a tool with four undocumented parameters; brevity here reflects under-specification rather than efficient 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?

With no annotations, no output schema, and 0% schema description coverage, the description should do more to explain required inputs and behavior. It states the basic purpose but leaves the agent without enough information to call the tool correctly, especially regarding drawing_id, position, size, and layer.

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 4 parameters with 0% schema description coverage, including required drawing_id and a nested position object. The description mentions none of these parameters, so it does not compensate for the missing schema documentation. An agent must infer all parameter meanings from names alone.

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: 'Add a north arrow symbol annotation for a map drawing.' This is clear enough to distinguish it from unrelated siblings like create_box or add_dimension_linear, but it does not explicitly differentiate it from similar annotation tools such as add_scale_bar or add_legend.

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 'for a map drawing' implies a context, but there is no explicit guidance on when to use this tool versus alternatives or what prerequisites exist. No when-to-use, when-not-to-use, or sibling routing information 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 burden of behavioral disclosure. It says nothing about side effects, required coordinate frame, mutation impact, undo behavior, or what happens if the dimension references invalid points.

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 under-specified rather than concise. For a mutation tool with three required parameters and nested objects, this level of brevity omits information the agent needs to call it correctly.

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 zero parameter description coverage in the schema, the description is completely inadequate for this tool. It leaves the agent without guidance on required inputs, coordinate semantics, or behavioral effects.

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 adds no meaning for any of the three required parameters (point, datum_point, axis). It does not explain the coordinate expectations, the role of the datum point, or the axis enum beyond what the schema already shows.

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 clear verb and resource: 'Add an ordinate dimension.' An agent can tell this creates an ordinate dimension, but the description does not differentiate it from the many sibling dimension tools such as add_aligned_dimension or add_baseline_dimension.

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 about when to use an ordinate dimension versus other dimension types, nor any prerequisites or contextual conditions. The agent is left to infer usage 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 provided, so the description carries the full disclosure burden, and it discloses nothing. It does not say whether this mutates the drawing, whether the arc must already exist and be committed, whether the operation is undoable, or how leader_point affects placement.

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 is not concise so much as under-specified; it is front-loaded only because there is nothing else to front-load.

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 a nested-object parameter, no annotations, no output schema, and zero parameter documentation, the definition is completely inadequate. An agent cannot reliably construct a correct call from this 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?

Two required parameters with 0% schema description coverage, including a nested leader_point object with x/y. The description mentions neither arc_id nor leader_point, so the agent gets no explanation of what the arc reference is or how the leader point is interpreted. Full compensation was required and none was 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 is a verbatim prose restatement of the tool name 'add_radius_dimension' — there is no information beyond what the identifier already encodes. It also fails to distinguish this tool from near-identical siblings such as add_dimension_radial and add_diameter_dimension that appear in the same toolset.

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 prerequisites, and no mention of the sibling dimension tools an agent would have to choose between. The only hint of usage is inferable from the name itself.

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-disclosure burden. It implies a mutation ('Add'), but does not describe side effects, whether the scale bar is created on a layout or model space, required drawing context, return behavior, or undo semantics.

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 clean. However, it is arguably too terse for a six-parameter nested-object tool with no schema descriptions, leaving necessary context absent.

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 six parameters, 0% schema description coverage, no annotations, and no output schema, the description is not complete enough for reliable invocation. It never explains coordinates, units, required drawing state, or the role of optional parameters such as segments, label, and layer.

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 six parameters, and the description adds no meaning for any of them. It does not explain drawing_id, position coordinates, segment_length units, segments count, label, or layer, leaving the agent to infer all parameter semantics from names and types alone.

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 ('Add') and resource ('scale bar annotation') and scopes it to a 'map drawing.' This distinguishes it from other annotation tools like add_north_arrow or add_legend in practice, but it does not explicitly name or differentiate from those 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?

The description gives no explicit when-to-use guidance, prerequisites, or alternative tools. The phrase 'to a map drawing' provides minimal context, but an agent receives no instruction on when this scale bar tool should be chosen over related drawing/annotation 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 disclosure burden, and it discloses nothing. It does not state whether this mutates the drawing, requires a specific drawing state, how the cut_line/direction/view_type interact, 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?

The single sentence is brief, but its brevity comes from under-specification rather than economy — it is a duplicated-word tautology with no informational content.

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 9-parameter mutation tool with no annotations, no output schema, nested objects, and 0% schema coverage, the definition is completely inadequate. An agent cannot reliably invoke 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 0% across 9 parameters, including ambiguous ones like direction, view_type, solid_id, parent_view_id, and the nested cut_line array of positions. The description supplies zero clarification, leaving the agent with no way to populate these correctly.

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 circular restatement of the tool name ('Add a add_section_view to a drawing'), which conveys no meaning an agent couldn't already infer. It fails to explain what a section view is or how it differs from the many sibling view-creation tools (add_view, add_detail_view, add_auxiliary_view, create_viewport).

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 add_view, add_detail_view, or add_auxiliary_view, nor any mention of prerequisites such as requiring an existing drawing or cut line. The agent is left entirely to inference.

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 discloses nothing about whether this mutates the drawing, what permissions are needed, what the symbol attaches to, or how 'datum', 'roughness', and 'tolerance' affect the result. Total absence of behavioral context.

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 wasted words, but it is under-specified rather than concise: it conveys no information beyond the name it echoes, so the brevity reflects missing content.

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 8 undocumented parameters, a nested position object, no annotations, and no output schema, the description is grossly inadequate. It gives an agent nothing to construct a valid call for what appears to be a drawing annotation operation.

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 8 parameters at 0% schema description coverage, including a nested 'position' object and an open-ended 'options' object. The description adds zero meaning for any of them, so an agent cannot infer the role of entities, symbol, datum, roughness, or tolerance.

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 'Add symbol annotation add_surface_finish_symbol' is essentially a restatement of the tool name with no explanation of what a surface finish symbol annotation is or what it accomplishes. Beyond the verb 'add', an agent learns nothing distinguishing this from siblings like add_weld_symbol or add_gdt_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 guidance, no prerequisites, and no mention of alternatives. The many sibling annotation tools (add_leader, add_center_mark, add_gdt_frame) are not referenced, leaving the agent no basis for routing.

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. 'Add' implies a mutation, and 'single-line' hints at the content constraint, but nothing is said about coordinate space, what layer the annotation lands on, undo/transaction behavior, 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?

A single short, front-loaded sentence with no filler, which is structurally sound. But the brevity here reflects under-specification rather than economical precision, so it does not earn more than a middling score.

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 five-parameter mutation tool with no annotations, no output schema, and a nested object parameter, the description omits nearly everything an agent needs: units, coordinate frame, style format, and return information. It is far too thin for the tool's 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 description coverage is 0% across five parameters (content, position, height, style, rotation), including a nested position object. The description adds only a weak constraint that content must be single-line; it does not explain units for height, the reference point for position, or what style expects.

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 ('Add ... text annotation'), and the qualifier 'single-line' implicitly distinguishes it from the sibling add_mtext. However, it never names or contrasts with that sibling, so differentiation still requires the agent to infer it from the description 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 guidance on when to use this versus add_mtext or add_leader, no exclusions, and no mention of prerequisites such as an active document or layer. The agent is left to guess the selection criteria 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing. It doesn't say whether the drawing must be active, whether the view is attached to a parent, what view_type/direction values are valid, 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?

It is a single short sentence, but it is also grammatically broken ('a add_view') and conveys almost no information. Brevity here reflects under-specification rather than efficient communication.

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 9-parameter tool with nested objects, 0% schema coverage, no annotations, and no output schema, this description is nowhere near adequate. An agent has no basis for supplying required or optional parameters 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 9 parameters, and the description explains none of them. Meanings of scale, center, cut_line, solid_id, direction, view_type, and parent_view_id are entirely 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 description 'Add a add_view to a drawing' essentially restates the tool name and adds only the target resource (a drawing). It never explains what a 'view' is here or how this differs from siblings like add_section_view, add_detail_view, or add_auxiliary_view, leaving the agent unable to distinguish it from those tools.

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 add_section_view or create_viewport. The only implied context is that a drawing must exist, which is not 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 delivers nothing. It does not state whether this mutates the drawing, what permissions are needed, what happens to the symbol after placement, or any side effects. For a mutation tool with zero annotation coverage, this is a serious omission.

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 short sentence with no waste, so it is concise. However, the conciseness is achieved through under-specification rather than efficiency, and the sentence awkwardly repeats the tool name as its own object ('Add symbol annotation add_weld_symbol').

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 8 parameters at 0% schema coverage, no annotations, no output schema, and nested objects, the description should carry substantial weight. It provides essentially nothing an agent needs to call the tool correctly, falling far short of 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 description coverage is 0% across 8 parameters, including nested objects (position with x/y) and an open-ended options object. The description adds no parameter information whatsoever, leaving all eight parameters undocumented. The description had a clear opportunity to explain symbols, datum, tolerance, roughness, and the position object but did 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?

The description states a verb and a resource ('Add symbol annotation'), which is enough to identify the operation. However, it provides no sibling differentiation, which matters because the sibling list contains many annotation-adding tools like add_surface_finish_symbol, add_gdt_frame, add_center_mark, and add_center_line. An agent cannot tell from this text what distinguishes a weld symbol from these other annotation types.

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, nor any prerequisites. Given the dense population of annotation tools in the sibling list, the absence of routing guidance is a meaningful gap, though the tool name itself provides some directional signal.

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. 'Return' and 'plan' weakly imply a non-mutating, informational output, but the description never states that it has no side effects, what the plan format is, or whether it requires an existing exploded view. It adds almost no behavioral context beyond the name.

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 obvious waste, which is structurally fine. But it is under-specified rather than complete, and the word 'simple' is filler that adds no actionable 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?

Given no annotations, no output schema, and 0% parameter description coverage, the description is the only source of guidance an agent has, and it supplies essentially none. It does not explain the return artifact, required context, or how the inputs shape the plan, making it inadequate for a 3-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?

Schema description coverage is 0% and the description mentions none of the three parameters (assembly_id, view_id, fps). With both the schema and description silent on parameter meaning and constraints such as which assembly/view must already exist, 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 states a verb ('Return') and a resource ('explode animation plan'), so the broad purpose is inferable. However, 'simple explode animation plan' is vague about what the plan contains, and it does not distinguish this tool from close siblings like create_exploded_view or add_explode_step. That puts it at vague-but-not-tautological.

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 an assembly_id must already exist), and no mention of alternatives like create_exploded_view. The agent is left to infer when this tool is appropriate 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?

No annotations are supplied, so the description carries the full behavioral burden. It hints at a write side effect ('persist layout/export metadata') but never says whether the operation overwrites existing layout settings, what happens if the template name is unknown, whether it is reversible, or who may invoke it. For a mutation tool with zero annotation coverage this is a real 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?

One sentence, front-loaded with the verb and resource, with the secondary persistence effect appended. No padding, though it is terse enough that it omits needed detail.

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% parameter coverage, the description is the only source of behavioral and parameter information, and it leaves both under-specified. An agent cannot reliably determine required inputs beyond the obvious two or the side-effect semantics.

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 four parameters. The description implicitly covers drawing_id ('existing drawing') and template_name ('stored ... template'), but says nothing about title and figure_no, which the 'layout/export metadata' phrase only vaguely gestures at. It does not compensate for the parameter documentation 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 gives a specific verb ('Apply') plus a specific resource ('a stored thesis/map template to an existing drawing'), and adds a second effect ('persist layout/export metadata'). That is enough to distinguish it from the drawing/map-layout siblings. It does not name or contrast any sibling tool, so it stops short of a 5.

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 use this versus alternatives such as create_map_layout or add_legend, and no prerequisites (e.g. that the named template must already exist and the drawing must already be open). The usage context is only implied by 'existing drawing'.

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 full behavioral burden. It discloses the angle-unit convention (radians) and that the angle includes the source entity, which is genuinely useful. However, it omits whether the source entities are preserved, duplicated, or moved; whether the operation is destructive; and whether any permissions or placed-entity constraints apply.

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 tightly packed sentences; the unit convention and source-inclusion rule are front-loaded and every clause earns its place. No filler.

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 five-parameter, nested-object, no-output-schema mutation tool with zero annotations and zero schema descriptions, the description is far too thin. It leaves the agent to guess parameter meaning, side effects, and return 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 0%, so the description must compensate for five undocumented parameters. It only clarifies 'angle' semantics (radians, includes source), leaving 'center', 'count', 'entity_ids', and 'unit' with no semantic help beyond their names. The unit enum and required-vs-optional distinction are unaddressed.

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 ('Create polar array copies around a center'), clearly distinguishing it from array_rectangular. The operation type is unambiguous, though the description could mention it operates on entity_ids to fully anchor the resource.

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 polar array vs. array_rectangular or mirror_2d, nor any mention of prerequisites or conditions that select this tool over siblings. The agent must infer usage 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?

No annotations are provided, so the description carries the full burden. It discloses that copies are created in 'current units' but says nothing about whether source entities are preserved, what the units default to, or that the unit parameter overrides 'current units'. Selection-set quantities (rows-1 x cols-1 copies) are 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?

A single efficient sentence that front-loads the verb and resource with zero filler.

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 mutation tool with no annotations, no output schema, and 0% schema coverage deserves more: which entities are copied vs. retained, how many copies result, and how unit interacts with dx/dy spacing 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% across 6 parameters. The description only glosses 'rows/cols/dx/dy' and 'current units', but does not explain that dx/dy are spacings, what the unit override does, or how entity_ids are consumed. It only partially compensates for a total 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?

States a specific verb (Create) and resource (rectangular array copies) plus the mechanism (row and column spacing). It is distinguishable from its closest sibling array_polar, though it doesn't explicitly name the alternative.

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. The agent must infer that this is the rectangular counterpart to array_polar 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 provided, the description must carry the full burden. It discloses the state change (attaching a layer to the session) and the return (layer id plus parsed metadata), but says nothing about failure behavior for a bad path, idempotency, or whether the layer is visible by default.

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 action and resource, followed immediately by the follow-up tool hint. No filler.

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-flavored tool with four undocumented parameters, no annotations, and no output schema, the description covers the action and return shape but leaves parameter meaning and error behavior unaddressed. It is minimally adequate rather than complete.

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 all four parameters (id, name, path, visible) are undocumented in the schema. The description only hints at 'path' via 'a GeoTIFF on disk'; id, name, and visible are left entirely unexplained, 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?

States a specific verb and resource: 'Attach a GeoTIFF on disk to the session as a raster basemap layer'. An agent can distinguish this from import_geotiff_metadata or get_raster_layer. It stops short of explicitly contrasting with the sibling import_geotiff_metadata, which also handles GeoTIFFs.

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?

'Use list_raster_layers / render_raster_layer_png afterwards' gives post-attach workflow guidance, which is useful. But there is no when-to-use-this vs. import_geotiff_metadata guidance, nor prerequisites such as whether the file must exist or the session must be in a particular 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?

No annotations are provided, so the description carries the full burden. It usefully discloses that the operation requires an already-open document and that it 'updates the binding' to the target, but says nothing about failure behavior when the name matches nothing, whether the prior binding is lost, or any permission requirements — notable gaps for a state-changing 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?

Three short sentences, no waste, with the core action and its key constraint ('does not open files') front-loaded before the pointer to the lookup 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?

For a one-parameter activation tool with no annotations and no output schema, the description covers the essential: what it does, the precondition, and how to obtain the argument. Only failure/edge-case behavior is absent, which is a minor gap.

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% for the single parameter, so the description must compensate. It does: the document argument accepts an 'exact name or full path' (and must be exact), which is meaningful disambiguation not present in the bare string 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?

Specific verb (activate) plus resource (an already-open AutoCAD document), with the scope qualifier 'already-open' and 'Does not open files'. This cleanly distinguishes it from any file-opening sibling and from autocad_attach/detach.

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?

States the precondition (document must already be open, this does not open files) and routes the agent to autocad_list_documents to find the target. It gives clear context but does not explicitly contrast with autocad_attach or autocad_detach, which are the nearest ambiguous 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 and discloses key behavior: it binds the server, activate defaults to true, later commands reject if the bound document is no longer active, and COM may not expose every same-version process. It does not describe error behavior on failed binding or what happens if already bound, but the core behavioral traits are covered.

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 front-loaded with the binding purpose and then adds only necessary detail about parameters, activation behavior, and COM limitations. Every sentence earns its place, and the structure flows logically from purpose to usage to caveats.

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 the tool's complexity, no annotations, and no output schema, the description is largely complete: it covers purpose, parameter sourcing, activation semantics, a critical dependency (bound document must remain active), and a COM limitation. It stops short of explaining return values or failure modes, which would be helpful for a tool that establishes a binding.

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, and it does: it explains that windowHandle is a decimal string from status/list calls, that document is a name or full path, and that activate defaults to true and activates the selected document. All three parameters gain meaning beyond the schema's type information.

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: bind the MCP server to an AutoCAD application window/process and document. It distinguishes this binding action from activation by explaining that activate defaults to true and that false only establishes the binding without activating it. An agent can tell this apart from sibling tools like autocad_activate_document.

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 explains where to get windowHandle and document values (from status/list calls) and clarifies that omitting them selects the current target. It also describes the activate flag's effect, giving clear context for when to use each behavior. However, it does not explicitly name alternative tools or state when not to use this tool.

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, and it does useful work by disclosing that the operation is non-destructive: it does not close AutoCAD, close a document, or discard drawing changes. What is missing is whether re-attachment is possible or whether the binding must be re-established afterward, but the safety profile is well conveyed.

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, scope stated first and non-behavior stated second. Every clause earns its place and nothing is redundant with the 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?

For a zero-parameter, no-output-schema teardown tool, the description covers scope and non-destructive behavior, which is close to what an agent needs. Only the post-condition (state of the session after detaching) is left unstated.

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 to document and the description appropriately adds no parameter chatter. Baseline 4 applies for a no-parameter tool.

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 precise verb and resource ('Clear this MCP server's AutoCAD binding') and pairs it with an explicit statement of what it does NOT do, which cleanly separates it from potently destructive siblings like delete_entity or close-document behavior. An agent can identify this as the counterpart to autocad_attach without opening any schema.

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?

Usage is implied by the attach/detach pairing in the sibling list, and the negation clause hints at when it is safe, but the description never explicitly says when to call this versus autocad_attach or whether it is required before shutdown. Adequate but with a clear gap in 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?

No annotations are provided, so the description carries the full disclosure burden. It adds a useful behavioral note about verification semantics and reading from the live document, but says nothing about error handling for unknown variable names, permission/auth needs, or the shape of the returned values.

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 zero waste; the core action and scope are front-loaded before the verification 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 single-parameter read tool with no output schema or annotations, the description covers what it reads, how many, examples, and a usage caution. Only the return shape and failure behavior are left unstated, which are minor gaps here.

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 reinforces the 1–50 count constraint from maxItems/minItems and provides example variable names, which communicates the naming convention the regex enforces and what kinds of values are valid.

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 (Read) and resource (AutoCAD system variables) with scope ("from the live document") and concrete examples (CMDACTIVE, CLAYER, INSUNITS) that make the resource unambiguous among many autocad_* 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?

Gives a clear usage condition: use readback to verify command effects, since an idle state alone does not prove success. This implies the workflow relationship with autocad_send_command but does not explicitly name that sibling or state when not to use this tool.

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 does add genuine behavioral context: it discloses the return shape (data.applications, data.documents with window/process identity) and a real limitation ("COM may not expose every same-version AutoCAD process"). It does not explicitly confirm it is a side-effect-free read, but for a list tool the disclosure of the enumeration caveat is meaningful.

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?

Three short sentences, front-loaded with what it lists, then what it returns, then the caveat. Every sentence earns its place with no filler.

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 discovery tool with no output schema and no annotations, the description supplies the return structure and a key limitation, which is enough for an agent to call and interpret it correctly. It could be slightly richer by noting it is a read-only, side-effect-free probe, but nothing essential is 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?

The tool takes zero parameters, so there is no schema semantic to add and the baseline is 4. The description's note about window/process identity relates to outputs rather than inputs, which is harmless but not compensating for any parameter 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?

States a specific verb+resource ("List ... AutoCAD applications and their open documents") with the qualifying scope "COM-reachable". It is distinguishable from siblings like autocad_status or autocad_list_layers, though it never explicitly names a sibling or contrasts with them, so it stops short of a 5.

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 "for target selection" and "list ... applications" implies this is a discovery step preceding autocad_attach, so usage is implied rather than stated. There is no explicit when-to-use/when-not guidance or named alternative (e.g., autocad_status), which keeps this at a minimum-viable 3.

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 provided, so the description carries the full burden. It mentions 'through COM' and 'respecting the current application/document binding', which hints at COM interop and dependency on an active AutoCAD connection, but doesn't specify required permissions, error conditions, or whether it requires an attached session. There's no mention of what happens if no document is bound or if COM fails.

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 concise sentences that are front-loaded with the primary purpose and then the differentiation. No wasted words; all information is relevant.

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 0% schema description coverage, the description is incomplete. It doesn't explain the return format (list of layers?) or the behavior of the 'limit' parameter. It also doesn't clarify what 'respecting the current application/document binding' entails operationally (e.g., what happens if not attached).

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 a single optional 'limit' parameter. The description doesn't explain what 'limit' does (e.g., maximum layers to return) or its constraints (max 500). The schema has the type and range but no description, so the description should compensate, but it doesn't mention the parameter at all.

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 (List) and resource (layers) plus the source (live AutoCAD document through COM). It distinguishes itself from the sibling 'list_layers' by explicitly naming it and the source difference (internally 'internal CAD session' vs live AutoCAD). This is clear, though the phrase 'respecting the current application/document binding' is a bit abstract without further context.

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?

Provides clear context: use this to list layers from a live AutoCAD instance, as opposed to the internal CAD session's list_layers. It doesn't explicitly state when to choose one over the other beyond the source distinction, but the implication is clear. No explicit exclusions or prerequisites 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?

With no annotations, the description carries the full burden and does disclose meaningful context: entities come from the live AutoCAD document and results honor the current binding. It is silent on read-only safety, whether the limit is a cap vs. required, and pagination/ordering behavior, so a fair but incomplete picture.

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?

Three short sentences, front-loaded with the core action and scope. The disambiguating sentence earns its place; there is no filler, though slightly more could be said about the filters without bloat.

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 no-annotation, no-output-schema list tool, the description covers scope and the sibling distinction but leaves the return payload (entity types, handles, attributes) and filter semantics entirely unspecified. Adequate as a minimum-viable definition, not complete.

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, but it merely repeats the property names (layer, objectName, limit) with no added meaning — no matching semantics for layer, no admissible objectName values, no explanation that limit caps result count. An agent learns nothing beyond the raw schema keys.

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+resource (list entities) scoped to the live AutoCAD document's ModelSpace, and explicitly distinguishes itself from the similarly named internal list_entities sibling. An agent can tell which entity-listing tool to reach for without opening a schema.

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?

Gives a clear operating condition ('respecting the current binding') and names the alternative it is not (the internal CAD session's list_entities). It does not, however, address other plausibly overlapping siblings such as autocad_list_documents or find_entities_by_layer, so routing is only partially disambiguated.

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 burden and does so richly: rejection conditions, waitForIdle polling semantics, a separate 45-second bridge timeout, possible result states, the caveat that no state proves semantic success, MCP-error-on-timeout behavior, and a no-retry policy. This is unusually thorough failure-mode disclosure.

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?

Front-loaded with the core purpose and example, then builds out constraints, timing, and failure semantics. Dense but each sentence conveys distinct operational information; slightly packed but nothing is clearly 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?

For a complex, annotation-free tool with no output schema, the description covers failure modes, timing, and result-state semantics thoroughly. Minor gap: no guidance on which structured siblings supersede it or formatting rules for the command string.

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 explains waitForIdle's default and polling window, the timeoutMs range (1000-30000) and its relationship to idle polling, and gives a command syntax example. The command parameter itself could use more formatting guidance, but the two behavioral params are well covered.

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 ("Submit a raw command to the live AutoCAD document") and includes a concrete example (`_.ZOOM _E`). It is clearly distinguishable from the many structured autocad_* and geometry siblings as the raw escape-hatch tool.

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?

Gives clear operating context: rejects busy/inactive documents, explains when waitForIdle should be toggled, and instructs to query intended results afterward and not to resend after error/timeout. It does not, however, explicitly state when to prefer this raw tool over the structured 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 and does well: it declares the COM transport, the read-only inspection nature, and explicitly disclaims persistent binding and internal-session side effects. It omits failure behavior (e.g., what happens when no AutoCAD instance is running), which is a real gap for a status 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?

Two tight sentences, front-loaded with the verb and resource, followed by the scope disclaimer. Every clause carries information; nothing is redundant.

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 compensates by enumerating the inspected fields, which stands in for a return-value description. It is nearly self-sufficient; only error/edge-case behavior when AutoCAD is absent is 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?

The tool takes zero parameters, so the baseline is 4. The description correctly implies a no-argument call by describing the target application rather than any filter or identifier the caller 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?

Names a specific verb (Inspect) and a precise resource (a running AutoCAD application via COM), then enumerates the inspected aspects: window/process identity, binding, active document and idle state. It contrasts itself with the attach/binding tools by negating their behavior, but never names the sibling (e.g., autocad_attach) that an agent should pick instead, so differentiation is implied rather than explicit.

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