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

No annotations are provided, so the description carries the full behavioral burden. It does not state that this mutates the current drawing, whether the layer must already exist, what coordinate system or units are expected, or whether layer creation occurs. The output schema helps with return values, but mutation behavior remains undisclosed.

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 purpose is front-loaded in the first sentence, followed by a compact Args block. Each line documents a parameter without redundant or promotional text.

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

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

An output schema exists, so return values need not be described. However, for a mutation tool with no annotations, the description should say more about drawing mutation, coordinate expectations, and layer handling. Parameter semantics are complete enough for invocation, but behavioral context is thin.

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

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

Schema description coverage is 0%, but the description compensates well by documenting all five parameters: point1 and point2 as extension line origins, dim_line_point as dimension line location, dim_type as 'aligned' or 'linear', and layer as optional. It adds meaning beyond the bare schema titles.

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 and resource: 'Add a linear or aligned dimension between point1 and point2.' It clearly distinguishes this from drawing primitives like draw_line or draw_rectangle because the resource is a dimension object with extension line origins.

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 explains how to call the tool but gives no guidance on when to use it versus alternatives, prerequisites for adding dimensions, or what happens if the target layer does not exist. The intended CAD drafting context 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 carries the full behavioral burden; it does usefully disclose the sweep direction and the radius > 0 constraint. It is silent on side effects: whether the entity is added to the active drawing, whether a missing layer is auto-created, and what happens on invalid geometry.

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

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

Front-loaded one-line summary followed by a compact parameter list; every line adds information beyond the bare property names. Slight redundancy between the property names and the Args labels, but no wasted prose.

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 return shape is covered by an existing output schema, so that need not be described. However, for a drawing-mutation tool with no annotations, the description omits environment context (which drawing is targeted, layer creation behavior, coordinate units) that would let an agent call it confidently.

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

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

Schema description coverage is 0%, but the Args block documents every parameter: center accepts 2D or 3D coordinates, radius must be positive, angles are degrees, layer is optional, and color is an ACI value 1-255. Remaining gap is the unit/origin assumption for center coordinates.

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

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

States a specific verb and resource ('Draw a circular arc') plus the defining behavioral detail (counter-clockwise, from start_angle_deg to end_angle_deg). An agent can distinguish this from draw_circle, draw_line and draw_polyline on the description alone.

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

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

No guidance on when to choose an arc over a polyline approximation, and no mention of prerequisites such as an active drawing or an existing layer. The reader must infer all usage conditions from the verb.

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

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

No annotations exist, so the description carries the full behavioral burden, yet it says nothing about side effects (a new entity is added to the current drawing), whether an active session/connection is required, or whether the operation is undoable. For a mutating tool this is a meaningful gap, partly offset by the presence of an output schema.

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

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

One front-loaded purpose sentence followed by a compact args list; every line carries parameter information. The 'AutoCAD 2027' version tag is the only near-redundant element.

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 an output schema present, return values need no explanation, and all four parameters are covered. However, for a drawing-creation tool with zero annotations, the absence of any statement about connection requirements or the effect on the active drawing leaves an agent guessing about execution 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%, and the description compensates well: it documents center as [x, y] or [x, y, z], radius as strictly positive, layer as optional, and color as an ACI index 1-255. The ACI range and coordinate formats are genuinely new information not present 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?

States a specific verb+resource ('Draw a circle in AutoCAD 2027') that unambiguously separates it from draw_line, draw_arc, and draw_polyline by geometry type. It stops short of explicitly naming those alternatives, so it is clear but not fully differentiating.

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

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

No guidance on when to use this versus sibling geometry tools, and no preconditions such as an active AutoCAD connection or which drawing the circle lands in. The agent must infer all routing decisions from the tool name alone.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that the boundary must be closed, that scale is ignored for SOLID, and that color is an ACI value from 1-255, but it omits error behavior, permission/layer implications, and whether the HATCH is immediately visible or requires regeneration.

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 purpose is front-loaded in one sentence, followed by a compact per-parameter list. Every line carries useful information, and the size is appropriate for a six-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?

The description covers the essential invocation details: boundary requirements, parameter meanings, and optional layer/color. Since an output schema exists, return values need not be explained, though additional failure-mode context would make it fully complete for a mutation tool with no annotations.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: boundary_handle is defined as a hex handle of a closed boundary with source examples, pattern includes concrete pattern names, scale notes SOLID behavior, angle_deg gives units, and layer/color are marked optional with constraints.

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 first sentence states a specific verb and resource: create a HATCH inside a closed entity by handle. It is immediately distinguishable from the sibling drawing primitives such as draw_line, draw_rectangle, and draw_circle.

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

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

