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

With no annotations provided, the description carries the full burden. It does disclose the batch-add behavior, the modelspace target, and a rich catalog of supported entity shapes. However, it does not mention side effects like whether entities are appended versus replacing existing content, whether the file must already exist, or how invalid entities are handled.

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 long but highly information-dense: every entity type line adds necessary formatting detail that the schema lacks. The content is front-loaded with the core action and modelspace target before the examples. A more compact representation would risk losing critical type-specific parameter information.

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

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

Given the high complexity of the entities parameter and the complete absence of schema detail, the description does enough for an agent to invoke the tool with correct entity payloads. It stops short of explaining file-path prerequisites, behavior with existing drawings, and response/error semantics, but the provided examples cover the primary invoke-correctly needs.

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 schema itself only defines an opaque array of objects. The description compensates fully by providing detailed JSON examples for every supported entity type, including required fields like start/end, center/radius, and insert points. This is essential for constructing valid calls.

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 ('Batch add geometric entities') and a precise resource ('a DXF drawing's modelspace'). It also enumerates the supported entity types, which clearly separates this tool from siblings like add_layer, delete_entities, and query_drawing_entities.

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 implies when to use the tool: whenever geometric entities need to be added to a drawing. However, it does not explicitly state when not to use it or mention alternatives like execute_ezdxf_script for more custom entity creation.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does usefully reveal that the tool can update an existing layer rather than only creating one. However, it omits side effects such as file modification, whether existing layer properties are overwritten, persistence behavior, and any failure conditions.

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 short and front-loaded with the main action, followed by a compact, useful bullet about color formats. There is no filler or repetition. It sacrifices completeness in favor of brevity, but what is present is efficiently structured.

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

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

For a mutating tool with no annotations and minimal parameter documentation, the description is incomplete. It does not clarify the required file_path and name semantics, update behavior, or how the optional parameters behave. An output schema may cover return values, but the operational context is still too thin.

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 explains the color parameter well with ACI numbers, color names, and hex values. However, it leaves name, file_path, linetype, lineweight, and description without any added semantic meaning beyond their types and defaults.

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 action and resource: 'Add a new layer or update an existing layer in a DXF drawing.' This distinguishes it from siblings like list_layers and add_entities, since it specifically targets layer definitions. It does not name sibling alternatives, but the core purpose is unambiguous.

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 list_layers, add_entities, or execute_ezdxf_script. No conditions, prerequisites, or exclusions are provided, so an agent must infer when this tool is the right choice.

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

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

No annotations are provided, so the description carries the full disclosure burden. It clearly says the operation creates a file, but it does not disclose overwrite behavior, handling of existing files, file-system side effects, or any other consequences. For a file-creation tool this is a notable gap.

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

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

The description is compact and front-loaded: a single purpose sentence followed by concise parameter bullets. There is no filler or redundancy, and every line contributes usable information.

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

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

This is minimally viable for a simple creation tool: an agent can understand the main action and most parameters, and an output schema exists. Still, the required file_path is undocumented in both the description and schema, and the absence of overwrite/side-effect context leaves an important 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?

With 0% schema description coverage, the bullet examples add real value for dxf_version, units, and layers. However, the required file_path parameter is completely omitted, so its semantics must be inferred from the schema field name.

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

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

The description states a specific verb and resource: 'Create a new blank DXF CAD drawing file.' The word 'blank' also differentiates this from sibling tools that read, query, export, or add content to existing drawings.

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 only implied: this tool is for creating a fresh, empty drawing. There is no explicit guidance about when to prefer it over alternatives such as add_entities or execute_ezdxf_script, nor any when-not-to-use conditions.

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

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

With no annotations available, the description carries the full burden of behavioral disclosure, but it mostly restates the tool's name. It does not disclose whether the file is modified in-place, whether deletion is permanent, how the selection criteria interact, or what happens when no entities match the filter.

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, tightly worded sentence that front-loads the action and resource, then states the selection modes. Every word contributes meaning, and there is no redundant or filler content.

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

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

For a destructive tool with four parameters, no annotations, and no schema property descriptions, the description is too sparse. It omits critical side-effect information, default behavior, and parameter combination rules. While an output schema exists, it cannot convey whether the file is permanently altered or whether filters are exclusive.

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 to handles, layer, and entity_type by framing them as filters, which is helpful because the schema has no property descriptions (0% coverage). However, it does not explain file_path, nor does it clarify whether layer and entity_type are combined or mutually exclusive.

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 action (delete) on a specific resource (entities in a DXF file) and identifies two selection mechanisms: handle list or layer/entity type filter. This clearly distinguishes delete_entities from sibling tools like query_drawing_entities and add_entities.

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: when the goal is deletion of entities from a DXF file. However, it provides no explicit comparison to alternatives or exclusions, and it does not clarify when the handle-list mode should be preferred over the layer/entity type filter mode.

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

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

With no annotations, the description carries the burden of explaining behavior. It usefully discloses that code is executed, which variables are available, and how result should be assigned. However, it does not mention side effects, whether the drawing is modified, error behavior, or security implications of arbitrary code execution.

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, front-loaded, and contains only essential information. It avoids filler while still communicating the execution model and required result convention.

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 high complexity of arbitrary code execution and the absence of annotations, the description is not sufficiently complete. It lacks clarity on target_file, what doc/msp represent, how the result is used, and whether changes are persisted. The presence of an output schema reduces some burden, but the core execution contract remains underspecified.

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 only lightly addresses parameters. script_code is implied as custom Python code, and target_file appears in the variable list but its meaning as a parameter is not explained. The description does not compensate for the missing schema documentation.

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

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

The description clearly states it executes custom Python code with ezdxf for parametric drafting or calculations, identifying both the verb and the resource. It is distinct from the sibling tools, though it does not explicitly name alternatives or contrast with them.

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

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

The phrase 'advanced parametric drafting or calculations' implies when it should be used, but there are no explicit conditions, exclusions, or guidance comparing it to alternatives like generate_autocad_scr or add_entities. The usage context is implied rather than stated.

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

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

With no annotations, the description must carry behavioral disclosure. It clearly states the core transformation from DXF to PDF and implies file generation, but it does not address side effects such as output_path default behavior, overwriting, or whether the source DXF is modified. No contradiction with annotations exists because no annotations are 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 one concise, front-loaded sentence with no filler. Every word contributes to the core purpose.

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?

Although an output schema exists and the tool is simple, the description is too thin to be complete: it gives no selection guidance among PDF/SVG/PNG siblings and leaves four parameters effectively undocumented. An agent could invoke it, but not confidently choose or configure it.

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

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

Schema description coverage is 0%, so the description must compensate. 'DXF CAD drawing' and 'PDF format' loosely map to file_path and output_path, but the description does not explain bg_color, layout_name, or the optional output_path behavior, leaving most parameter semantics to schema names and defaults.

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-resource pair: 'Render and export DXF CAD drawing to PDF format.' The explicit PDF format distinguishes it from sibling tools like export_drawing_to_svg and export_drawing_to_png.

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 choose PDF export over the SVG or PNG export siblings, nor any exclusion criteria. The agent must infer selection from the format name alone.

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

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

No annotations are provided, so the description carries full disclosure burden. It only mentions the output format and resolution; it does not say whether the tool writes a file, what output_path null means, how DPI/color settings affect rendering, or whether the operation has side effects.

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

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

The description is a single front-loaded sentence with no filler or repetition. It is concise, but the brevity comes at the cost of omitting parameter and behavioral context, so it is not fully 'appropriately sized' for the tool's complexity.

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

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

For a six-parameter tool with no annotations and zero parameter descriptions, this one-line description is not complete enough. It provides no guidance on layouts, colors, output path behavior, or when to prefer SVG/PDF siblings. The output schema may cover return values but cannot compensate for missing invocation semantics.

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

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

Schema description coverage is 0%, so the description must compensate for six undocumented parameters. It only hints at dpi via 'high-resolution' and PNG format via 'PNG image', but leaves file_path, output_path, bg_color, dark_mode, and layout_name semantics entirely to the schema's bare property names and defaults.

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 ('Render'), a specific resource ('DXF CAD drawing'), and a concrete output ('high-resolution PNG image'). The PNG format clearly distinguishes this tool from sibling export tools such as export_drawing_to_pdf and export_drawing_to_svg.

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 intended use case—rendering a DXF drawing as a raster PNG—is implied by the description and tool name. However, there is no explicit when-to-use/when-not-to-use guidance or comparison with sibling export tools, so the agent must infer the selection logic.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that a drawing is rendered to SVG, but it does not explain whether the tool writes to output_path, returns SVG content, or has side effects. The behavior around output_path defaulting to null is left entirely to inference.

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 with no filler, and it front-loads the core action and output format. It is appropriately concise, though that brevity comes at the cost of behavioral and parameter detail.

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

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

An output schema exists, so return-value documentation is not strictly needed, but the description remains incomplete for a five-parameter tool with no annotations. It does not explain parameter semantics, output behavior, or when to choose this sibling over PDF/PNG exports.

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

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

Schema description coverage is 0%, and the description does not compensate by explaining any of the five parameters. While parameter names like bg_color and dark_mode are suggestive, nothing clarifies semantic details such as how layout_name selects a layout or what happens when output_path is null.

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 an action: render a DXF CAD drawing to SVG format. It adds the vector and browser-viewing context, which helps distinguish it from raster exports like export_drawing_to_png. However, it does not explicitly contrast with export_drawing_to_pdf, which is also a vector-format sibling.

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

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

The description provides no explicit guidance on when to use SVG versus PDF or PNG exports. 'Crisp browser viewing' hints at a use case, but there is no mention of alternatives, exclusions, or conditions favoring this tool.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the extraction scope and output fields, but it does not clarify whether block references or layouts are traversed, whether the layer parameter filters results, or whether the operation is strictly read-only.

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

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

A single concise sentence that front-loads the action and scope with no fluff. It is efficient, though it sacrifices important parameter and usage detail.

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

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

The output schema may cover return values, but the input side is under-specified: the optional layer parameter and required file_path are absent from the description. Without annotations or parameter descriptions, an agent faces ambiguity about how to invoke the tool correctly.

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

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

The input schema has 0% description coverage and the description does not mention either parameter. An agent cannot learn that file_path is the drawing to read or that layer optionally filters extracted text entities; the description adds no 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 names a specific action and resource: extracting all TEXT & MTEXT annotations, notes, and labels. It also lists the exact output attributes (coordinates, heights, rotations, layers), which clearly distinguishes this from general sibling tools like query_drawing_entities.

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 guidance on when to choose this tool versus query_drawing_entities, list_blocks, or other siblings. The usage context is implied by the name but not stated, and there are no exclusions or alternative routes.

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

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

Annotations are absent, so the description must disclose behavior but only says a file is generated. It does not state whether the tool writes to output_path, returns the LISP code, validates the template/custom code, or what happens when output_path is null.

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 compact, front-loaded clauses with no filler. The template_type hint is useful, but the definition is so short that conciseness edges into under-specification.

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

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

For a tool with five parameters and no annotations, the description is incomplete: required routine_name and output path behavior are missing, and the output schema is the only source of return information. It is enough to identify purpose, but not to invoke correctly with confidence.

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

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

Description adds meaning beyond the schema for template_type by enumerating accepted values and linking None to custom_lisp_code. However, it leaves routine_name (required), parameters, and output_path semantically unexplained, and schema coverage is 0%.

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

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

States a specific action and artifact: generates an AutoLISP (.lsp) routine file, which differentiates it from the sibling generate_autocad_scr. It is clear but does not explicitly contrast itself with sibling tools or explain what kind of routines it supports beyond the template_type hint.

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

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

Provides no guidance about when to use this tool rather than generate_autocad_scr or other generation/export siblings. The template_type list implies some use cases, but no conditions, prerequisites, or exclusions are stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the tool generates a .scr file and does not disclose side effects, such as whether existing files are overwritten, whether commands are validated, or whether the file is written locally. This is minimal behavioral transparency.

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 words. It immediately identifies the deliverable and the purpose, making it easy to parse.

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

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

The tool has three parameters, no annotations, and no description-level parameter coverage, making the definition incomplete for reliable invocation. While an output schema exists, the description still omits key context such as how commands are encoded in the .scr file, whether the output path should include the .scr extension, and what happens with the comment parameter.

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

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

Schema description coverage is 0% and the description adds no parameter-level clarification. The meaning of 'commands', 'output_path', and 'comment' is left entirely to the schema's field names, with no guidance on command formatting, file extension handling, or path conventions.

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 ('Generate') with a specific resource ('AutoCAD Script file (.scr)') and names the use case ('batch automation inside AutoCAD'). This clearly distinguishes it from the sibling tools, which are query/export operations rather than script generation.

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 by stating the tool is for 'batch automation inside AutoCAD,' which implies when to use it. It does not explicitly name alternatives or when-not conditions, but the sibling tool names (list_blocks, export_drawing_to_png, etc.) make alternative purposes obvious.

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

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

No annotations are provided, so the description carries the full burden. It states what it lists but doesn't disclose behavioral details like whether it returns aggregated counts across the whole drawing, whether it scans modelspace only (it does say 'in modelspace', which is a useful scoping detail), or what happens if the file_path is invalid. The output schema exists, which helps, but the description adds limited behavioral context beyond the basic call.

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

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

The description is a single concise sentence that front-loads the primary action and result. No wasted words, though it could add a hint about file_path format without bloating.

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 a single required parameter and a provided output schema, the description covers the core purpose. It lacks details like file format expectations and edge-case behavior, but for a simple list operation with output schema available, it's fairly complete. The absence of annotations and explicit usage alternatives slightly lowers this from a 5.

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. The description clarifies that file_path refers to a drawing file containing modelspace, but it doesn't specify the format, whether it's a DXF/DWG, or what the expected file extension is. With only one parameter and no enum, a brief format hint would be helpful but isn't present.

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 verb 'List' and the resource 'block definitions', plus the specific output (usage/instance count) in modelspace. It distinguishes from siblings like list_layers and query_drawing_entities by focusing on block definitions and instance counts, though it doesn't explicitly name a sibling.

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

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

The description implies usage: call this tool to get block definitions and their instance counts. It doesn't explicitly state when to prefer this over siblings like query_drawing_entities, but the scope (blocks vs entities vs layers) is reasonably clear. No exclusions or alternatives are mentioned, so it's implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden. It accurately indicates a read-only listing operation and enumerates the returned properties, but does not disclose edge cases (e.g., empty drawings, invalid files, or performance behavior). The behavior is straightforward enough that a score of 3 reflects adequate but not deep transparency.

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, efficient sentence that front-loads the core action and lists the output contents in parentheses. Every word contributes meaningful information, with no filler or 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?

Given the tool's low complexity, one parameter, and an existing output schema that already defines the return structure, the description covers the essential calling context: what the tool does and what data it returns. It omits direct usage guidance, but the operational completeness is strong.

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 file_path parameter has no schema description, so the description must compensate. It does so by establishing that the tool operates on a DXF drawing, implicitly clarifying that file_path is the path to that drawing. While explicit path format details are absent, this is sufficient for a single obvious parameter.

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

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

The description clearly states a specific verb and resource ('List all layers in a DXF drawing') plus the properties returned (name, color, linetype, lineweight, status, entity count). This distinguishes it from sibling tools like list_blocks, which target a different resource type.

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

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

The description gives no explicit guidance on when to prefer this tool over alternatives. Siblings like list_blocks or query_drawing_entities are not mentioned, and no conditions or exclusions are provided. Usage context is only implied by the tool's name and basic function.

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

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

With no annotations provided, the description carries the disclosure burden. It clearly communicates that this is a read-style query operation and specifies the returned data categories: coordinates, dimensions, layers, and properties. It does not discuss pagination or result limits, but the operation's non-destructive nature is strongly implied by 'Query'.

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 purpose and filtering capability are front-loaded, and the return value summary is placed second. Every sentence contributes useful information.

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

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

The description is adequate for selecting the tool and understanding its core behavior, and an output schema exists for return details. However, it leaves gaps around pagination semantics, exact matching behavior for filters, and any file-format assumptions, which matter given five parameters and no annotations.

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

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

Schema description coverage is 0%, so the description must compensate, but it only adds meaning for entity_type and layer. Parameters like file_path, limit, and offset receive no semantic explanation, leaving the agent to infer their roles solely from names and defaults.

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 ('Query') and resource ('entities in the drawing'), and clarifies optional filtering by type and layer. It also distinguishes itself from siblings like list_layers and list_blocks by covering arbitrary entity types and returning geometric/property data.

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

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

The description makes the usage context clear: use this when you need drawing entities filtered by type/layer and their coordinates or properties. It does not explicitly name alternatives or exclusion conditions, but the context is strong enough for an agent to select it over obvious siblings.

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

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

No annotations are provided, so the description carries the full disclosure burden. It clearly frames the operation as read-only ('Get') and lists the exact output fields. It does not cover error behavior or file-path requirements, but for a simple summary tool this is reasonably transparent.

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 compact sentences: the first states the core purpose, the second gives a concrete return list. No filler, no repetition of schema information, and every sentence contributes value.

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

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

For a one-parameter read-only tool, the description lists the output categories and is therefore usable. However, with no annotations and no parameter documentation, it leaves gaps around when to choose this tool versus siblings and what exactly file_path must point to. The output schema exists but is not shown, so the description remains the only explanatory source.

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

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

Schema description coverage is 0% and the only parameter file_path has no description. The tool description implies the path refers to a DXF CAD drawing, but it does not add explicit parameter semantics such as path format, file type requirements, or accessibility expectations. The description does not compensate for the empty schema.

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

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

States a specific action ('Get') and resource ('a comprehensive high-level summary of a DXF CAD drawing'), and enumerates the returned contents (version, units, counts, entity breakdown, bounding box). This clearly distinguishes it from sibling tools that focus on specific details like blocks, layers, or entities.

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 when a high-level overview is needed, but it does not explicitly say when to use this tool instead of siblings such as list_layers or query_drawing_entities. No exclusions or alternative tool references are provided.

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