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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so the safety profile is established. The description adds useful input context ('from entities' and 'import a DWG as a block') but does not disclose side effects such as overwriting an existing block definition, deleteSource behavior, or zoomToResult effects. With annotations carrying the destructive/mutation burden, this is adequate but not rich.

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

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

The description is one sentence and front-loads the core operations, making it easy to scan. It earns its place by naming four relevant actions. It is not bloated, though the ambiguity around 'redefine it' slightly reduces clarity.

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 15 parameters, nested objects, multiple actions, no output schema, and only 20% schema description coverage, the description is far too thin. It omits action-parameter relationships, required expectedDocumentId/expectedRevision concurrency semantics, result conventions, and side-effect details, so an agent cannot confidently invoke all advertised operations correctly.

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

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

Schema description coverage is only 20%, and the description does not compensate. It fails to explain how action maps to the other 15 parameters, such as sourceHandles for create, sourcePath for import, or insertionPoint/scale/rotation for insert. The 'redefine' phrase is also not represented in the action enum, creating possible parameter-selection ambiguity.

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 specific block-domain verbs and a clear resource: 'Create a block definition from entities, insert a block, redefine it, or import a DWG as a block.' It is clearly about block operations and distinguishes this tool from the other cad_* siblings by resource and action. It stops short of 5 because it mentions 'redefine it' while the schema action enum only lists create, insert, and import.

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 is given about when to use this tool versus alternatives such as cad_draw, cad_edit, or cad_command. There are no exclusions, prerequisites, or context cues beyond listing the actions. The agent is left to infer the appropriate use case from the action names 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?

Annotations already signal readOnly, idempotent, and non-destructive behavior, and the description adds the critical detail that this tool does not contact AutoCAD. It does not describe output formatting or potential caveats, but for a zero-parameter read-only capability query the behavioral disclosure is solid.

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 entire description is one tight sentence beginning with the action and the deliverable, followed by a key behavioral qualifier. There is no filler, and every phrase adds either scope or operational context.

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 parameters and no output schema, the description carries the full burden of explaining what the tool returns, and it lists the main content areas. It could elaborate on the exact structure of the matrix or limits, but for a simple capabilities query the information is sufficient for an agent 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?

The tool has zero parameters, so the input schema carries no burden and the description does not need to explain parameter semantics. The baseline of 4 for parameterless tools applies, and the description avoids inventing unnecessary parameter details.

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 ('Return') and defines a clear resource: the exact feature matrix, limits, coordinate conventions, and verified export behavior. It also states a distinctive constraint ('without contacting AutoCAD') that separates it from CAD interaction tools like cad_connect or cad_command.

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 'without contacting AutoCAD' implies this tool is for querying static capability information rather than live state, which gives some usage context. However, there is no explicit guidance about when to prefer this over siblings or when not to use it, leaving some inference required.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, openWorldHint=false, and idempotentHint=false, so the safety profile is known. The description adds critical context: commands are blocked unless explicitly allowlisted in the plugin configuration. It doesn't explain what happens on failure, what the return format is, or how waiting for completion affects behavior, so it earns a 3 despite the useful allowlist note.

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 with no waste, and the primary constraint (use only as fallback) is front-loaded before the allowlist condition. Very efficient and readable.

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 coverage for safety details, no output schema, and 0% schema description coverage, the description should do more to explain the parameters, the command string format, expected return behavior, and the consequences of destructive commands. The allowlist note is valuable but insufficient for a high-risk, unannotated 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 all three parameters (command, arguments, waitForCompletion) lack any documentation in both the schema and the description. The description does not mention any parameter, leaving the agent to infer their format and constraints, which is especially problematic for a command-string-based interface.

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: 'Run an AutoCAD command sequence'. It also distinguishes from specialized siblings by positioning itself as a fallback when those cannot express the operation. The scope of 'command sequence' is slightly ambiguous, but the core purpose is clear.

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?

Explicitly says to use this only when a specialized MCP tool cannot express the operation, which effectively implies using the specialized sibling tools first. However, it doesn't name specific alternatives or provide concrete examples of what that means in practice.

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?

The annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description adds important behavioral context beyond them: it establishes a persistent scoping effect on subsequent MCP calls. This is exactly the kind of stateful behavior an agent needs to know before invoking the 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?

Two tight sentences with no filler; the core action is front-loaded and the rationale follows immediately. Every word earns 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 a simple one-parameter tool it conveys the core mechanism, but it omits how to discover the processId and how the binding might be changed or released. Since there is no output schema and no param descriptions, those details would make the definition fully self-sufficient.

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 the undocumented processId parameter. It only says 'one specific AutoCAD process' and never explains that processId is the target process identifier or where to obtain it, leaving a meaningful gap for correct invocation.

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 action and resource: 'Bind subsequent MCP calls to one specific AutoCAD process,' which is a clear and unique purpose. The second sentence adds a concrete rationale (avoiding the wrong drawing) that distinguishes it from generic command tools and process-listing siblings like cad_instances.

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 clearly identifies when to use the tool: 'when multiple instances are running' and routing to the wrong drawing is a risk. It does not name alternatives or explicitly say when not to use it, so it stops short of full 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description does not contradict them. The description adds that paths must be absolute local paths and that save/saveAs/overwrite semantics exist via parameters, but it does not disclose which actions are destructive (e.g., overwrite behavior, close discarding changes), the risk of saving over files, or authentication/permission needs. Given the destructive hint is already present, the gap is moderate rather than severe, so 3 is appropriate.

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 one concise sentence that front-loads the action list and then the critical path constraint. Every word earns its place and there is no filler. It loses one point only because it is so terse that it omits important usage context that would fit naturally in another sentence.

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

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

Given 9 parameters, a large sibling set, no output schema, and only minimal annotations, the description is under-specified. It does not explain which parameters apply to which actions, the meaning of documentId vs path, the dependencies between action and other parameters, or the safety implications of destructive flags like overwrite and discardChanges. An agent would need to probe the tool or make risky assumptions to call it correctly.

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

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

Schema description coverage is very low (11%) and there are 9 parameters, mostly undocumented. The description adds almost no parameter-level meaning: it implies path is the document path and action is one of the verbs, but it does not explain documentId, template, overwrite, readOnly, discardChanges, password, or version. The enum on action is self-descriptive, but the other seven parameters require inference, so the description fails to compensate for the schema gap.

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

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

The description names a specific verb list and resource ('Create, open, save, save-as, close, activate, or list AutoCAD drawings') and states a key constraint (absolute local paths). It identifies the tool as the document lifecycle manager within a large sibling group (cad_document vs cad_draw/cad_edit/cad_view etc.), so an agent can reasonably distinguish it without opening the schema. However, it doesn't name any sibling explicitly, and the verb list bundles many actions into one description rather than isolating the one the tool is for.

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 implies the tool is for file-level document operations versus drawing, editing, or inspecting (implied by the verb list), but it gives no explicit when-to-use versus alternatives or exclusions. The path constraint is stated, which is useful operational guidance. Siblings like cad_draw, cad_edit, cad_view, and cad_workflow are not mentioned, so an agent must infer routing from the action verb list.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=true, so the mutation nature is known. The description adds the key behavioral trait of atomicity ('Atomically create'), which is not in the annotations. It does not, however, disclose other side effects such as revision increments, event emission, or failure rollback behavior, so it only partially enriches beyond the structured data.

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, tight sentence that front-loads the core purpose before adding the unit/coordinate note. Every clause earns its place: the atomicity, the entity types, and the critical geometric conventions. No filler or redundancy.

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 high complexity—8 top-level parameters, 20+ entity variants, no output schema, and a 1000-item array limit—the description is far from complete. It omits preconditions like expectedDocumentId and expectedRevision, the meaning of visualMode options beyond the schema, and any error/rollback semantics. An agent would need to deep-dive into the schema and infer much of the usage context on its own.

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 only 38% schema description coverage, the description partially compensates by stating global conventions: 'Angles are radians and coordinates use the current UCS unless otherwise stated.' This is valuable for all coordinate/angle parameters. However, it does not explain the entities array's structure, defaults for visualMode, or the purpose of expectedRevision/expectedDocumentId beyond what the schema already provides, so it falls short of fully bridging 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 specific verb ('create') and enumerates the resource types ('2D entities, annotations, hatches, dimensions, and block references'). It also adds the atomicity qualifier, which distinguishes it from siblings like cad_edit (which modifies) and cad_command (which executes arbitrary commands). This is clear and differentiates from alternative 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?

