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

Annotations include readOnlyHint=false, indicating a write operation. The description adds operation-specific data shapes but does not disclose side effects, requirements, or error conditions beyond what the annotations already convey, providing only modest additional 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?

The description is efficiently structured: a one-line summary followed by a concise bulleted list of operations and their data. Every line adds necessary information, and the format is scannable.

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

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

Presence of an output schema covers return-value documentation. The description sufficiently defines all listed operations and their data inputs, though it doesn't address the optional include_screenshot parameter or confirm whether the operation list is exhaustive, leaving minor gaps.

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

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

The input schema treats 'data' as a generic object with additionalProperties, providing no structure. The description compensates by detailing the exact data fields for each operation (e.g., {x, y, text} for create_text), significantly enriching parameter understanding.

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 'Annotation: text, dimensions, and leaders' and enumerates specific operations (create_text, create_dimension_*, create_leader), making the tool's scope unambiguous and distinct from sibling tools like drawing or entity.

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 clear context that this tool is for creating annotation objects, and the operation names define the exact use cases. However, it doesn't explicitly state when not to use the tool or compare it to alternatives like the entity tool, so it lacks explicit 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?

Annotations already set readOnlyHint=false, aligning with the write operations listed. The description adds operation-specific data shapes but does not disclose side effects, error behavior, or whether operations affect the current drawing vs. a database. It is moderately transparent but lacks deeper 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?

The description is compact and well-structured, using a bullet list to separate operations. Each line is informative and directly relevant. Minor inefficiency: the initial sentence could be integrated with the list, but overall it is concise and scannable.

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

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

The tool is complex with multiple operations and an output schema exists (not shown). The description covers operation-specific parameters but lacks information on return values, error handling, permissions, or examples. Given the complexity, the description is helpful but incomplete for fully autonomous 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?

The input schema has 0% coverage in its descriptions, but the tool description compensates by detailing the required data structure for each operation (e.g., {name, x, y, scale?, rotation?, ...}). However, it omits any explanation for 'include_screenshot' and does not fully document all possible data fields for 'define' (uses ellipsis). Thus, partial compensation.

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 explicitly states the tool's scope: 'Block definition, insertion, and attribute management.' It lists specific operations with clear verbs (list, insert, get_attributes, update_attribute, define). This makes the purpose clear and differentiates it from generic tools, though it does not explicitly compare with 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 operation list implies usage contexts (e.g., use insert to add a block, define to create a definition), but there is no explicit guidance on when to prefer this tool over sibling tools like 'entity' or 'drawing'. The context is implied by the block-specific operations, but exclusions are 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?

The description discloses each operation's high-level behavior but lacks deeper context about side effects or safety. For example, 'purge' implies deletion but doesn't state it removes unused objects permanently. Annotations only provide readOnlyHint=false, so the description carries some burden but adds limited behavioral detail beyond the operation list.

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 well-structured, compact list. Each operation is summarized in a single line with no redundancy. The opening 'Drawing file management' provides immediate context, and the list format makes it easy to scan.

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

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

The description covers all operations and their data inputs, which is comprehensive for a dispatcher tool. It omits include_screenshot and does not explain return values, but an output schema exists, so return behavior need not be described. Given the multi-operation complexity, this strikes a good balance.

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%, but the description compensates by specifying the data shape for each operation (e.g., data:{name?}, data:{path}). However, it does not describe the include_screenshot parameter, which remains undocumented. The operation field itself is unconstrained in the schema, so the description is essential and mostly fulfills that need.

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 opens with 'Drawing file management' and enumerates ten distinct operations (create, open, info, save, save_as_dxf, plot_pdf, purge, get_variables, undo, redo). This clearly identifies the tool's purpose as a dispatcher for drawing file operations and distinguishes it from sibling tools like entity, layer, and block.

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 when to use the tool through its operation list, and provides specific guidance for save ('saves to path if given, else QSAVE') and create ('new empty drawing'). It does not explicitly mention exclusions or alternatives, but the operation list serves as clear context for when this tool is appropriate.

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

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

Annotations only indicate readOnlyHint: false, meaning the tool can mutate state. The description adds value by listing specific mutating operations (move, rotate, scale, erase) and read operations, which gives an overview of behavioral scope. However, it does not disclose side effects, permission requirements, or return value details beyond the operation names. It 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 well-organized with clear headings for create, read, and modify operations. Each operation is presented as a compact, single-line signature. There is no filler or redundant prose, making it easy to scan and reference despite covering many operations.

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

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

The description covers all major operations and their parameter schemas, which is sufficient for an agent to construct valid calls. An output schema exists, so return values are likely documented elsewhere. The description does not address error conditions or coordinate system specifics, but for a broad entity tool it is fairly 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 is the only source of parameter meaning. It thoroughly explains how general parameters like data, x1, x2, points, and entity_id are used for each operation, including nested structures for operations like create_circle and data for create_hatch. This fully compensates for the schema's lack of explanatory text.

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 begins with a clear statement of purpose: 'Entity creation, querying, and modification.' It then enumerates specific operations (create_line, create_circle, list, get, move, erase, etc.) with distinct verbs and resources. This clearly differentiates the tool's scope from sibling tools like drawing, layer, or block by focusing on entity-level 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 implies usage by listing operations and their parameters, but it does not explicitly state when to use this tool versus alternatives like block or annotation. There are no 'when not to use' or 'use X tool instead' statements. However, the grouping of operations gives a clear sense of the tool's domain, so it provides adequate context for an agent to decide when to invoke it.

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

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