The description gives clear usage context by tying boundary_handle to entities produced by draw_rectangle, draw_polyline, or draw_circle. It does not explicitly state when not to use the tool or name alternatives, but the intended scenario 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?

No annotations exist, so the description carries the full burden; it does disclose one meaningful side effect — the layer is automatically created if missing. It does not say whether the entity is committed to the current drawing immediately, what coordinate system or units the points are interpreted in, or what happens if the connection is not established.

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 core sentence is front-loaded and the Args block is scannable with no filler. It is slightly longer than strictly needed but every line maps to a parameter an agent must supply.

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

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

An output schema exists so return values need not be explained, and all four parameters are covered. However, for a drawing-mutation tool with zero annotation coverage, the absence of connection prerequisites, coordinate-system/units context, and the default-layer behavior leaves real 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, and it largely does: it gives accepted shapes for start_point and end_point ([x,y] or [x,y,z]), marks layer as optional with auto-creation semantics, and provides a concrete ACI color mapping (1=Red ... 7=White). Only units, coordinate system, and the default layer when omitted remain undocumented.

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

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

States a specific verb and resource ('Draw a line') plus the host application and supported dimensionality, so an agent knows exactly what entity is created. It does not explicitly distinguish itself from draw_polyline or draw_rectangle, leaving that inference to the reader.

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

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

There is no guidance on when to choose draw_line versus draw_polyline (a two-segment polyline would be equivalent), and no prerequisites such as needing an active AutoCAD connection first. Usage is only implied by the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It notes that the layer is auto-created if missing, which is useful, but omits whether the operation requires an active drawing/connection, whether it is undoable, and any mutation effects. For a drawing-mutation tool with zero annotation coverage this is a significant gap.

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

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

The purpose sentence is front-loaded, followed by a compact Args section with no filler. Sizing is appropriate for a five-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?

An output schema exists, so return values need not be explained, and parameters are well covered. However, for a mutation tool with no annotations, the description leaves behavioral and precondition gaps (connection state, undo semantics) that an agent would want.

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: the Args block documents all five parameters, including that vertices requires at least 2 points, that layer is auto-created, and that color is an ACI value in range 1-255. These add real semantics beyond the bare schema types.

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

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

States a specific verb (Draw) and resource (LWPOLYLINE polyline through vertices), and the LWPOLYLINE specificity distinguishes it from siblings like draw_line and draw_arc. An agent can tell apart this tool from generic line-drawing alternatives without opening the schema.

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

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

No guidance on when to use draw_polyline vs draw_line or draw_arc, or on prerequisites like an active connection. The usage context is implied by the name alone, with no explicit alternatives or exclusions.

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

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

With no annotations, the description does useful work by disclosing exactly what is created (a closed LWPOLYLINE) and that width/layer/color are applied to it. It omits behavioral facts that matter for a write operation: whether a live connection/session is required, which coordinate space or units the corners are in, and whether the entity is undoable.

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

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

One front-loaded sentence plus a tight Args block; every line adds information and there is no filler or repetition of the schema structure beyond legitimately clarifying it.

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 5-parameter mutation tool with no annotations, the definition explains the geometry and the optional styling attributes but leaves out session prerequisites, coordinate units, and layer-creation behavior. The output schema covers return values, so that omission is not counted, but the call-time preconditions 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 description coverage is 0%, so the description must carry the load, and it largely does: it maps corner1/corner2 to [x, y] pairs, calls width/layer optional, and gives the ACI color range (1-255). Gaps remain: no units/coordinate system for points, no note that the arrays must contain exactly two elements, and no explanation that width=0 means the default lineweight.

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

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

States a specific verb and resource ("Draw an axis-aligned rectangle") and even discloses the resulting entity type (closed LWPOLYLINE), which is more than the name alone provides. It is distinguishable from siblings like draw_line and draw_polyline by the resource, though it never explicitly contrasts with them.

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

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

Usage is only implied: "from two opposite corners" and "axis-aligned" hint at the geometry model, but there is no statement of when to prefer this over draw_polyline (e.g. for rotated rectangles), nor any prerequisite such as an active CAD connection despite get_connection_status existing as a sibling.

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

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