Usage is implied: an agent would use this tool to create new drawing objects. However, there is no explicit guidance on when to prefer this over cad_edit for modifications, cad_undo for reverting, or cad_block for block-specific operations. No exclusions or alternative conditions 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?

The description adds the behavioral trait 'Atomically' which is not in annotations, implying all operations succeed or none. However, it does not disclose critical details like the need for expectedDocumentId, expectedRevision, the effect of destructive operations beyond annotations, or what happens on failure. Given destructiveHint=true is already declared, the description adds minimal value beyond the atomicity note and doesn't mention error handling or rollback behavior.

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

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

The description is a single, dense sentence with no filler. It leads with the core action and scope, then lists operations. Every word serves a purpose, and it is appropriately concise for the amount of information it conveys.

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 highly complex tool (8 parameters, nested objects, no output schema) and the description is insufficient. It does not explain how to construct the filter (e.g., window point format, layer/type values), how to chain multiple operations, coordinate system assumptions, or what success returns. The lack of output schema means the description should cover result behavior, but it doesn't. For a tool this complex, the description is far from 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 only 38%, so the description must compensate. It adds clarity that 'target' can be 'exact handles or a constrained filter' and enumerates the operation types, but it does not explain the structure of the target.filter (e.g., window coordinates, layer names), the meaning of from/to/base/angle/factor in operations, or the format of coordinates and angles. Most parameter semantics are left to the schema, which is sparse, so the description provides only marginal help.

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 clearly states a specific verb ('edit') and resource ('entities'), and lists the supported operations (properties, move, copy, rotate, scale, mirror, erase). It distinguishes itself from sibling tools like cad_draw (creation) and cad_inspect (reading) by focusing on modification. The phrase 'Atomically edit' adds a precise scope that is unique among the 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 provides no guidance on when to use this tool versus alternatives such as cad_command or cad_undo. It does not mention that cad_command might be simpler for single commands, or that cad_edit is for batch/atomic edits. There are no exclusions or conditional recommendations, leaving the agent to infer usage solely from the tool name and 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds useful context about the bounded journal and sequence cursor, implying incremental reading. It does not describe return format or error behavior, but given the annotation coverage, a 3 is appropriate.

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, well-formed sentence that packs the core action, resource, and event categories without any fluff. The most important information is front-loaded, making it easy for an agent to parse quickly.

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 four optional parameters, the description covers the tool's purpose but leaves the return structure and parameter interactions unexplained. For a read-only tool with safety annotations, this is adequate but not thorough enough to merit a 4.

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 this partially does: 'bounded' hints at the limit parameter, 'sequence cursor' maps to afterSequence, and the listed event types relate to the types filter. However, it does not explain documentId or the precise filtering semantics, so it only partially fills the 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 specific verb (Read) and resource (bounded AutoCAD change journal) plus the constraint 'after a sequence cursor'. It also enumerates event categories, which clearly distinguish it from other CAD inspection tools. However, it does not explicitly name sibling tools, 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 like cad_inspect or cad_status. The description explains what the tool does but does not mention any selection criteria or exclusions, leaving the agent to infer 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?

Annotations already signal destructiveHint=trueants, and the description adds a useful constraint about absolute pathsaine. However, it does not disclose overwrite behavior, file-extension expectations, or side effects beyond the annotation's generic destructive warning.

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 compact and front-loaded with the verb and resource. It wastes no words, though it could have used the room to mention the omitted STL format or clarify overwrite behavior.

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?

