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 thoroughly covers side effects: saving to assets/library/<categoria>/<nombre>.dwg, indexing, the origen transformation with real-world rationale, rotation correction with an example, and overwrite behavior requiring confirm=true. This is exceptionally transparent for an unannotated 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?

The description is dense and front-loaded with the core action, then provides necessary parameter explanations. It is somewhat long and runs as a single paragraph, but every sentence contributes useful information, so it remains reasonably concise for a complex 7-parameter tool.

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

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

Despite lacking annotations and schema descriptions, the description is complete for the tool's complexity: it covers the target path, indexing side effect, parameter selection, transformations, and overwrite semantics. The output schema exists, so not detailing return values is acceptable. It gives the agent enough to invoke the tool correctly in realistic scenarios.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. It explains handles vs block, each origen value ('min', 'centro', 'dejar'), rotation with the 357.588/2.412 example, confirm's overwrite role, and location-implied nombre/categoria. All parameter semantics are meaningfully covered beyond the bare 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 opens with a specific verb+resource: 'Guarda un objeto del dibujo activo como pieza propia de la biblioteca' and even gives the exact storage path. It clearly differentiates this tool from siblings like draw_from_library or index_library by framing it as the way to add new assets without a catalog.

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 explicitly states when this tool is appropriate ('Es la via para sumar assets nuevos... sin pasar por ningun catalogo') and gives concrete selection guidance (handles= vs block=, and 'Si es un bloque conviene block='). It does not explicitly contrast with every sibling tool, but the practical usage context is clear.

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 discloses important behavior: without confirm=true it returns a PLAN (dry-run). It also explains the layer remapping purpose. Missing details like whether the operation is reversible or requires an active drawing, but the confirm behavior is a significant disclosure.

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

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

Three sentences, front-loaded with the core function. It uses domain-specific shorthand (AUX -> ZD-*) but stays concise. Slightly dense but no wasted words.

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 an output schema exists, the description doesn't need to detail return values. It covers the main use case, the confirm behavior, and the key parameter target_layer. For a 10-parameter tool, it provides enough context for an agent to decide when to use it, though some parameter semantics remain vague.

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

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

Schema coverage is 0%, so the description must compensate. It explains target_layer (AUX -> ZD-* remapping) and confirm (PLAN vs execution), but dx, dy, rotation, handles, create_layer, and other parameters are not described. Some are inferable from names, but others like create_layer and type remain unclear.

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 copies entities with displacement, optional rotation, and layer remapping. It gives a concrete use case ('copiar un bano y ajustarlo') which distinguishes it from siblings like transform_entities that likely modify in place.

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 provides specific context: this is the way to copy a bathroom base for adjustment, and target_layer handles AUX -> ZD-* remapping from catalog to production. However, it does not explicitly mention when to prefer alternatives like transform_entities or insert_block.

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 transparency burden. It discloses that the drawing is temporary and not persisted to disk until save_drawing is called, which is key behavioral information. It does not mention potential side effects like becoming the active drawing, but the core behavior is well covered.

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

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

The description is two short sentences, front-loaded with the main action, and every sentence adds value. The note about save_drawing is essential and succinct.

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 tool with an output schema, the description covers the temporary nature and save requirement. However, the unexplained 'name' parameter leaves a gap in the tool's usage contract. Since the tool is simple and the query about the name is minor, completeness is adequate but not 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?

The input schema has one optional parameter 'name' with a default, but no schema description and the tool description does not mention this parameter at all. With schema coverage at 0%, the description needed to explain the purpose of 'name' (presumably a drawing name), and it fails to do so, leaving the agent to guess.

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 a new, empty drawing ('Crea un dibujo nuevo y vacio'), which is a specific verb+resource with the scope 'nuevo y vacio' distinguishing it from open_drawing, read_drawing, or create_working_copy. It also notes the temporary nature, adding further specificity.

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 usage context by explaining the drawing is temporary and must be saved with save_drawing(path). This implies when to use the tool (creating a new drawing) and directs the user to a follow-up action, though it does not explicitly exclude alternatives like open_drawing.

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

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

With no annotations provided, the description carries full burden. It discloses that the copy is at filesystem level and that the original is not opened in write mode, which are important safety behaviors. It does not cover what happens if the destination file exists or verify write failures, but for a copy tool this is reasonable disclosure.

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

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

The description is compact and front-loaded: the first sentence states the core purpose, and subsequent sentences add essential context. There is no filler or redundancy, every sentence 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?

The tool is simple (2 optional parameters) and an output schema exists, which reduces the need for return-value details. The description covers the purpose, mandatory usage, and path default, but leaves the suffix parameter unaddressed. Still, for a safety-oriented copy tool, it is sufficiently complete to guide correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'path' parameter by noting that without it the active drawing is used, which adds meaningful context. However, the 'suffix' parameter is completely unexplained, leaving a gap 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 states a specific action: 'Duplica un DWG en disco' (duplicates a DWG on disk), and emphasizes the scope 'antes de tocarlo' (before touching it). This distinguishes it from sibling tools like create_drawing, save_drawing, and copy_entities, which operate differently.

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 explicitly says 'Obligatorio antes de cualquier operacion destructiva' (mandatory before any destructive operation), giving a clear when-to-use condition. It also clarifies that without a path it uses the active drawing. However, it does not mention alternatives or when not to use it, so it stops 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly discloses that the tool reports remaining artifacts and that these do not move on their own ('Reporta que artefactos quedan... esos NO se mueven solos'), and that without 'confirm=true' it returns a plan rather than executing. This is substantive, non-obvious behavior that helps the agent predict 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 three sentences, front-loaded with the core purpose, followed by a use-case example, a technical note on the method, and key behavioral caveats. Every sentence contributes meaningful information with no redundancy 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 has an output schema and no annotations, the description covers the essential selection and usage context: what it does, when to use it, the precision method, report behavior, and the confirm/plan mode. It does not detail all parameters (marcar, layer_marca) or error conditions, but the presence of an output schema reduces the need to explain return values. Overall, it is sufficiently complete for an agent to select and invoke the tool effectively.

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 meaning. It clarifies the core geometry parameters (handles as 'conjunto de entidades', esquina as one of NE/NO/SE/SO, ancho/alto as rectangle dimensions) and hints at 'confirm'. However, it does not explain 'marcar' or 'layer_marca', leaving these parameters underspecified. The description adds meaning for the main required parameters but not complete 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 clearly states the tool's function with a specific verb ('Recorta un rectangulo') and resource ('en una esquina de un conjunto de entidades'), and distinguishes it from siblings by specifying the corner-cut scenario. The concrete example ('es un B2 pero hay que sacarle 1x1 porque pasa una columna') further clarifies its unique use case.

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 a clear context for when this tool is appropriate, using an illustrative scenario ('el caso B2...'). It also notes a critical behavioral distinction ('Usa resta booleana nativa... no una aproximacion'), but it does not explicitly name alternative tools or state when not to use it. Thus, it gives clear context without 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?

With no annotations, the description fully discloses critical behaviors: it deliberately ignores world points due to rounding errors, uses library-accurate widths for piezas, warns on depth mismatches, returns exact placement data, and makes no modifications without confirm=true. This is thorough for a tool with no annotation support.

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 dense but every sentence provides essential information: purpose, measurement details, why world points are avoided, library behavior, return value, and dry-run mode. It is well-structured and appropriately sized for the tool's complexity, with no redundant content.

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

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