Annotations only provide readOnlyHint:false, and the description adds the multi-operation structure and data shapes, signaling that most operations mutate layer state. However, it does not explain side effects of operations like set_current, freeze, or lock, nor does it mention persistence, permissions, or error 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 compact and front-loaded, opening with a clear purpose and then presenting a scannable list of operations and their data payloads. Every line carries useful information with no unnecessary padding.

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 seven-operation multiplexed tool, the description covers all operations and their data shapes, and an output schema exists to handle return values. It is slightly incomplete because it omits include_screenshot and does not elaborate on the behavioral consequences of each operation, but overall it is robust.

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

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

The input schema provides only bare parameter names without descriptions or enums, but the description compensates by listing valid operation values and the expected data fields for each operation. It does not mention include_screenshot, but the core parameter semantics are well documented.

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 'Layer creation and management' and then enumerates seven concrete operations (list, create, set_current, set_properties, freeze, thaw, lock, unlock), making the tool's resource and supported actions unmistakable. This operation list distinguishes it from sibling tools such as entity, block, or view.

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 operations list implies that this tool is for layer-related tasks, but there is no explicit statement about when to use this tool over sibling tools or when not to use it. No alternatives or exclusions are mentioned, so usage guidance is only implicit.

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 show readOnlyHint=false, so the agent knows operations mutate state. The description adds context by naming each operation and its data payload, implying effects like inserting a symbol or creating layers. However, it does not disclose prerequisites (e.g., whether setup_layers must be called first), potential overwrites, or error 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 terse, well-organized list. It front-loads the tool's purpose in the first sentence, then presents each operation on its own line with its data payload. There is no redundant text or 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?

Given the tool's complexity (a dispatcher with 12 operations), the description covers the operation catalog and their data formats well. However, it omits usage guidance, does not mention include_screenshot, and lacks information on operation prerequisites or sequencing. The presence of an output schema covers return values, but overall completeness remains moderate.

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 burden is on the description. It does give meaning to 'operation' by listing valid operation names and to 'data' by showing per-operation data structures, but it fails to explain the 'include_screenshot' parameter entirely and does not explicitly state that 'operation' must be one of the listed strings or that 'data' must conform to the selected operation's structure.

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 opens with 'P&ID drawing with CTO symbol library' and then enumerates a comprehensive list of specific operations (setup_layers, insert_symbol, draw_process_line, etc.), making the tool's purpose unmistakable. It clearly distinguishes itself from sibling tools by focusing on P&ID-specific symbols and process-line 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 lists operations but provides no guidance on when to use this tool versus its siblings (e.g., 'drawing' or 'entity'). There is no explicit 'use this when...' or 'for generic drawings use drawing tool instead', leaving the agent to infer usage solely from operation 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?

The annotations declare readOnlyHint=true, but the description includes operations 'init' (re-initialize backend) and 'execute_lisp' (execute arbitrary AutoLISP code) which are clearly mutating or potentially destructive. This directly contradicts the read-only annotation. The description also fails to disclose side effects or safety implications of these operations.

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 well-structured with a clear summary and a bulleted list of operations, each with a brief explanation. It is concise without unnecessary verbosity, though the inclusion of potentially dangerous operations warrants more cautionary wording.

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

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

The description lists operations but fails to explain return values, error handling, permissions, or the behavior of the 'include_screenshot' parameter. Given the tool's complexity and the presence of potentially destructive operations, the description is insufficient for an agent to use all features safely and 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 description adds meaning by listing valid values for the 'operation' parameter and specifying that 'execute_lisp' takes data with a 'code' field. However, it omits any discussion of the 'include_screenshot' parameter and does not clarify whether other operations use 'data', leaving gaps in parameter understanding.

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 identifies the tool as 'Server status and management' and enumerates specific operations (status, health, get_backend, runtime, init, execute_lisp), giving a clear idea of the resource and actions. It does not explicitly contrast with sibling tools, but the system focus is evident from the operation list.

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 provided on when to use this tool versus alternatives like drawing, entity, or layer tools. There is no mention of prerequisites, exclusions, or typical use cases beyond listing operations, so agents must infer usage from operation 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?

The annotations already declare readOnlyHint=true, covering the safety profile. The description adds operational detail but does not disclose potential side effects like modifying the current view state or any screenshot output details. Since annotations lower the burden, a score of 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 concise and well-structured, front-loaded with a summary sentence followed by a clean bullet-style list of operations. Every line earns its place with no redundancy or fluff.

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 view-control tool, the description covers all operations and parameter context, while annotations provide the read-only safety hint and an output schema exists. It is complete enough for an agent to select and invoke the tool correctly without further explanation.

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%, but the description compensates by explaining x1, y1, x2, y2 in the zoom_window line and listing valid operations. This adds meaning beyond the bare schema types, clarifying when parameters apply, even though it stops short of detailing units or optional behavior.

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 'Viewport control and screenshot capture' and enumerates three concrete operations (zoom_extents, zoom_window, get_screenshot). This specific verb+resource phrasing distinguishes it well from sibling tools like drawing, entity, and layer.

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 operation list implies when to use the tool (zoom or screenshot), providing clear context. It does not explicitly name alternatives or exclusions, but the operations themselves are self-explanatory, making usage reasonably obvious.

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