There is no output schemaasiatic and 7 parameters, but the description only addresses two and leaves important invocation details (version enums, overwrite semantics, what the tool returns) unstated. This is not enough for an agent to call the tool correctly with advanced options.

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 0% schema description coverage, the description carries the full burden of parameter explanation. It covers format and path partially, but leaves layout, options, version, overwrite, and selection entirely unexplained—significant gaps given the schema has 7 parameters.

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 ('Export') and resource ('active drawing or a layout') and lists the supported output formats. This clearly distinguishes cad_export from sibling tools like cad_draw or cad_inspect.

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 clear context by specifying the input resource and formats, but it does not explicitly state when to prefer this tool over alternatives or when not to use it. The usage is implied rather than explicitly guided.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds one behavioral hint (handles are reusable for edits) but does not state pagination behavior (limit/offset), whether entity geometry is omitted by default, or what happens with large drawings. For a read tool with 8 params and nested filters, this is thin.

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, no filler, front-loaded with the verb and the enumerated resource scope. Efficient.

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 8 parameters, a nested filter object, an enum scope, and 13% schema description coverage, the description is far too sparse. No output schema exists, so the description should describe what gets returned (metadata shape, pagination, handle usage), but does not. Only one workflow hint (handles for edits) is provided.

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

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

Schema description coverage is only 13%; six of eight parameters (limit, scope, filter, offset, handles, includeExtents, includeGeometry) have no description in the schema and the description contributes nothing about any parameter. The description mentions 'handles' and 'system variables' loosely but does not explain scope enum values, filter semantics, pagination, or the geometry flag. It fails to compensate for the low coverage.

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

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

States a specific verb (Read) plus a concrete resource list of CAD drawing metadata (system variables, layers, blocks, layouts, styles, entities). Clear what the tool does, though it doesn't explicitly contrast with cad_edit/cad_document beyond the hint 'Use handles returned here for precise edits.'

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 second sentence implies a workflow: read here, then edit using returned handles. But no explicit when-to-use vs siblings (e.g., cad_document, cad_measure, cad_instances) is given. Implied usage only.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds value beyond that by scoping the result to processes registered with this MCP server and disclosing the returned fields (PID, active drawing), which matters since no output schema exists.

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

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

Two sentences, each earning its place: the first defines the output, the second defines when to call it. The purpose is front-loaded ahead of the usage rule.

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 parameterless read-only discovery tool with full annotation coverage, the description supplies everything needed: what is listed, what is returned, and when to prefer it over cad_connect. Nothing an agent needs to invoke it correctly 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 per the rubric the baseline is 4. There is nothing for the description to clarify about inputs, and it correctly implies no arguments are needed.

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 (running AutoCAD 2024 processes) plus the scope constraint (registered with this MCP server) and returned fields (PID and active drawing). An agent can distinguish this discovery tool from cad_connect or cad_status 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?

Explicitly names the trigger condition and the follow-up tool: 'Use this before cad_connect when multiple AutoCAD windows are open.' The when-to-use and the related alternative are both stated, leaving nothing 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?

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds no behavioral detail beyond restating the action enum; it does not explain consequences such as deleting being irreversible, what isolate/restore does to visibility, or whether changes require a document/revision check.

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 or repetition. Every listed verb adds meaning, and the resource is immediately clear.

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

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

This is a complex, destructive tool with 9 parameters, nested objects, action-specific requirements, and no output schema. A one-line description is far from sufficient; an agent cannot determine per-action required parameters, return behavior, or error/side-effect expectations.

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 only 33% schema description coverage, the description should compensate for undocumented parameters, but it does not. It only paraphrases the action enum and provides no meaning for properties, visualMode, zoomToResult, expectedRevision, highlightResults, or expectedDocumentId.

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

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

The description identifies the resource (drawing layers) and enumerates all key operations: create, update, delete, rename, set current, isolate, restore. It clearly distinguishes this tool from sibling tools like cad_draw and cad_edit by focusing exclusively on layer operations.

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 guidance on when to use cad_layer versus alternatives, nor does it mention any exclusions, prerequisites, or conditions. Usage can only be inferred from the resource name 'layers,' which is not explicit enough to route an agent reliably.

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

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