Given the tool's complexity (6 parameters, no annotations, but has output schema), the description covers most key aspects: what it does, how to measure, why certain parameters exist, return value, and side-effect-free mode. It is missing explicit descriptions of handle_muro and jambas, and does not mention any prerequisites beyond draw_wall, which prevents a perfect score.

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

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

Schema description coverage is 0%, so the description must explain parameters. It clearly explains distancia, ancho, pieza, and confirm (including units and axis measurement). However, handle_muro and jambas are not described; while handle_muro is somewhat guessable, jambas is a boolean whose effect is not explained, leaving a 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 clearly states the tool's function: it opens a real opening in a wall created by draw_wall, specifically to accommodate doors or windows. It uses a specific verb ('abre') and resource ('muro hecho con draw_wall'), and the context distinguishes it from sibling tools like cut_corner or insert_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?

It provides explicit when-to-use context: after drawing a wall, for placing doors/windows. It explains key measurement rules (meters, along the wall axis) and mentions the dry-run mode with confirm=false. However, it does not explicitly mention alternatives or 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?

Without annotations, the description discloses that deletion is irreversible and requires confirmation, which are crucial behavioral traits. It also implies a guarded execution by requiring filters, though it does not describe the exact deletion scope or potential side effects on dependent entities.

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: the first states the action, the second delivers the key safety requirement and prerequisite. No filler words; all information is actionable.

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 5 parameters and no annotations, the description covers the core safety constraints and purpose. However, it omits details on how filters combine (AND/OR), what the output schema returns, and whether it affects child entities. The presence of an output schema may cover return values, but the filter logic remains unspecified.

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

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

The schema provides no parameter descriptions (0% coverage). The description compensates by stating that at least one filter is required and that confirm must be true, giving meaning to the confirm flag and the collective filter parameters. However, it does not explain the semantics of individual filters like type, block, layer, 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 opens with 'Borra entidades', clearly stating the tool deletes entities. This is a specific verb+resource that matches the tool name and distinguishes it from sibling tools like 'read_drawing' or 'transform_entities', none of which are delete 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 explicitly instructs to 'create_working_copy' before using it and warns that 'esto no se deshace desde el agente' (this cannot be undone from the agent). It also requires 'al menos un filtro y confirm=true', providing clear conditions for use and an explicit prerequisite.

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

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

With no annotations, the description carries full behavioral disclosure burden. It discloses that it doesn't open/copy/close files, accepts B2/B02 interchangeably, inserts without the catalog label, and explains editable and recorte parameters. It also warns that mirroring is a separate block, not xscale=-1.

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 yet dense, using short sentences to convey essential information. It front-loads the main purpose and then addresses important caveats. No redundant language.

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 (12 parameters) and no annotations, the description covers the most important behavioral aspects and usage warnings. The output schema exists, so return values are not needed. Some parameters like layer/create_layer remain underexplained, but overall it is sufficient for an agent to select and invoke 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%, but the description adds meaning to key parameters: tipologia (accepts B2/B02), editable (exploded), recorte_esquina/ancho/alto (corner cutout). It doesn't explain layer, confirm, rotation, create_layer, but the most important parameters are covered.

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

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

The description clearly states the tool inserts a real Azcuy bathroom type at coordinates (x,y) from the local MCP library. It explicitly distinguishes itself from draw_reference, calling itself the only correct way to place a bathroom.

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 explicitly states when to use this tool ('Es la unica forma correcta de poner un bano') and warns against using draw_reference. It also provides guidance on mirroring via separate block types, which helps the agent choose the right approach.

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 only states the geometric definition, not how the tool behaves in practice, such as whether it appends to the current drawing, uses the active layer, or is a mutating operation. This is a significant gap for a drawing 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?

The description is a single concise sentence that conveys the essential information without redundancy. It is appropriately sized for the tool's simplicity.

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?

Despite its simplicity, the description is too terse. It omits any mention of drawing context, coordinate system, or layer behavior, and it does not help differentiate the tool from the many drawing-related siblings. An output schema exists, but the description still lacks critical operational context.

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 explains cx and cy as the center coordinates and radius as the radius, which adds meaning beyond the parameter names. However, the layer parameter is not mentioned, and schema coverage is 0%, so the description only partially compensates for the lack of 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 identifies the tool as creating a circle with a center point and radius. This distinguishes it from sibling tools like draw_line and draw_rectangle, which have different geometry. The verb is implied by the tool name, and the description adds specific geometric parameters.

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. It does not mention prerequisites such as an active drawing, nor does it reference sibling tools or cases where other drawing tools would be more 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?

With no annotations, the description carries the transparency burden. It discloses key behavioral traits: it does not open the source file, rotation is in degrees (float), and explode=true makes the piece editable. These add value beyond the schema, though it does not mention side effects, permissions, or undo 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 concise, with each sentence adding distinct information: main action, a behavioral caveat, and parameter notes. The structure is slightly fragmented with mixed imperative and declarative phrases, but it remains tight and front-loaded with the primary 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?

For a tool with 9 parameters and no annotations, the description provides core insertion context, parameter hints for rotation and explode, and a notable behavior (no source file opening). An output schema may cover return values, but the description still omits explanations for several parameters and does not clarify how this relates to sibling tools.

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 rotation (degrees), explode (editable when true), and implicitly nombre as the library piece name, plus x,y as coordinates. However, it does not explain layer, scale, mirror, or create_layer, leaving nearly half of parameters undocumented in the 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 clearly states the tool inserts a library piece at (x,y), specifying the types included (artefact, plumbing, lighting, installation piece). It distinguishes from siblings by mentioning 'local library' and 'without opening the source file,' which differentiates it from general insert_block or draw_reference tools. However, it does not explicitly name a sibling tool for contrast.

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 use for placing local library fixtures at coordinates, and the phrase 'Sin abrir el archivo de origen' suggests a benefit over alternatives, but it does not explicitly state when to choose this tool over insert_block or draw_reference. There is no exclusion or alternative tool mentioned, leaving the decision to the agent.

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 disclosing behavior, but it only states the geometric operation. It does not mention that this modifies the active drawing, how the optional layer parameter behaves, or what side effects or errors may occur.

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 extremely concise, containing no filler words and front-loading the core concept. It is a fragment rather than a full sentence, but for a simple line-drawing primitive the brevity is acceptable.

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 the essential line-drawing semantics and the output schema exists, so return values do not need explanation. However, it omits the meaning of the `layer` parameter and the requirement of an active drawing context, leaving the tool minimally viable but with clear 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 phrase 'from (x1, y1) to (x2, y2)' adds meaning to four of the five parameters, clarifying that they are endpoint coordinates. However, the optional `layer` parameter receives no explanation, and the schema property descriptions are entirely absent (0% coverage), so the description only partially compensates for the missing schema detail.

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 that the tool creates a line from (x1, y1) to (x2, y2), which clearly identifies the resource and distinguishes it from sibling tools like draw_circle, draw_rectangle, or draw_text. However, it lacks an explicit verb like 'draw' or 'create' in the description itself, relying on the tool name to carry the action.

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, nor does it mention any prerequisites such as an active drawing. There are no exclusions or alternative tool references, so the agent gets no contextual selection help.

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 available, so the description must carry the behavioral disclosure. It states the result (closed polyline) but omits important context such as whether the rectangle is added to an active drawing, how layers are handled, or any side effects. The description is purely definitional with no operational details.

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, compact sentence with no filler. However, its brevity comes at the cost of omitting actionable details, so while it is concise, it undersells the tool's functionality.

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 five parameters, no active drawing context mentioned, and an output schema that is not explained, the description is insufficient for safe and correct use. It does not indicate prerequisites (e.g., an open drawing), coordinate system, or return values, making it inadequate for a complex CAD 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%, yet the description does not explain the meaning of x1, y1, x2, y2 or the optional layer parameter. It mentions 'opposite corners' but does not explicitly map these to the coordinate parameters, leaving the agent to guess the correspondence.

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's function: creating a rectangle as a closed polyline between two opposite corners. This distinguishes it from sibling tools like draw_line or draw_circle, which create different geometry types.

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

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