No annotations exist, so the description carries the full burden. "Create" correctly signals a mutating operation and the multiline flag explains the entity type produced, but nothing is said about whether the target layer must pre-exist, what happens on a locked/frozen layer, whether the insertion is undoable, or whether an active document is required.

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?

Purpose is front-loaded in one sentence, followed by a compact Args list; there is no filler. Slight expansion of a couple of args (units for height/position) would have cost nothing and improved it.

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 7 parameters, no annotations, and an output schema present, the description covers parameter semantics adequately and need not explain return values. What is missing is the mutation context an agent needs before calling a write tool: required application state, layer-existence behavior, and failure modes.

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 Args block does necessary work: it gives the position format ([x, y] or [x, y, z]), states rotation is in degrees, explains that multiline switches the entity type, and constrains color to ACI 1-255. It leaves the height default (2.5) to the schema and adds no unit information, which is a minor residual gap.

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

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

States a specific verb and resource ("Create single-line TEXT or multiline MTEXT") plus the target application, and the TEXT/MTEXT distinction immediately separates it from sibling drawing tools like draw_line or draw_hatch. An agent can pick this tool without opening the schema.

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

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

Usage is implied by "Create ... in AutoCAD" and the multiline flag hints at the TEXT-vs-MTEXT choice, but there is no explicit when-to-use guidance, no mention of prerequisites (must a drawing be open? must the layer already exist?), and no comparison to alternatives such as send_command or eval_autolisp.

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 usefully discloses the execution mode, the fallback path and the timeout, but never states that arbitrary code runs with full drawing/document privileges, whether it mutates the current drawing, or whether live-GUI runs differ in result from headless runs.

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 capability is front-loaded in one sentence, then a compact arg list with no filler. The parenthetical example for code earns its place; the timeout_ms line is near-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?

An output schema exists, so return values need not be described, and the parameters are fully covered. But for a tool that executes arbitrary code against a live CAD application with no annotations, the omission of side-effect and safety context leaves a meaningful gap.

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

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

Schema description coverage is 0%, so the description must do all the work, and it largely does: every parameter is explained, including the interaction where input_dwg forces headless mode and save_as_dwg only applies there. The timeout_ms entry merely restates the parameter name, and no formats or units are given for the dwg paths.

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?

Opens with a specific verb+resource+scope: evaluate arbitrary AutoLISP in AutoCAD 2027 and return the serialized result. It is distinguishable from the draw_* siblings, but does not clarify how it differs from send_command or run_accoreconsole_script, which plausibly overlap in capability.

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

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

It explains the prefer_live vs headless decision and the condition that forces headless (input_dwg provided, or prefer_live=False), which is real conditional guidance. However, it never says when to reach for this tool versus send_command or run_accoreconsole_script, so sibling selection is left to inference.

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

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

No annotations are supplied, so the description carries the full behavioral burden, yet it says nothing about whether an existing file at output_path is overwritten, whether the live drawing is mutated, whether parent directories must exist, or whether a connection to AutoCAD must be established first. The output schema covers return values, so that omission is acceptable, but the write-safety profile of a file-creating mutation is entirely undisclosed.

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 purpose sentence is front-loaded and the Args block is compact; since schema coverage is 0%, the parameter lines are not redundant filler. The raw docstring formatting is slightly less scannable than prose but wastes no sentences.

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

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

An output schema exists, so return values need not be described, and the two parameters are at least named. What is missing for a file-writing tool with zero annotations is overwrite semantics, connection prerequisites, and format/path interaction — enough gaps that an agent could call it incorrectly and silently clobber a file.

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 format parameter has no enum in the schema, so the description genuinely compensates by listing 'dwg', 'dxf', 'pdf', 'png' and by giving concrete path examples. However, it never states whether the path's extension must match the format, whether relative paths are accepted, or whether the target directory must already exist.

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

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

The description states a specific verb (save/export) plus the resource (the active AutoCAD 2027 drawing) and enumerates the supported output formats. It is clear what the tool does, though it never contrasts itself with nearby siblings such as inspect_or_create_dxf or run_accoreconsole_script, which could also plausibly produce files.

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

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

Usage is only implied by the phrase 'Save or export the active drawing'; there is no statement of when to prefer dwg over pdf/png, no precondition such as an open connection or loaded drawing, and no exclusion pointing away from sibling file-producing tools. The agent must infer the selection criteria from the format list alone.

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

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

With no annotations, the description carries the full burden, and it does disclose a meaningful non-obvious side effect: with auto_bootstrap=True it will open a workspace drawing in AutoCAD (a mutation of GUI state, implicitly the default since the schema shows default=true). However, it says nothing about failure behavior, timeouts, or whether checking is side-effect-free when bootstrap is False.

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

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