Annotations declare destructiveHint=true, so the agent knows this tool can be destructive. The description adds the scope of behavior (managing layouts and plot settings) but does not disclose which actions are destructive (e.g., delete) versus safe (e.g., list), nor does it mention side effects like activating a layout changing the current view. It adds some context beyond annotations but not rich behavioral detail.

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

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

The description is a single sentence that front-loads the action list and resource. It is concise and every word earns its place. It could be slightly more structured by separating the action list from the resource, but it is appropriately sized and readable.

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 (9 parameters, nested settings object, 6 actions, destructive annotation, no output schema), the description is too thin. It does not explain the relationship between actions and required parameters (e.g., rename requires newName, configure requires settings), nor does it clarify the meaning of the concurrency-control parameters (expectedRevision, expectedDocumentId) or the visualMode options. An agent would need to open the schema and guess at parameter semantics, which is a significant 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 description coverage is only 33%, so the description must compensate for undocumented parameters. The description mentions 'plot settings' which maps to the settings object, but it does not explain the meaning of parameters like expectedRevision, expectedDocumentId, visualMode, zoomToResult, or highlightResults. The schema provides descriptions for only a few parameters (visualMode, expectedRevision, expectedDocumentId), leaving the rest unexplained. The description adds minimal semantic value beyond the schema.

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

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

The description states a clear verb set ('Create, rename, delete, activate, configure, or list') and a specific resource ('paper-space layouts and their plot settings'). It distinguishes the tool's scope from siblings like cad_layer, cad_view, and cad_document, though it doesn't explicitly name a sibling alternative. The action enum in the schema reinforces the verb list, so the purpose is clear and specific.

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 implies usage by enumerating the supported actions, which gives an agent a sense of when to call this tool (whenever a layout operation is needed). However, it does not explicitly state when NOT to use it or mention alternatives like cad_view or cad_document for related but different operations. The context is clear but exclusions are absent.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds that mass is optional and derives from density, but it omits relevant behavior such as the 500-entity cap on handles and what happens with unsupported entity types.

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

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

A single front-loaded sentence with the verb and then a compact enumeration of outputs; every clause carries information and 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, the description usefully enumerates the returned metrics, which is the key information an agent needs. It is nearly complete for a read-only measurement tool, with only minor gaps around units and selection prerequisites.

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 50%: the density parameter is documented in the schema, and the description reinforces its purpose ('optional mass from density'), while handles is only self-evident as an identifier list. With half the parameters documented, the description neither compensates fully nor needs to, so a baseline 3 is appropriate.

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

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

The description gives a specific verb (measure) and resource (selected entities) and enumerates exactly what is computed: extents, curve length, planar area, 3D solid volume, centroid, and optional mass. It is clear and self-contained, though it does not explicitly differentiate itself from potentially overlapping siblings such as cad_inspect or cad_solid.

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, and no prerequisites are stated. The phrase 'selected entities' implies the caller must first have a selection, but this is left to inference rather than stated, and no sibling tool is named or excluded.

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

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

Annotations already signal destructive, non-read-only behavior; the description adds useful traits: deterministic reconstruction, the need to retain the recipe and returned liveHandles for later rebuilds, and the build/rebuild duality. There is no contradiction with the 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?

Two sentences, with the core purpose front-loaded and the follow-up sentence adding only the key lifecycle instruction. No filler or schema repetition.

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 nested schema with no output schema, the description covers the high-level workflow (build/rebuild, keep recipe/handles) but leaves the roles of overrides and previousHandles implicit and does not describe the shape/format of the returned liveHandles. It is enough for a general understanding but not fully sufficient for correct invocation without inspecting the schema.

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

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

Schema description coverage is 0%, so the description must compensate. It names the central 'recipe' object and introduces 'liveHandles' as a rebuild token, which helps infer the role of previousHandles, but it never explains overrides or the relationship between recipe.parameters and overrides. The property names in the schema carry most of the remaining meaning, so this is adequate but not rich.

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

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

The description names a specific action ('Build or rebuild'), a resource ('deterministic parameterized solid model'), and the input mechanism ('named recipe'), and adds a lifecycle cue about liveHandles. This clearly distinguishes it from sibling drawing/editing tools like cad_draw and cad_edit by anchoring it to recipe-driven model construction.

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 gives clear context: use for initial build or later rebuild from a recipe, and keep the recipe and returned liveHandles for subsequent calls. It does not explicitly name alternative tools or say when not to use it, so it falls short of a 5.

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

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