No guidance is provided about when to use this tool versus alternatives such as draw_room or draw_wall. There are no explicit conditions, exclusions, or references to alternative tools, leaving the agent to infer usage solely from the tool name.

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

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

With no annotations provided, the description carries the full burden and delivers meaningful behavioral details: it materializes as a block, creates the definition once then inserts on subsequent calls, auto-scales by drawing units, and warns that rotation must be a float in degrees. It does not cover all side effects, but the key behavioral traits are well 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 four short sentences, each providing a distinct piece of information: purpose, block behavior, scaling, and a critical rotation warning. It is concise, front-loaded, and contains no filler.

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

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

Despite good behavioral transparency, the description omits usage guidance and parameter semantics for most optional fields, and the existence of an output schema does not compensate for the missing invocation context. An agent would need to guess how scale, label, layer, mirror, and create_layer behave, so the description is not complete for the tool's complexity.

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

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

Schema coverage is 0%, and the description only explains (x, y) coordinates, rotation as float degrees, and implicitly 'name' as the catalog identifier. It leaves label, layer, mirror, create_layer, and importantly the scale parameter's interaction with auto-scaling unexplained, which is a significant gap for a 9-parameter tool.

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

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

The description clearly states the tool's function: drawing a catalog reference as a block, using the specific verb 'Dibuja' and resource 'referencia del catalogo'. It distinguishes itself from other drawing tools by emphasizing catalog references and block/insertion semantics, though it does not directly name sibling alternatives.

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

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

There is no explicit guidance on when to use this tool versus alternatives; sibling tools like insert_block, draw_from_library, or draw_rectangle are never mentioned, and no prerequisites or exclusions are given. The only implied usage is for catalog references, which is weak 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?

With no annotations, the description carries the burden of behavioral disclosure. It reveals that the tool creates a closed polyline with name/area label and that width/height are real project units not rescaled. However, it omits side effects like layer handling, rotation behavior, or failure modes.

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 two sentences: the first front-loads the core purpose and output details, the second adds a critical unit clarification. No redundant words.

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 an output schema, so return values are covered, but the description lacks context for correct invocation: coordinate system, rotation semantics, layer creation behavior, and whether an active drawing is required. Ten parameters demand more explanation than this brief description provides.

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 width/height but leaves x, y, name, layer, rotation, show_area, text_layer, and create_layer entirely unexplained. Only 2 of 10 parameters receive any semantic clarification.

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 'Dibuja' (draws), the resource (room/local outline as a closed polyline), and key details like 'CERRADA' and 'rotulo de nombre y superficie'. This distinguishes it from generic drawing tools like draw_rectangle or draw_line.

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 siblings like draw_wall or draw_rectangle. It neither states prerequisites (e.g., active drawing) nor typical scenarios. Only the unit constraint is mentioned, which is more about semantics than 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?

With no annotations, the description must disclose behavior, but it only mentions position and height. It does not state that this creates a text entity, how it interacts with layers, whether it requires an open drawing, or what the return value is. The behavioral profile is largely opaque.

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, terse phrase with no redundant or irrelevant information. It front-loads the core placement concept, though it sacrifices completeness for brevity.

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 purpose (drawing text in a CAD-like environment), the description is too sparse. It lacks context about coordinate system, layer behavior, units, error conditions, or the effect of the operation. The existence of an output schema does not compensate for the missing operational context.

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 partially compensates by explaining x, y, and height. However, it does not explicitly clarify the 'text' parameter (though implied) and completely omits 'layer'. Units and coordinate system are unaddressed, leaving gaps for parameters beyond the basic ones.

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 'Texto en (x, y) con la altura dada' clearly indicates placement of text at coordinates with a specified height, distinguishing it from other drawing tools like draw_line or draw_circle. However, it lacks an explicit action verb such as 'draws' or 'creates', making it slightly less direct.

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 draw_line or draw_rectangle. There is no mention of prerequisites (e.g., active drawing) or typical use cases, leaving the agent without context for tool selection.

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

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

With no annotations, the description carries the behavioral disclosure: it draws four parallel lines without caps, defines thickness by tipo, notes unit conventions, and records the axis in XData for later use by cut_opening. This is substantial context, though it doesn't cover every side effect or requirement.

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 dense yet well organized, with each sentence adding unique value: purpose, exclusions, structural details, units, and XData integration. There is 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?

For a 14-parameter tool with no annotations and no schema descriptions, the description covers the core drawing behavior, unit conventions, and integration with cut_opening. However, some auxiliary parameters remain undocumented, so it is not fully 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 main source. It explains tipo values and resulting thickness, espesor/revoque units, and puntos behavior, but leaves cerrado, create_layer, terminaciones, and layer_terminaciones unexplained. This is helpful but incomplete for 14 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 opens with 'Dibuja un MURO de punta a punta' - a specific verb + resource - and immediately distinguishes itself from draw_room and library blocks. It clearly scopes the tool as drawing real-thickness walls with two layers.

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 explicitly states what the tool is not ('No es draw_room... ni una pieza de biblioteca'), naming sibling alternatives, and explains that puntos mode draws full runs with mitered corners. It also ties to cut_opening via XData, giving a concrete downstream 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?

With no annotations, the description carries the full burden of behavioral disclosure. It discloses that the tool uses a crossing window and filters within AutoCAD, and that results are ordered by distance. However, it does not state whether the operation is read-only, mention permissions, or clarify what 'filtered within AutoCAD' entails, leaving gaps.

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 at three sentences, front-loading the core purpose and adding relevant context about interference detection and AutoCAD filtering. There is no fluff, though it could be slightly more structured with parameter mentions.

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 presence of an output schema, return values are covered, but the description does not explain the 7 parameters, usage prerequisites, or how the crossing window filtering behaves in practice. It is adequate for a simple query but incomplete for the tool's actual complexity.

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

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

Schema description coverage is 0%, so the description should explain parameter meanings. It mentions 'point' and 'area' but does not map these to x, y, radius, or explain the optional type, block, layer, or limit parameters. The added value is minimal 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 that the tool returns entities near a point, ordered by distance, and specifies its role as an interference detection engine for columns, beams, passes, and slabs. This specific verb+resource combination distinguishes it from sibling tools like query_entities or locate_in_polygons.

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 context by stating it is the interference detection engine, implying use cases like detecting overlapping structural elements. However, it does not explicitly mention when to use it over alternatives or when not to use it, so guidance remains 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that the tool 'Entra en XREF' (enters XREFs), filters by tag signature because it is the 'unico confiable' for dynamic blocks, has a time budget ('presupuesto de tiempo'), and returns 'parcial=true' on timeout, warning that the table is 'INCOMPLETA' and should not be treated as a total computation. This is exceptional transparency about side effects and edge cases.

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 four sentences, front-loaded with the main purpose, then adding conditional usage and a critical warning about partial results. Every sentence carries information and no fluff. It is concise yet dense with actionable guidance.

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

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