One front-loaded sentence states the whole check, followed by a compact Args block. No filler, and the most important information (what is being checked, and the exact host/port) comes first.

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

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

An output schema exists, so return-value documentation is correctly omitted, and the description covers all three status domains plus the bootstrap side effect. What remains thin is the diagnostic semantics — what a negative result looks like and whether the agent should retry.

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 the single parameter, and it does: it defines auto_bootstrap's condition ('if True and the live bridge is not yet connected') and its resulting action. The only gap is that it does not restate or clarify the default value of True that the schema declares.

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

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

The description names a specific verb ('Check') and three concrete resources: the AutoCAD 2027 GUI process, the live TCP bridge at 127.0.0.1:9877, and AcCoreConsole status. That is unmistakably distinct from every sibling tool, which are all drawing, query, or script-execution operations, though it never explicitly names an alternative.

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

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

The purpose strongly implies the calling context (verify connectivity before issuing draw/send_command calls) and the auto_bootstrap arg hints at the 'bridge not yet connected' scenario, but the description never states when to call this versus proceeding directly to a sibling or when not to call it. Usage is inferable rather than specified.

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; 'Get' implies a read-only operation, which is reasonable but not authoritative. It does not disclose what happens when no drawing is open, whether a connection to AutoCAD is required, or the cost/latency of reading a file via input_dwg.

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 sentence with no filler, front-loading the primary mode (active drawing) before the alternative. Every clause conveys information about what is returned or what can be passed.

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

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

An output schema exists, so return-value detail is not required, and the description covers the core purpose. What is missing is prerequisite context (connection/active document state) and any parameter format guidance, which matters for a tool with zero annotation 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% for the single parameter, so the description must compensate. It does add meaning by framing input_dwg as a file alternative to the active drawing, but it omits the expected format (path string, absolute vs relative, .dwg extension), which is the main ambiguity an agent would hit.

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

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

States a specific verb and resource ('Get metadata, system variables, bounds, and entity count of the active drawing') and enumerates the returned data categories. The scope variant via input_dwg is also explicit. It does not explicitly name a sibling, but the drawing-level read is implicitly distinct from entity-level siblings like query_entities and get_selection.

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

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

The parenthetical '(or a file via input_dwg)' signals one usage variant, so the agent can infer two modes of operation. However, there is no statement of when to prefer this over query_entities or get_selection, and no prerequisites (e.g., an open AutoCAD document) are given.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. 'Get' implies a read-only retrieval, and mentioning 'currently or previously selected' adds useful state context, but it does not explicitly state side effects, permissions, or empty-selection 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?

A single sentence with no wasted words, front-loaded with the verb and resource. It communicates the essential scope efficiently.

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

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

For a zero-parameter retrieval tool with an output schema, the description is nearly complete: it says what is retrieved and in which drawing context. It could say more about selection persistence or empty results, but the core information is present.

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

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

The tool has zero parameters and schema description coverage is 100%, so there are no parameter semantics to explain. Baseline for a no-parameter tool is 4.

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

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

The description states a specific verb ('Get'), resource ('all currently or previously selected entities'), and scope ('active AutoCAD 2027 drawing'). It is clear what the tool returns, though it does not explicitly distinguish itself from neighboring tools like 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 phrase 'currently or previously selected' implies when the tool is useful, but there is no explicit guidance on when to use it instead of alternatives such as query_entities. Usage context 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?

No annotations, so the description carries the full burden. It discloses useful traits — offline/high-speed, ezdxf backend, GUI handoff via open_in_autocad — but never says whether 'create' overwrites an existing file at dxf_path, whether the path must already exist for 'inspect', or what happens on failure. For a tool that writes files, the overwrite semantics are a real gap.

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

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

The summary sentence is front-loaded and carries the key framing; the args block is compact and each entry earns its place. The entities_spec example is verbose but justified given zero schema documentation.

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

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

An output schema exists, so return values need not be explained. However, for a file-writing tool with no annotations, the description leaves out overwrite behavior, path-existence requirements, and error/validation semantics — the remaining gaps an agent needs before calling 'create' safely.

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, and it largely does: all four params are documented, with concrete example entity dicts showing required keys for LINE and CIRCLE. It stops short of enumerating valid entity types or the per-type required keys, so an agent must guess beyond the two examples.

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

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