Annotations already declare destructiveHint=true, so the description doesn't need to restate that. The description adds useful context: coordinates are WCS, one request is atomic, and it creates editable primitives. However, it doesn't disclose details like whether boolean operations modify existing entities destructively, what happens to source entities, or any side effects beyond the atomicity note. The description doesn't contradict 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 sentence that packs in the core purpose and two key behavioral facts (WCS, atomicity). It's concise and front-loaded with the main action. However, it could be slightly more structured by separating the create vs boolean operations, but it's still efficient.

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 has 23 parameters, no output schema, and only 13% schema description coverage, the description is far from complete. An agent would not know how to choose between action values, what handles are needed, how boolean operations reference existing solids, or what the expectedRevision/expectedDocumentId are for. The atomicity and WCS notes are helpful but insufficient for a tool this complex.

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

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

Schema description coverage is only 13%, so the description must compensate for the 23 parameters. It mentions 'boolean union, subtract, and intersect operations' which maps to the 'operation' enum, and 'primitives' is implied. But it doesn't explain key parameters like action, toolHandles, targetHandle, eraseSource, eraseTools, pathHandle, profileHandle, expectedRevision, expectedDocumentId, visualMode, zoomToResult, highlightResults, etc. The description adds minimal meaning beyond the schema.

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

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

The description clearly states the tool creates editable AutoCAD 3DSOLID primitives and applies boolean operations (union, subtract, intersect). It names specific verbs and resources, and the mention of boolean operations helps distinguish it from generic cad_draw or cad_edit. However, it doesn't explicitly differentiate from cad_model_build or cad_edit, which could overlap in purpose.

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

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

The description implies usage for creating 3D solids and boolean operations, but it doesn't explicitly state when to use this tool versus alternatives like cad_draw, cad_model_build, or cad_edit. It mentions coordinates are WCS and one request is atomic, which gives some context, but no explicit when/when-not guidance or alternative tool names.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety and idempotency profile is fully carried by structured data. The description adds the concrete scope of what is inspected (bridge, document, version, drawing state), which is useful, but no return format, cost, or freshness details given there is no output schema.

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 a specific verb and a coherent list of inspected items. No filler, no repetition of the tool name.

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

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

For a zero-param read-only status tool with full annotation coverage, the description is close to complete, but with no output schema it should say something about what the check returns (e.g., connection state, version string, drawing name) so the agent knows whether the result answers its question. As written the enumerated items imply returns but don't confirm them.

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?

Zero parameters, so per the rubric the baseline is 4. Nothing to describe and nothing misleading; the description appropriately spends its budget on scope rather than params.

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 ('Check') and enumerates the resources checked: bridge, active document, product version, drawing state. This is clear and specific. It doesn't explicitly differentiate from siblings like cad_instances or cad_capabilities, which could also report on the connection/product, but the enumerated scope is distinctive enough.

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 explicit when-to-use or when-not-to-use guidance. With zero parameters and a read-only status role, usage is somewhat implied (health/state check), but the agent gets no routing help against siblings like cad_capabilities for 'what can this product do' questions. Implied usage only.

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

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

Annotations already indicate destructive behavior approximating, so the description does not need to restate that. The additional note about CJK text being assigned a Unicode-capable style is a useful behavioral detail. However, side effects of update or apply, such as modifying existing entities or changing current style state, are not disclosed.

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

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

The description is compact and front-loaded with the main operations; the second sentence adds a genuinely useful behavioral detail. It is appropriately sized, though not formatted for easy parsing of the multiple action branches.

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 13-parameter tool with a nested target objectadian destructive annotations and no output schema, yet the description does not explain target semantics, action-specific requirements, or parameter interactions. An agent cannot reliably construct a correct call for actions like apply or update from this description alone.

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

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

Schema description coverage is only 23%, and the description does not explain the many undocumented parameters such as target, name, fontFile, vertical, zoomToResult, or expectedRevision. The description adds no parameter-level meaning to compensate for the low schema coverage.

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

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