Given the tool's complexity (9 parameters, no annotations, no schema descriptions), the description covers the essential behavioral context: what it extracts, the XREF scope, the tag filtering rationale, the zone-based usage, and the time-budget behavior with partial results. The output schema exists, so not detailing the return table is acceptable. This description is robust enough for an agent to select and 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?

With zero schema description coverage, the description compensates well for key parameters: it explains near_x/near_y/radius as 'para una zona puntual' and segundos as the time budget with a default of 25. It also explains tag as filtering by tag signature. However, it does not explain block, layer, limit, or max_depth, which remain undocumented despite 0% coverage, so it is not fully complete.

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 'Extrae atributos de bloque en formato tabla, listo para volcar a planilla' (extracts block attributes in table format, ready to dump to spreadsheet). It mentions specific use cases (carpinterias, locales, plenos, terminaciones, tomas) and distinguishes itself from siblings by noting it enters XREFs and filters by tag signature, which is unique among tools like inspect_block or query_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 provides conditional guidance: 'Si el computo es de una zona puntual (una unidad, un baño), pasa near_x/near_y/radius' and 'Para un archivo entero subi segundos.' It clearly states when to use the near parameters and how to adjust the time budget, but it does not explicitly mention alternatives or when-not-to-use cases, so it lacks the full 'when/when-not/alternatives' structure.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the search is case-insensitive, uses substring matching, sorts by modification date, and is restricted to allowed roots. This adds meaningful context beyond a simple 'find' operation, though it doesn't cover every behavior (e.g., recursion, limit semantics).

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

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

The description is three concise sentences, front-loaded with the primary action and scope. Every sentence adds value: the search criteria, the sorting behavior, and the root restriction. 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?

The description covers the core purpose and key behaviors, and an output schema exists, so return values may be documented elsewhere. However, it omits some operational details like whether the search is recursive, the effect of the 'limit' parameter, and what happens if 'root' is empty. For a read-only search tool, it is adequate but has clear 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?

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only mentions 'name' (via 'por nombre') and 'root' (via AUTOBAT_SEARCH_ROOTS), but does not explain the 'limit' or 'extension' parameters. This is insufficient for a 4-parameter tool with no schema descriptions.

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

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

The description clearly states the tool's function: searching for DWG/DXF files on disk by name (substring, case-insensitive). It specifies the verb 'Busca' (searches), the resource (archivos DWG/DXF en el disco), and the scope (by name), distinguishing it from sibling tools like find_nested.

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 you need to locate a drawing file by name), but it does not explicitly compare it to alternatives or state when not to use it. There is no mention of sibling tools or exclusions, so usage guidance is only implied.

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 fully discloses behavior: returns composed world coordinates, rotation, scale, and mirror flag; explains that filters apply after traversal and do not prune; reveals the time budget (segundos default 25) and the partial=true fallback, including that partial results are incomplete. This is excellent 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 efficiently structured in three short paragraphs, each with a distinct purpose: purpose, usage/performance, and timeout behavior. Every sentence carries value, with clear emphasis (PASA, NO) and no filler.

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

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

For a complex tool with 13 parameters and an output schema, the description covers core functionality, usage recommendations, performance characteristics, and partial-result semantics. It does not explain every parameter, but the presence of an output schema reduces the need to describe return values, making this sufficiently complete for most use cases.

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?

Although schema coverage is 0%, the description adds meaning to near_x/near_y/radius (spatial pruning), segundos (time budget), and implies layer/type filters exist but do not reduce traversal. However, with 13 parameters, many remain unexplained (e.g., limit, detail, max_depth, text_contains, attribute_value), so the description only partially compensates 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 clearly states the tool searches inside XREF and nested blocks, returning composed world coordinates, rotation, scale, and mirror state. It explicitly claims to be the only way to locate entities two levels deep, distinguishing it from sibling search 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?

Provides explicit guidance to pass near_x/near_y/radius when location is known, explains that layer/type filters do not reduce traversal, and warns about performance without a spatial window. It clearly implies when to use this tool (for nested content) but does not explicitly name alternatives or exclusions, 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?

With no annotations, the description must convey behavior. It discloses that the listing is raw and limited to the first entities, but does not specify criteria, quantity, or return format. The read-only nature isn't explicitly stated, though it's implied by 'listing'.

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; the first states the purpose, the second gives usage guidance. No filler.

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

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

The description adequately covers a simple no-parameter tool, but leaves ambiguity about how many 'first' entities are returned and what information is included. The presence of an output schema reduces the need to describe return values.

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 zero parameters, the schema fully covers all inputs. No additional parameter explanation is 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?

The description clearly states the tool's function: a raw listing of the first entities in modelspace. It distinguishes itself from read_drawing by positioning itself as a partial, quick 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?

It explicitly advises to use read_drawing for a complete understanding, implying this tool is for quick raw previews. This provides a clear when-to-use vs alternative.

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 clearly states the tool does not insert the block, only copies the definition, and references the source file. However, it does not mention potential side effects like name conflicts or dependencies, so it is not fully exhaustive but provides solid 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 concise, with three sentences that front-load the core function, then add real-world context, then give a follow-up instruction. Every sentence earns its place with no filler.

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

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

For a tool with no annotations and three parameters, the description gives sufficient context for selection: it explains the core mechanism, the source location, and the next step. The presence of an output schema covers return values. However, it lacks detail on the 'rename' parameter and conflict behavior, but overall it is adequate for an agent to choose and invoke the tool.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly refers to source and name ('desde otro DWG', 'definicion de un bloque'), but completely omits the 'rename' parameter and provides no details on parameter formats or defaults. This fails to adequately explain the three 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 clearly states the tool imports a block definition from another DWG into the active drawing without inserting it, using a specific verb ('Trae') and resource ('definicion de un bloque'). It distinguishes itself from insert_block by explicitly noting it does not insert and that insertion is a separate step.

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 explicit context for when to use this tool: for the real Azcuy bathroom typologies stored in SR-TIPOLOGIAS BAÑOS.dwg, and instructs to position the block afterwards with insert_block. This provides clear usage guidance and an alternative follow-up 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 full burden and delivers: incremental by mtime comparison, saves measurements/layers/weight, removes missing entries, and explains side-effects of purgar=true (cleans in place, slow, thins symbol tables). This is rich behavioral disclosure.

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

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

Two dense sentences with no wasted words; front-loads the main action. Slightly long but every clause adds information about purpose, timing, incremental behavior, or the purge mode.

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 and lack of annotations, the description covers what it reindexes, when to run it, incremental behavior, and the purge option. An output schema exists, so return values are not needed. Minor gap: no mention of required permissions or more detailed side effects.

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

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