States a specific verb+resource pair ('DXF inspection or creation') plus the engine used (ezdxf) and the optional AutoCAD 2027 handoff. This implicitly separates it from the live-drawing siblings like draw_line/query_entities, though no sibling is named explicitly.

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 action parameter is disambiguated with explicit conditions: 'inspect' for reading layers/entities of an existing DXF, 'create' for generating from entities_spec. Missing is any guidance on when to choose this offline tool over the live AutoCAD siblings (draw_*, query_entities).

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. It discloses nothing about mutation side effects: whether 'create' fails or overwrites when block_name already exists, whether 'insert' modifies the active drawing, whether operations are undoable, or what permissions/connection state are required. 'List' versus two write modes is the only behavioral signal.

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 front-loaded summary sentence followed by a per-parameter list is an efficient structure for a 10-parameter tool, and each line earns its place by stating which action the parameter serves. The raw 'Args:' dump is slightly mechanical but not padded.

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

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

An output schema exists, so return values need not be described. But for a tool with three modes, two of which mutate the drawing, and zero annotation coverage, the definition leaves out error conditions, state prerequisites, and the effect of insertion on the current drawing. It is adequate to construct a call but not to predict its consequences.

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 schema does not even enumerate the allowed 'action' values, so the description does real work: it enumerates 'list', 'create', 'insert' and maps every parameter to the mode that consumes it ('point' as base point versus insertion point, handles required only for 'create', scale/rotation only for 'insert'). It still omits accepted formats for point (2D vs 3D) and handles, and the units/range for ACI color.

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 opening sentence names three specific operations and their resources: listing blocks, creating a block definition from entity handles, and inserting a block reference. It is clearly distinguishable from drawing siblings like draw_line or modify_entities. It does not explicitly compare itself to any sibling, which keeps it just short of a 5.

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

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

The Args section implies when each field matters by tying them to 'create' and 'insert', which gives implicit mode-selection guidance. However, there is no explicit statement of when to choose this tool over alternatives, no prerequisites (e.g., must a connection or drawing be active), and no note on what 'list' returns versus the other modes.

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

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

No annotations are provided, so the description carries the full behavioral burden for a mutating tool. It says nothing about persistence of changes to the drawing, what happens when 'create' is called on an existing layer, whether frozen/locked states affect later draw calls, or any error conditions. Only the conditional requirement on 'name' hints at 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 one-line summary is front-loaded and the Args block is scannable with no filler. Every line maps to actual information an agent needs, though it could be slightly tighter about which params apply to which actions.

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

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

An output schema exists, so return values need not be explained, and parameter documentation is solid. What is missing for a stateful CAD mutation tool is behavioral context: preconditions per action, effect of freeze/lock on subsequent operations, and whether changes persist to the drawing file.

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

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

Schema description coverage is 0%, but the description compensates well: it enumerates all valid 'action' values, states the conditional requirement on 'name', gives the ACI range 1-255 for 'color', and supplies concrete linetype examples. What remains unclear is the default 'list' action and how color/linetype interact with the on/off/freeze actions.

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 first sentence names a concrete resource (AutoCAD layers) and enumerates the operations (list, create, switch, change properties), which is far more than a restatement of the name. It is clearly distinct from the draw_* siblings, though it never explicitly says so. The scope statement is specific enough for an agent to pick it over draw_line or modify_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 Args block implies per-action usage (name is 'required for all actions except list'), which is real guidance. However, there is no statement of when to reach for this tool versus siblings, no preconditions (e.g. must the layer already exist for 'on'/'freeze'/'lock'?), and no note that 'set_current' changes global drawing state.

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

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

No annotations are provided, so the description carries the full behavioral burden. It lists actions including 'erase' and set_layer/set_color, but it does not disclose permissions, undo/irreversibility, partial-failure behavior, or what happens to entities if an action fails. For a mutation tool with no annotations, this is a significant gap.

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

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

The purpose sentence is front-loaded, followed by a compact Args block that maps directly to the parameters. Every line earns its place given the lack of schema descriptions, and there is no redundant or filler text.

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

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

An output schema exists, so return values need not be explained. The description covers all parameters well enough to invoke the tool if handles are already known, but for a complex 8-parameter mutation tool with no annotations it still omits important usage, prerequisite, and destructive-action 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%, but the description documents all 8 parameters with meaning and action-specific conditions. It gives handle examples, enumerates valid action strings, and clarifies base_point, target_point, rotation_deg, scale_factor, layer, and ACI color range. This fully compensates for the empty 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 states a specific verb and resource: modify one or more entities identified by handles. It also lists supported actions, making the tool's scope clear. It does not explicitly differentiate itself from sibling tools such as draw_* or query_entities, so it stops short of a 5.

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

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