The description names specific operations (list, create, update, set current, apply) on AutoCAD text styles, which clearly identifies the resource and verb. However, 'apply' remains somewhat ambiguous without more context, and the description does not explicitly differentiate it from sibling 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?

The description provides no guidance about when to use this tool instead of siblings, no prerequisites, and no explanation of how the different actions relate to one another. The CJK note implies a particular use case but does not help an agent decide between actions or 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?

Annotations declare destructiveHint=true, readOnlyHint=false, idempotentHint=false, so the agent knows this mutates state. The description adds little beyond 'completed MCP edit operations' scope. It does not state whether undo is limited by session history, whether it affects unsaved changes, or what happens at history boundaries.

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 tight sentence with the core purpose front-loaded. No waste, but minimal given the tool's mutating nature.

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 output schema, no annotations covering step limits or history scope, and no parameter documentation. The description is only minimally complete for calling it correctly.

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

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

Schema coverage is 0% and the description names neither 'action' (undo/redo enum) nor 'steps'. The agent must open the schema to learn the required action enum and the 1-20 step bound. The description should have at least mentioned the action/steps shape.

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: undo/redo of completed MCP edit operations in the active drawing. Clear scope, though does not differentiate from cad_edit or cad_command among 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?

Implies use for reverting or re-applying edits via 'completed MCP edit operations', giving some context, but no explicit when-to-use vs cad_edit, no exclusions, and the action parameter name is left for the schema to explain.

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

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

Annotations already signal mutating behavior (readOnlyHint=false, destructiveHint=true), and the description adds little beyond listing operations. It does not explain side effects of regen, what 'capture' writes, or which state changes occur. No contradiction with annotations is present.

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

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

The description is a single, front-loaded sentence with no filler. It is concise and scannable, though its brevity comes at the cost of essential parameter-action mapping details.

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 9 parameters, multiple distinct actions, and no output schema, the description is too thin. An agent cannot determine which parameters apply to which action, what capture returns, or what side effects regen and view changes have.

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 hints at viewName for named views and width/height/path/overwrite for capture, but it does not map parameters to specific actions or explain geometric parameters like delta, window, or handles.

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 clearly names the resource (view) and specific verbs: zoom, pan, orbit, switch named views, regen, capture. It doesn't explicitly distinguish from siblings like cad_inspect or cad_measure, but the action vocabulary makes its view-navigation scope reasonably clear.

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 cad_view versus alternatives such as cad_inspect, cad_measure, or cad_draw. The action enum implies a view-manipulation tool, but no explicit context, exclusions, or alternative routing 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?

Annotations already declare idempotent and destructive behavior, and the description adds genuinely useful context: document preconditions, argument validation, optional post-change verification, and compensating undo. It does not contradict the annotations and adds behavioral meaning beyond the structured hints.

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 compact single sentence that front-loads the core action and resource. It lists many relevant behaviors without obvious filler, though the dense chain of clauses makes it slightly less scannable than ideal.

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 tool with 8 parameters, nested verification/expectedDocument objects, and no output schema, the description is incomplete. It does not explain what preview returns, how verification failures behave, how expectedDocument matching works, or the operational meaning of rollbackOnFailure and visualMode.

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

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

Schema description coverage is 0%, so the description must compensate for parameter semantics. It vaguely maps to concepts like expectedDocument, verification, idempotencyKey, and rollbackOnFailure, but it does not explain mode values, visualMode, workflowId, or the steps structure. This is insufficient for 8 parameters with nested objects.

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

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

The description names a specific action ('Preview or apply') and a specific resource ('bounded multi-step CAD change set'), and further distinguishes it from sibling single-purpose CAD tools by mentioning preconditions, verification, idempotency, and undo. This clearly separates cad_workflow from cad_command, cad_edit, cad_undo, and similar 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 clear usage context: this tool is for bounded multi-step change sets with preview/apply modes and compensating behavior, which implies when it should be chosen over direct editing tools. It does not explicitly state when not to use it or name alternatives, but it is not misleading.

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