The description explains 'purgar=true' explicitly and connects 'categoria' to reading the folder structure, but leaves 'forzar' undefined. With 0% schema description coverage, the description partially compensates but not fully for all three 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 opens with a specific verb+resource: 'Reindexa assets/library/ leyendo la CARPETA como categoria', clearly distinguishing from siblings like list_library or add_to_library. It also explains the incremental reindexing scope and what data is stored.

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 states when to run: 'despues de mover, agregar o borrar DWG a mano' (after manually moving/adding/deleting DWGs). It also contrasts the normal incremental mode with the slow one-time purge mode, giving clear usage context and when to use which.

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 transparency burden and adds meaningful behavior: it discloses support for negative scale, explains that xscale=-1 mirrors units on the same definition, and warns that mirrored bathroom blocks are separate entities (A01 vs A01e). It stops short of covering other side effects or error cases, but the information provided is useful and non-obvious.

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, front-loaded with the main purpose, and the additional caveat about mirroring is relevant. It is slightly conversational with 'Ojo', but every sentence adds value and it remains compact.

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 9 parameters, zero schema descriptions, and no annotations, the description is incomplete. It explains one behavior (negative scale mirroring) but omits how other parameters interact, what happens when the block is not defined, or what the output schema returns. The presence of an output schema reduces the need to explain return values, but the tool still needs more behavioral coverage.

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 adds semantics for xscale (negative scale implies mirroring) but leaves most of the 9 parameters (layer, rotation, mirror, create_layer, etc.) unexplained. It also creates ambiguity by mentioning xscale=-1 for mirroring while a mirror boolean parameter exists, without clarifying the relationship.

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 action: 'Inserta un bloque ya definido en el dibujo' (inserts an already defined block in the drawing). It explicitly uses a specific verb and resource, and the phrase 'ya definido' distinguishes this from related tools like import_block or draw_from_library.

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 implies usage for inserting pre-defined blocks, and the caveat about bathroom typology provides context for a specific case. However, it does not explicitly state when to prefer this tool over alternatives or mention exclusions such as 'use import_block for new blocks'.

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?

Given no annotations, the description carries the full burden. It clearly indicates a non-mutating inspection ('Radiografia... sin insertarla') and lists the analysis types (layers, nested blocks, bbox, residues). However, it doesn't explicitly state that the tool is read-only or describe any side effects beyond insertion.

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 dense sentence that front-loads the core purpose and follows with a structured list of outputs. No filler or redundancy, making it efficient despite its length.

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 and an output schema, and the description explains what the tool returns but not how to use its parameters. The lack of parameter guidance and explicit usage conditions make it incomplete for complex invocation, but the core purpose is well-articulated.

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 mentions 'bloque' and 'definicion' but never explains the 'name' parameter (presumably the block definition name) or the optional 'limit' and 'list_entities' parameters. With 0% schema coverage, the description should define these, but it doesn't, leaving invocation ambiguous.

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

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

The description begins with 'Radiografia de una definicion de bloque sin insertarla', which clearly identifies an inspection action on block definitions without insertion. It enumerates specific outputs (layers, nested blocks, bounding box, residual bindings), distinguishing it from siblings like insert_block or list_blocks.

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 'sin insertarla' implies the tool is for pre-insertion analysis, providing clear context without explicitly naming alternatives. It doesn't state when not to use it or identify sibling alternatives, but the non-insertion caveat gives sufficient guidance for an agent to select it over insert_block or list_blocks.

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. It discloses that the operation reads from a local index, does not interact with AutoCAD, and is instantaneous, indicating a safe, read-only behavior. This adds useful context beyond a simple 'list' description, but could further detail output ordering 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 three concise sentences that front-load the primary purpose, then provide behavioral traits, and finally explain the parameter. Every sentence adds value, with 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?

The description covers purpose, behavior, and parameter semantics sufficiently for a simple list tool. Since an output schema is present, it need not elaborate on return values. It could explicitly state that 'familia' is an optional filter, but this is strongly implied by the context and 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?

The input schema has one parameter 'familia' with 0% coverage and no enums. The description compensates by explicitly defining the possible values: A (Master Suite), B (Suite), C (Toilette), D (Servicio), giving the parameter actionable meaning.

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

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

The description clearly states the tool's function: it lists the 70 bathroom typologies of Azcuy, with specific catalog ranges (A01..D09 and mirrored 'e'), and includes content details (program, measurements, fixtures). It distinguishes itself from sibling drawing tools by noting it reads from a local index, does not touch AutoCAD, and is instantaneous.

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 context: it's a fast, local catalog listing that avoids AutoCAD operations. However, it does not explicitly mention when to use this over other tools (e.g., draw_bathroom or list_library), nor does it state any exclusions 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?

The description discloses a notable behavioral trait: enabling count_inserts triggers a full modelspace scan, which is a performance cost. However, since there are no annotations, the description carries the full burden of conveying safety and side effects; it does not explicitly state that the operation is read-only or non-destructive. It omits other behavioral details such as whether results are sorted or whether hidden/anonymous blocks are excluded by default.

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

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

The description is two sentences long, front-loaded with the core purpose, and adds a relevant performance caveat. Every word earns its place; there is no redundant phrasing 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?

Although an output schema exists (so return values are covered), the description lacks important context: it does not mention prerequisites (e.g., an active drawing), how filtering works, or what 'anonymous' blocks are. The tool has 4 parameters with 0% schema descriptions, and only one is addressed. Overall, the description is too sparse for a tool that lists block definitions with multiple filtering 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?

Schema description coverage is 0%, so the description must compensate. It only explains count_inserts (the full-sweep cost and its purpose), while limit, filter, and include_anonymous are left completely undocumented. The mention of XREF and path hints at filter usage but is not tied explicitly to any parameter. This is insufficient for 4 parameters with no schema descriptions.

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

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

The description names the resource (block definitions) and specifies what is reported (XREF status, path, optional insertion counts). Although the verb 'list' is not explicitly repeated, the context makes clear this is a listing operation. It partially differentiates from siblings like inspect_block and list_source_blocks by focusing on definition-level metadata, but it does not explicitly compare with those alternatives.

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 is provided. The performance warning about count_inserts ('cuesta un barrido completo del modelspace') implies that this option should be used sparingly, but there is no mention of when to prefer list_blocks over sibling tools like inspect_block or list_source_blocks. The guidance is limited to one parameter's cost, not the tool's overall 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?

With no annotations, the description carries the burden. It adds useful behavioral details: the filter also matches XREF-renamed layers, and color is authoritative over lineweight for print thickness. However, it does not disclose whether the operation is read-only, how limit behaves, or whether the list is scoped to the active drawing.

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 succinct and front-loaded. The first sentence establishes the core purpose, and the second sentence adds relevant domain insight. No wasted words.

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 list tool with an output schema, the description is reasonably complete. It explains the main output and filter nuance, but it omits details about the limit parameter and does not explicitly state that layers belong to the active drawing. Given the tool's simplicity and output schema, this is acceptable.

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 schema provides no descriptions for 'limit' or 'filter'. The description partially compensates by explaining that the filter matches layer names including XREF-renamed ones, but it does not mention the 'limit' parameter at all. With 0% schema coverage, more parameter guidance would be beneficial.

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 this tool returns a layer table with ACI color, line type, and state. It identifies the resource (layers) and the specific fields, effectively distinguishing it from sibling tools like list_blocks or list_references.

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 rather than explicitly stated. The description provides domain context (color importance via CTB) and filter behavior for XREF-renamed layers, but it does not explicitly explain when to use this tool versus alternatives or mention 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?