The phrase 'identified by their handles' implies this tool is for changing existing entities rather than creating new ones, but it gives no explicit when-to-use guidance or alternatives. It never mentions using query_entities or get_selection to obtain handles, nor does it state when to choose this over draw_* tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Query' implies a read operation and 'default 100' hints at result truncation, but the description never states read-only safety, required permissions, or what happens when filters match nothing. The headless-mode note adds useful context but behavioral disclosure remains partial.

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 summary sentence is front-loaded and the Args block is tight, with every line adding information. The formatting is efficient without being sparse.

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

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

An output schema exists so return values need not be explained, and all four otherwise-undocumented parameters are covered in the description. What remains thin is the operational context – permissions, truncation behavior beyond the limit default – but for a read/query tool this is largely 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 description coverage is 0%, so the description must compensate, and it does: entity_type is explained with concrete DXF values (LINE, LWPOLYLINE, CIRCLE, ...), layer is identified as a name filter, limit is documented with its default, and input_dwg is tied to headless inspection. Only minor syntax detail (layer name matching, limit bounds) is missing.

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 first sentence names a specific verb and resource ('Query entities') and states the target scope ('active drawing (or a DWG file)') with the optional filters. It is clearer than the name alone, but it does not explicitly distinguish itself from nearby read-style siblings such as get_selection or get_drawing_info.

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 context is implied by describing the two modes: query the active drawing, or pass input_dwg to inspect a file in headless mode. However, the description never says when to prefer this over get_selection, get_drawing_info, or inspect_or_create_dxf, and it gives no exclusions.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the headless environment, optional input drawing, optional save path, and timeout, but omits whether scripts can modify the input drawing, what happens without save_as_dwg, how timeouts or failures are handled, and what side effects arbitrary script execution may have.

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

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

The description is front-loaded with the purpose and then uses a compact Args list. There is no filler, and each sentence or argument line carries necessary meaning.

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

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

An output schema exists, so return values need not be explained, and the parameters are well covered. However, for a code-execution tool with no annotations, the description is incomplete regarding when to select it over sibling tools and how its side effects and failure modes behave.

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

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

Schema description coverage is 0%, but the Args section explains all five parameters, including the coupling between script_or_lisp and is_lisp, the optional open/save drawing paths, and the timeout meaning. This fully compensates for the bare schema titles.

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

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

States a specific verb and resource: run batch AutoLISP or .scr scripts in AutoCAD 2027's headless AcCoreConsole. The batch/headless framing distinguishes it from in-process siblings such as eval_autolisp and send_command, even without naming them.

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

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

The batch and headless AcCoreConsole framing implies its use case, but there is no explicit comparison to alternatives like eval_autolisp or send_command. It does not say when not to use this tool or what prerequisites are required.

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

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

With no annotations at all, the description carries the full disclosure burden and largely drops it: it doesn't say whether the call blocks until the command completes, what happens on an invalid command, whether it can modify or destroy drawing data, or whether undo state is affected. Only the phrase 'raw command string' hints that validation is bypassed.

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

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

One front-loaded sentence states the action and target, followed by a compact Args block. No filler, though the docstring-style Args section is slightly redundant for a single self-named parameter.

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 single required parameter is covered and an output schema exists so return values need not be explained. However, for an unannotated tool that executes arbitrary drawing commands, the absence of any failure-mode, safety, or blocking behavior information leaves a meaningful gap.

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

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

Schema coverage is 0% — the schema only types 'command' as a string — so the description must compensate, and it partially does by giving literal examples ('_.ZOOM _E', '_.REGEN') that convey the underscore-prefix and space-separated token convention. It does not explain sequence termination, how to pass multi-step input, or handling of prompts, leaving the format only half-specified.

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

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

States a specific verb ('Send') and resource ('raw command string') plus the exact target ('active AutoCAD 2027 command line'), which clearly separates it from the structured draw_* siblings. It never explicitly names those siblings as alternatives, so it stops short of a 5.

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

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

There is no statement of when to prefer this raw-command escape hatch over eval_autolisp, run_accoreconsole_script, or the dedicated draw_* tools. An agent must infer the 'use raw when no structured wrapper exists' rule from the word 'raw' alone.

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