With no annotations, the description carries the burden. It discloses that the operation is non-destructive ('No toca AutoCAD') and defines the library structure (DWG=piece, folder=category). However, it does not describe return volume, pagination, or how limit/filter parameters affect 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 concise at three short sentences and front-loads the purpose. The category enumeration is a bit dense but still readable; each sentence adds 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?

The tool has 3 undocumented parameters and no annotations, so the description must explain how to invoke it properly. It explains the domain model but leaves the filtering and limiting parameters unexplained; the output schema covers return shape, but the input semantics are incomplete.

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

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

Schema coverage is 0%, so the description must compensate. It gives a list of possible categories, which informs the `categoria` parameter, but provides no guidance on `filtro` or `limit`. The description does not explicitly connect the listed folders to the parameter names.

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

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

The description clearly states the tool lists the contents of the local MCP library with real measurements ('Que hay en la biblioteca local del MCP, con medidas reales'). It distinguishes itself from drawing tools by explicitly noting it does not touch AutoCAD ('No toca AutoCAD').

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 provides clear context that this tool is for library inspection rather than drawing manipulation, and explains the folder-as-category mapping. However, it does not explicitly name alternative tools or state 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only repeats the basic function implied by the name and does not reveal any side effects, error conditions, session requirements, or whether the operation is 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?

The description is very brief and front-loaded, but it is in Spanish and contains an ambiguous term ('activo'). While conciseness is a positive, the lack of clarity undermines structure, making it less effective than a well-worded English 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?

An output schema is present, so return values need not be described, but the description is still inadequate. With no annotations, no usage guidance, and an ambiguous phrase, the agent lacks sufficient context to fully understand the tool's purpose, especially the meaning of 'activo' and its role in the output.

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, and the schema coverage is trivially 100%. With no parameters to describe, the description does not need to explain parameter usage, matching the baseline of 4 for parameter-less tools.

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 the tool lists open drawings in AutoCAD and indicates the active one, which is a specific operation. However, it is written in Spanish while the tool name is English, and 'activo' is ambiguous (could mean 'active' or 'asset'), reducing clarity. It does distinguish from sibling tools like open_drawing by implying a listing operation.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_drawing_info or open_drawing. It does not mention any context, prerequisites, or exclusions, leaving the agent to infer usage solely from the name.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds valuable context by specifying the catalog contains conventional symbols, not actual geometry, and lists exclusions (bathroom typologies, unit blocks). This goes beyond basic listing but does not mention filter behavior or output details.

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 two concise sentences, front-loaded with the purpose and then adding a caveat and cross-reference. No wasted words, making it highly efficient and well-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?

Given the tool's simplicity, the output schema exists, and the description covers the core context—what the catalog contains and what it excludes. The main gap is the lack of explicit parameter behavior, but overall it provides sufficient context for an agent to select and 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 schema has one optional parameter 'categoria' with default '', and schema description coverage is 0%. The description mentions categories (electrical, sanitary, equipment) which likely map to valid values, but it does not explicitly explain that the parameter filters results or what the default behavior is. It provides partial meaning but lacks clarity.

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 lists a catalog of drawable references (electrical symbols, sanitary artifacts, equipment). It explicitly differentiates itself from import_block by noting that real Azcuy geometry is not included, making the purpose precise and distinct from 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 explicit usage guidance: it states that the real Azcuy geometry is not here and is brought with import_block, providing an alternative. This tells the user when to use this tool (for conventional symbols) and when to use another (for Azcuy geometry).

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 and does provide a key behavioral trait: 'sin importar nada' explicitly states it does not import anything, implying a non-mutating, read-only operation. It lacks details about error handling or whether the source must be open, but the core safety disclosure 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 two short, front-loaded sentences with no filler. Each sentence adds value: the first states the object and non-import behavior, the second gives the practical use case. It is appropriately sized for a simple listing tool.

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

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

Given the tool's low complexity and the presence of an output schema, the description is minimally adequate: it clarifies the overall purpose and non-import behavior. However, the lack of parameter semantics for 'limit' and 'filter' means an agent cannot fully infer correct invocation from the 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 0%, so the description must compensate. It only vaguely relates 'source' to 'OTRO archivo' and provides no explanation for 'limit' or 'filter'. The defaults of 400 and '' are not contextualized, leaving most parameters semantically unexplained.

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 lists block names available in another file ('Nombres de bloque disponibles en OTRO archivo') and explicitly distinguishes it from importing or bringing blocks. This verb+resource+scope framing differentiates it from sibling tools like list_blocks and import_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?

'Sirve para resolver un nombre antes de traerlo' gives explicit when-to-use context: resolve a block name before importing it. The mention of 'OTRO archivo' implies it is for external sources, though it does not explicitly name alternatives or exclusions, so it falls just 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?

With no annotations, the description carries the full burden. It discloses a significant non-obvious behavior: it does not trust the Closed flag and instead calculates ring closure, reporting the gap. This goes beyond what the schema shows. It could mention side effects, but given its analytical nature and presence of an output schema, this is adequate.

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 two sentences and front-loads the core function. The parenthetical example (7 of 25 polylines closed) is useful but slightly verbose. Overall, it is concise and well-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?

The description covers the core behavior and unique logic, but with 0% parameter coverage and 5 parameters, it is incomplete for correct invocation. The output schema mitigates the need to describe return values, but key parameter semantics are still missing.

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

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

Schema description coverage is 0%, so the description must compensate. It only hints at polygon_layer and point_layer through 'poligonos' and 'etiquetas', but does not explain limit, min_area, point_type, or their defaults. This leaves users guessing about key 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 ('Cruza' - crosses/intersects) and resource (polygons with labels). It clearly differentiates itself from sibling tools like 'entities_near' or 'extract_attributes' by focusing on polygon-label spatial intersection. The phrase 'Motor de la auditoria de superficies' adds domain context.

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

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

The description provides clear context: it is the engine for surface audit, implying when to use it. However, it does not explicitly mention alternatives or when not to use it. It gives enough context to infer the primary use case but lacks exclusion criteria.

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

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

No annotations are provided, so the description carries full behavioral burden. It discloses the read_only=True default and the safety rationale (accidental write mode is irreversible), plus the behavior when the drawing is already open. This goes beyond basic 'opens' without being exhaustive.

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

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

Three sentences, front-loaded with the main purpose. Every sentence adds valuable information: activation, path flexibility, read_only risk, and already-open behavior. No filler.

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

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

Given an output schema exists and no annotations, the description covers all essential aspects for an open operation: activation, path handling, read_only safety, and how it behaves when the file is already open. It is well-rounded for its complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to path ('full path or just name') and read_only (default true and why), directly addressing the two parameters in 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 'Abre un DWG/DXF y lo deja activo'—a specific action on a specific resource. It also distinguishes itself from siblings like read_drawing or create_drawing by emphasizing it opens and activates the drawing, not merely reads or creates.

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

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

Provides clear context: accepts full path or just name, read_only defaults to true, and if already open it activates it. However, it does not explicitly mention alternatives like set_active_drawing for pure activation, so 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?

No annotations are present, so the description carries the full burden. It discloses that the tool checks AutoCAD responsiveness and which document is active, implying a read-only health check. However, it does not explicitly state that it has no side effects or what happens when AutoCAD is unresponsive, which would be useful additional 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 extremely concise, with two short sentences that immediately convey the purpose. There is no unnecessary verbosity or repetition, making it highly 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?

The tool is simple with no parameters, and an output schema is present to document return values. The description sufficiently explains the health-check purpose, making it complete for this low-complexity 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?

The tool has zero parameters and the schema already documents this with 100% coverage. Since there are no parameters to explain, the description adds no parameter semantics, which is appropriate for this simple tool.

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

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

The description clearly states this is a health check that verifies AutoCAD responsiveness and identifies the active document. It uses a specific verb and resource, distinguishing it from sibling tools that perform drawing 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?

No guidance is provided on when to use this tool versus alternatives. The description merely states what it does, leaving the agent to infer that it should be used as a preliminary connectivity check, but it does not explicitly say so.

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

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

With no annotations provided, the description carries the full burden and delivers substantial transparency: it states the tool is read-only, reveals that Azcuy blocks have geometry up to 186 m from their base point, explains the building frame is rotated 2.41 degrees, and notes conventions are copied from existing instances. It also describes what the return values will include.

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 compact block that front-loads the core purpose, then adds usage prerequisites, the three key problems, return contents, and read-only status. Every sentence provides distinct 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?

It is strong on purpose, usage timing, and behavioral quirks, and it summarizes return contents even though an output schema exists. However, it is incomplete as a standalone spec because all 7 parameters remain undocumented, and with no annotations the agent has no other source for parameter semantics; the complexity of the geometry logic makes this gap significant.

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 7 parameters with 0% description coverage, and the description does not explain any of them. It discusses conceptual terms like block, layer, and scale, but never maps them to parameter names such as near_x, near_y, radius, or reference_block, so an agent cannot determine how to populate the arguments correctly.

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

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

The description clearly states the tool computes where, with which rotation, scale, and layer the next drawing operation should go, inferred from what is already drawn. It distinguishes itself from siblings by explicitly recommending running it before insert_block/draw_bathroom, and it enumerates concrete outputs like anchors, detected rows, free gaps, and a suggested insertion point.

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 an explicit when-to-use instruction: 'Corre esto antes de cualquier insert_block / draw_bathroom sobre un plano existente.' It also explains why it is necessary by listing the three specific placement problems, and the phrase 'sobre un plano existente' implies it is not meant for blank drawings.

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 behavioral disclosure. It reveals the use of AutoCAD SelectionSet (fast), the AND logic, and the limitation of not entering XREF/blocks. This is meaningful behavior, though it doesn't mention side effects (appears read-only) or response structure.

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 front-load the core purpose and then add scope limitations and performance context. No unnecessary words 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?

For a tool with 6 optional parameters, no annotations, and an output schema, the description gives essential scope and speed context but omits parameter semantics and any mention of output format/limits. It is adequate for basic understanding but leaves gaps for correct invocation.

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

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

Schema has 0% parameter description coverage, so the description must compensate, but it only generically mentions filters (AND) without explaining the six parameters (type, block, layer, limit, detail, text_contains). No parameter-specific meaning is added.

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 returns modelspace entities matching filters (AND), using the verb 'query' implied and specific resource 'Entidades del modelspace'. It also distinguishes from sibling find_nested by explicitly excluding XREF/blocks.

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 explicitly says when NOT to use this tool (for XREF/blocks) and points to find_nested as the alternative. It also notes speed in large plans, implying suitability for filtering large drawings, but does not contrast with other siblings like entities_near or list_layers.

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. It discloses that por_capa=true requires a slow COM sweep (tens of seconds), which is a useful performance warning. It also signals a read-only intent via 'LEER ANTES DE ESCRIBIR' and lists the exact data returned. It does not explicitly state 'does not modify the drawing' in a direct sentence, but the read-before-write phrasing implies it. The behavioral context added is valuable.

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: it leads with a clear purpose statement, then adds usage guidance and parameter-specific details. It is a bit verbose, but every sentence adds value (purpose, timing, alternative, performance warning). It is not overly long and avoids unnecessary 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 tool has an output schema, so return values need not be explained. However, with three parameters and 0% schema coverage, the description leaves two parameters undefined, which is a notable completeness gap. It does provide a clear primary use case and an alternative for layer-specific queries, but the missing parameter semantics reduce the overall context. Adequate for the core purpose but not fully complete.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It only explains 'por_capa' ('agrega el conteo por capa') and mentions its performance cost. It does not explain 'max_scan' or 'top_layers' at all, leaving agents without any clue about their meaning or default behavior. This is a significant gap for a tool with three undocumented 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 clearly states the tool provides an 'overview of the active drawing' with units, extension, entity counts, block definitions, and XREFs. It uses a specific verb ('read'/'panorama') and resource ('active drawing'), and distinguishes itself from query_entities by noting it is a global overview. However, it does not explicitly differentiate from the sibling get_drawing_info, which may overlap.

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 explicitly says 'Es el primer paso antes de tocar cualquier plano' (it is the first step before touching any plan), which clearly tells when to use it. It also provides an explicit alternative: 'Para preguntar por una capa puntual usa query_entities(layer=...)' and warns about performance implications when por_capa=true. This is strong contextual 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?

With no annotations, the description carries the full burden. It discloses a key behavioral aspect—empty path triggers Save, provided path triggers SaveAs—which adds value beyond the schema. However, it does not mention overwrite behavior, error conditions (e.g., no active drawing), permissions, or return value, leaving significant behavioral gaps for a write operation.

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

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

The description is exceptionally concise: two short sentences, front-loaded with the primary purpose, followed by a clear rule for the parameter. Every sentence earns its place, and there is no redundant 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 tool's simplicity (one optional parameter) and the presence of an output schema, the description is largely complete. It explains the purpose, the active-drawing dependency, and the parameter behavior. It could be more complete with explicit notes about errors or prerequisites, but these are not critical for this level of complexity.

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

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

Schema coverage is 0% because the schema only lists 'path' with a default of ''. The description fully compensates by explaining the parameter's semantic impact: without a path it performs Save, with a path it performs SaveAs. This is exactly the meaning an agent needs and goes well beyond the minimal 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's function: 'Guarda el dibujo activo' (saves the active drawing). It uses a specific verb ('save') and resource ('active drawing'), and the second sentence distinguishes between saving to the existing path and saving to a new path, differentiating it from sibling tools like create_drawing or open_drawing.

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: it operates on the active drawing. It also gives explicit usage guidance for the path parameter ('Sin path hace Save; con path, SaveAs'), telling when to use each mode. However, it does not explicitly compare with alternative tools or state when not to use this tool, so it misses a full when/when-not structure.

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

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

With no annotations, the description carries full burden and delivers: it discloses a security filter, that modifications require confirm=true, and that SendCommand is asynchronous ('confirma el envio, no el exito'). This is rich behavioral context beyond mere function.

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

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

Three concise sentences in Spanish, front-loaded with purpose and followed by critical usage and behavioral notes. Every sentence adds value with no 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?

For an escape hatch tool with a simple schema and an existing output schema (which likely covers return format), the description covers purpose, usage constraints, and behavioral nuance (async, security filter). It is complete and 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%, but the description compensates by explaining 'command' as accepting commands or AutoLISP, and 'confirm' as mandatory for drawing modifications. While it doesn't detail command string syntax, it covers the essential semantic difference.

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 'manda comandos o AutoLISP a la linea de comandos' (sends commands or AutoLISP to the command line) and uses 'Escotilla de escape' (escape hatch), distinguishing it from all specific drawing tools as a general-purpose command executor. The verb and resource are explicit.

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 'Usala solo para lo que no cubre ninguna tool' (use it only for what no other tool covers), providing direct when-to-use guidance. It also specifies the confirm=true requirement for drawing modifications, an important usage constraint.

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 what the tool does (activates a drawing) but does not explain side effects, what 'active' means, whether other drawings are affected, or what happens if the drawing is not open. This is insufficient for a state-changing operation.

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

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

The description is a single, well-structured sentence that is direct and free of unnecessary words. It effectively conveys the core functionality and parameter semantics.

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 tool with one parameter and an output schema (though not shown), the description covers the basic purpose and parameter semantics. However, it lacks behavioral details such as error handling, prerequisites (drawing must be open), and the exact meaning of 'active', making it only minimally 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?

The input schema only defines 'name' as a string with no description. The tool description adds meaningful context by specifying that the name can be a name or a path, which clarifies the expected input format 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 uses a specific verb ('Activa') and resource ('dibujo ya abierto'), clarifying that it activates an already-open drawing, which distinguishes it from 'open_drawing' that would open a new one. The scope ('por nombre o ruta') further specifies how the target is identified.

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 'ya abierto' clearly implies the tool should be used only for drawings that are already open, providing contextual usage guidance. However, it does not explicitly mention alternatives like 'open_drawing' for opening closed drawings or 'list_open_drawings' to see available options.

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 discloses the crucial plan mode behavior (no changes without confirm=true) and the CTB-based thickness logic. However, it doesn't mention side effects of confirm=true, prerequisites like layer creation, or other behavioral traits such as whether changes are reversible.

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

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

Three sentences cover purpose, plan behavior, and a domain-specific tip. Each sentence earns its place; the description is appropriately sized and front-loaded with the primary 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?

For a complex 8-parameter mutation tool with no annotations, the description captures core behavior and the plan mode, but lacks details on what 'matcheen' means (matching criteria) and the create_layer parameter behavior. The output schema covers return values, so that part is not needed.

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 for 'property' by listing allowed values (color, layer, linetype, lineweight, linetypescale, visible) and for 'confirm' by explaining its effect. With 0% schema coverage, this is valuable but leaves many parameters (type, block, handles, create_layer) unexplained, so the description only partially compensates.

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 changes a property (color, layer, linetype, lineweight, linetypescale, visible) on matching entities, using a specific verb and resource. It distinguishes from geometry-focused siblings like transform_entities by specifying property types.

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

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

It provides explicit usage context for the confirm flag: without confirm=true, it returns a PLAN with affected_count and makes no changes. It also gives a domain-specific guideline for Azcuy thickness hierarchy (use COLOR, not lineweight), which helps in a specific scenario. However, it doesn't explicitly contrast with alternative tools.

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

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

No annotations are provided, so the description must carry full burden. It states the main action but fails to disclose the default 'maximizar' (maximize) behavior implied by the parameter default true, nor does it mention side effects, limitations, or return values. This is a significant gap for a UI manipulation 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?

The description is concise: two sentences, front-loaded with the action, and then a brief context sentence. Every sentence earns its place with no unnecessary repetition or verbosity.

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 simple, and the description covers its main purpose and context. However, it omits the behavior of the 'maximizar' parameter (default true), which is critical for correct invocation. The output schema exists, so return values need not be explained, but the parameter gap leaves the description incomplete.

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 contains one parameter 'maximizar' with 0% description coverage, and the description does not mention it at all. Thus, the description adds no semantic value beyond the parameter name, failing to compensate for the schema's lack of 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 the tool's function: 'Trae la ventana de AutoCAD al frente' (brings the AutoCAD window to the front), using a specific verb and resource. It is distinct from sibling tools, which focus on drawing, entity manipulation, or file management.

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 provides a specific use case: 'Sirve cuando el servidor se engancho por COM sin que AutoCAD estuviera a la vista' (use when the server connected via COM without AutoCAD being visible). This gives clear context, though it does not explicitly mention alternatives or when not to use 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?

No annotations are provided, so the description carries the full burden. It discloses that without confirm=true the tool returns a PLAN, which is useful behavioral context. However, it does not mention whether the mutation is permanent with confirm=true, whether it is reversible, or any permission requirements.

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 very concise, front-loaded with the main purpose, and every sentence provides useful information. The detail about rotation and the plan behavior is essential and not 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?

Despite having an output schema, the tool is complex with 11 parameters and no annotations. The description fails to explain key aspects like how to select entities (handles vs type/block/layer), what the PLAN contains, or the exact effect of confirm=true. This is insufficient for an agent to reliably invoke the tool.

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

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

Schema description coverage is 0%, and the description only clarifies the rotation parameter ('rotation en grados float, respecto de (base_x, base_y)'). It does not explain the semantics of dx/dy, scale, type/block/layer filters, handles, or confirm, leaving the agent with insufficient guidance 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 clearly states the tool's action with a specific verb and resource: 'Mueve, rota y/o escala entidades existentes' (moves, rotates, and/or scales existing entities). This differentiates it from sibling tools like delete_entities or copy_entities, which target different 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: without confirm=true it returns a PLAN, so the tool can be used for previewing changes. However, it does not explicitly contrast with alternatives or state when to prefer this over transform-related siblings, leaving usage mostly implied.

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 clearly discloses the key behavior that this undoes the full AutoCAD history, which is critical for an undo operation. It does not mention other traits like reversibility or edge cases, but the primary caveat is well covered.

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

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

The description is only two sentences, concise and front-loaded with the action. Every sentence adds value, 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 simplicity of the tool (one optional parameter, no annotations), the description captures the essential purpose and behavior. It omits parameter details, but the output schema likely covers return values. The core context is sufficiently complete, though parameter semantics would improve 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?

The input schema has zero description coverage, and the description does not explain the 'steps' parameter at all. The parameter name 'steps' is somewhat self-explanatory, but the description adds no meaning about how many operations will be undone or how the value is interpreted.

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

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

The description clearly states the tool undoes the last operations of the active drawing, using a specific verb and resource. It also distinguishes itself by noting it undoes the entire AutoCAD history, not just agent actions, which differentiates it from any potential sibling undo 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 clear context about when to use the tool: when you need to undo operations on the active drawing, and it cautions that it affects the full history, not just agent actions. It does not explicitly name alternatives or exclusions, but the scope clarification is enough to guide selection.

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

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

With no annotations, the description carries the transparency burden. It discloses an important side effect: if AutoCAD is hidden (Visible=False), it first brings the window to front, with a rationale. This is useful behavioral context beyond the basic zoom operation, though it does not mention all potential 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?

Two concise sentences, front-loaded with the primary action and a conditional side-effect explanation. No wasted words, appropriately sized.

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 operation is simple and has an output schema, so return values need not be described. The description covers the main action and the notable hidden-window behavior, but the unclear parameter semantics prevent a perfect score.

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 does not explicitly explain the 'mostrar_ventana' parameter. It indirectly references showing/hiding the window, but the agent must infer the parameter's relationship to the described behavior, which is insufficient for a 0-coverage 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?

Description states 'Zoom a la extension del dibujo activo' — a specific verb (zoom) and resource (active drawing extents), clearly distinguishing it from sibling drawing/query tools. No other sibling provides zoom behavior.

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?

Implied usage: use to zoom to extents of the active drawing. It provides context about hidden windows but does not explicitly state when to prefer this over alternatives or when not to use it.

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