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

With no annotations, the description carries the full burden and does well: it states the return value (new ids), that defaults fills lg/ly/lc/lt only for entities that leave them unset, that architectural types expand to Jw_cad lines/arcs/text, and that a preset-created drawing auto-fills layers. It omits error/idempotency behavior and whether 'name' must reference an existing 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?

Purpose and return value are front-loaded, followed by a densely packed reference list of entity shapes. It is long, but the length is driven by the genuinely large variant space and every line documents a distinct key or unit, so little is wasted.

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 an unbounded entity union and no output schema, this is about as complete as it can be: each entity type, its coordinate semantics, unit conventions, and defaults are spelled out, and the return value is stated in prose. Remaining gaps (existence of the target drawing, error handling) are secondary.

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 does for the dominant parameter: the entities array is documented type-by-type with keys, defaults, and units (mm, degrees, CCW). The defaults object is explained; only 'name' is left undefined, though its meaning is obvious from context.

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 (add entities to a drawing), flags the batch nature, and states the return (new ids). Together with the sibling names (drawing_update, drawing_remove, drawing_new) an agent can immediately place it as the creation/append operation without opening a schema.

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

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

Usage is implied rather than stated: 'batch' hints at adding many entities at once, and it points to presets_list for automatic layer assignment. It never says when to prefer drawing_update or drawing_remove, nor that the target drawing must already exist (drawing_new), so the agent must infer the workflow.

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. 'Return' implies read-only behavior and it notes optional filtering, but it omits pagination behavior (limit/offset), entity structure, permissions, ordering, and empty/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?

A single front-loaded sentence with no redundancy. It is efficient, though arguably too terse given the undocumented parameters and behavior.

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

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

For a five-parameter read tool with no annotations, no output schema, and 0% schema description coverage, the description is insufficient. It does not explain the required name, pagination, or return shape, leaving agents with significant 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%, but the description only addresses ids and tag as optional filters. It says nothing about the required name parameter, limit, or offset, leaving most parameters 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: 'Return entities of a drawing', with optional filtering by ids or tag. It is clear but does not distinguish itself from siblings such as drawing_info, drawing_layers, or jww_query, so it falls 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 description implies usage for retrieving drawing entities and optionally filtering by ids/tag, but it gives no explicit when-to-use guidance, no exclusions, and no alternatives among the many sibling drawing/query 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?

With no annotations, the description carries the full burden. It states the return value ('Returns the output path') but says nothing about side effects, whether an existing file is overwritten, where output defaults to when 'out' is omitted, or permission prerequisites for a mutation-style 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?

Compact and front-loaded: the verb+resource leads, then the format enumeration, then the return note. Every element contributes; only minor phrasing could be tightened.

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, no output schema, and 3 parameters at 0% schema coverage, the description should cover more. It omits semantics for 'name' and 'out' and any behavioral context, leaving an agent under-informed despite the solid format detail.

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 partly: it fully documents the important 'format' parameter with three concrete values and their handling. But 'name' and 'out' remain unexplained in both schema and description.

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 'Export' and resource 'drawing', and enumerates the concrete format outputs, so the core operation is unambiguous. It does not, however, distinguish itself from siblings like jww_to_dxf or drawing_import_jww, which an agent must choose between.

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 names the format values but never says when to reach for drawing_export versus the several sibling export/import tools (jww_to_dxf, drawing_import_jww). There is only an implied 'this exports a drawing' usage with no conditions 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?

No annotations are provided, so the description carries the full disclosure burden. It indicates a mutating import but says nothing about whether existing entities are merged or overwritten, whether the target drawing must already exist, permission requirements, or failure/duplicate behavior. For a write 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?

A single front-loaded sentence that leads with the action and resource, with the filter options parenthetically condensed. No waste, though the closing purpose clause is arguably padding rather than essential invocation info.

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 7-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, the description is thin: it omits destination-drawing semantics, parameter formats, and any behavioral guarantees. An agent could not confidently invoke this without opening external docs.

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% across 7 parameters, so the description must compensate, but it only echoes the filter names (lg/ly/types/bbox) without explaining what lg or ly mean, what values 'types' accepts, or the bbox format. The tag, name, and path parameters receive no explanation at all — notably whether 'name' is a new or existing drawing.

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 (Import) and resource (entities of a .jww file into a drawing) and even names the downstream purpose (edit, re-export, send back to Jw_cad). It is clearly distinguishable from siblings like jww_info/jww_query (read) and drawing_export (write-out), though it never names those alternatives 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 'so they can be edited, re-exported or sent back to Jw_cad' clause implies the intended workflow, giving implied usage rather than explicit guidance. There is no statement of when NOT to use it, no prerequisites (does the target drawing need to exist?), and no named alternative such as scan_vector_import or jww_to_dxf.

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 implies a read-only summary operation but does not explicitly state safety, permissions, side effects, or error behavior, leaving significant gaps for a tool that likely reads data.

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

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

The description is a single, front-loaded phrase with no wasted words. It efficiently lists the key return fields, making it appropriately sized for a simple summary 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?

For a simple read-only tool with one parameter and no output schema, the description covers the main return content (counts, layers, bbox). However, it omits what 'name' identifies, how to interpret the output, and any usage context, leaving the definition minimally adequate.

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%, meaning the single required 'name' parameter is not documented in the schema. The description only hints that 'name' refers to a drawing but adds no further meaning (e.g., format, source, or scope), so it does not compensate for the schema gap.

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

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

The description states a specific resource (drawing) and the kind of information returned (counts, layers, bbox), so an agent can tell what the tool provides. However, it does not explicitly distinguish this tool from siblings like drawing_layers or drawing_entities, so it falls 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 description offers no guidance on when to use this tool versus alternatives, nor any prerequisites or context for invocation. It simply states what the tool returns, leaving the agent to infer usage from the name alone.

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

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

No annotations at all, so the description carries full burden. It does not state whether this mutates the drawing permanently, requires an open drawing, or is reversible. No mention of auth, side effects, or what happens to existing layers.

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?

Very compact, front-loads the action and then gives concrete parameter examples. Slightly cryptic because the example object syntax is unexplained, 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?

A mutation tool with no annotations, no output schema, 0% schema description coverage, and no explanation of the required 'name' parameter or return value. Only the optional parameter examples are given, leaving significant 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 coverage is 0%, so the description must compensate. It provides example values for three of the four parameters, showing key formats ('0','0-1','1') which is helpful. However, the required 'name' parameter is never explained, and the examples do not clarify whether keys are IDs or indices.

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 ('Set/rename') and resource ('layer groups, layers and scales of a drawing'). Distinguishes itself from siblings like drawing_update and drawing_entities by targeting the layer hierarchy. Not fully differentiated from drawing_update but the layer-specific focus is clear.

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

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

No guidance on when to use this vs drawing_update, drawing_new, or preset tools. Nothing indicates prerequisites like whether the drawing must already be open or imported first.

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, yet it discloses nothing beyond the bare action. It does not state ordering, scope (all projects vs. current), pagination, or what fields each drawing entry carries. For a read-only list the risk is low, but almost no behavioral context is added.

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 three-word sentence with zero padding, and the core action is front-loaded. It is perhaps under-specified rather than over-long, but there is no wasted 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?

No output schema and no annotations exist, so the description is the only source of information, yet it says nothing about the shape or scope of the returned list. Minimum viable for a trivial list tool, but it leaves the agent guessing about return contents.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is no parameter semantics to clarify and the description neither misleads nor omits anything parameter-related.

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

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

States a specific verb ('List') and resource ('saved drawings'), so the agent knows exactly what it retrieves. It does not, however, distinguish itself from siblings like drawing_info, drawing_layers, or scan_list, which all deal with stored drawing data.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no indication of which sibling to pick when the agent needs entities, layers, or a single drawing's metadata. Usage is only inferable 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?

No annotations provided, so the description carries the burden. It implies a destructive/idempotent behavior via '(or reset)' which is useful, but says nothing about permissions, side effects, or what happens to existing content when resetting. Partial disclosure 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?

Compact and front-loaded, with the core purpose first and parameter hints after. Dense but no wasted sentences; some parenthetical Japanese examples could be seen as slightly heavy but are informative rather than padding.

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

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

For an 8-param construction tool with no annotations and no output schema, the description covers several key parameters well (scale, paper, names) but omits preset, description, and group_scales. An agent would still need to guess at these, leaving meaningful 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 coverage is 0%, so the description must compensate. It does add meaning for scale ('denominator, 100 for 1/100'), paper values, and the group_names/layer_names examples with real key formats. However, preset, description, and group_scales are entirely undocumented, leaving 3 of 8 parameters 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?

States a clear verb+resource ('Create (or reset) a named drawing'), and the parenthetical reset behavior distinguishes it somewhat. It doesn't explicitly name which sibling it differs from (e.g., drawing_update, drawing_add), but the create/reset framing is specific enough to identify the resource.

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 drawing_update (which presumably modifies an existing drawing), drawing_add, or drawing_import_jww. The '(or reset)' hint implies idempotency but the conditions under which reset is appropriate are not stated.

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

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

No annotations are provided, so the description carries full burden. It discloses that it returns an image (rare and useful) and that bbox zooms, but omits whether it's read-only, whether rendering can fail on large drawings, cost/latency, or what out_png does when set (write to disk? return path?). Multiple behavioral unknowns remain.

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 efficient sentence that front-loads the core action and folds in the one parameter that needs explaining. No filler or repetition. Slightly under-specified rather than verbose.

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 4 params, 0% schema coverage, no annotations, and no output schema, the definition should explain parameters and return semantics. It only covers bbox/zoom and return type partially, leaving name, out_png, width_px, failures, and sibling distinctions unaddressed.

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. Only bbox is clarified ('in real mm to zoom'). 'name', 'out_png', and 'width_px' are undocumented in both description and schema — notably 'out_png' is ambiguous (output file path?) and 'width_px' defaults are invisible to the reader. Should do much more given the coverage gap.

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

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

States a specific action (render to PNG) and names the resource (drawing), which is better than a tautology. But it doesn't distinguish 'drawing_preview' from siblings 'jww_preview' and 'gaihen_preview', and it's not clear from the description why a caller should choose this generic preview over the format-specific ones.

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 when-to-use guidance beyond the purpose clause. Nothing tells the agent when to use drawing_preview versus jww_preview/gaihen_preview, or when bbox is needed versus a full-page render. The only hint is that bbox zooms, which is indirectly a usage cue but not 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 at all, the description carries the full burden, and it does disclose the destructive scope of tag-based removal ('every entity with the given tag') and the clear-all mode. It stops short of stating irreversibility, permission requirements, or behavior when an id does not exist.

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

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

Two short sentences, front-loaded with the core action and the alternate selection mode, with the clear=true instruction last. No filler and 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 a destructive 4-parameter tool with no annotations and no output schema, the description covers the main usage paths but omits the required 'name' argument and any safety framing. It is minimally viable rather than 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% across 4 parameters, so the description must compensate, and it does explain ids, tag, and clear. The gap is the required 'name' parameter, which is never explained in either the schema or the description, leaving the single mandatory argument 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?

States a specific verb ('remove') and resource ('entities') plus the two selection modes (by id, or every entity with a tag), which clearly separates it from drawing_add and drawing_update. It does not name those siblings explicitly, so differentiation is inferred rather than stated.

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 one concrete usage cue ('Use clear=true to empty the drawing'), which tells the agent when that parameter applies. However, it offers no guidance on choosing between ids and tag, and no warning about when not to use this destructive tool.

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

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

With no annotations, the description carries the full burden, and it does disclose one important behavioral trait: missing fields are not merged from the existing entity, so this is effectively a full replacement. However, it stays silent on permissions, what happens when the id does not exist, and whether the drawing must be open.

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

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

Two short sentences with the core action front-loaded and no filler. The second sentence is terse to the point of ambiguity, but the overall size is appropriate.

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 mutation tool with no annotations, no output schema, 0% parameter coverage, and a nested free-form 'entity' object, the description is too thin. An agent still lacks enough context to know what a valid entity payload looks like or what side effects to expect.

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 three undocumented parameters, and it largely fails. It explains 'id' only obliquely via "same id" and reduces 'entity' to the vague phrase "new content", while the required 'name' parameter is never mentioned at all.

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?

"Replace one entity (same id) with new content" gives a specific verb (replace), a resource (entity), and a scope qualifier (same id), which distinguishes it from siblings like drawing_add and drawing_remove. It is clear what the tool does, though it never states the domain (drawing) or names the alternative tools 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?

There is no explicit when-to-use guidance and no comparison to alternatives such as drawing_add or drawing_remove. The reader must infer from "replace" that this is the tool for modifying an existing entity rather than adding or deleting one.

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 does disclose one genuine behavioral fact — that cancellation causes Jw_cad to report 未実行 and leaves the drawing unchanged — but omits whether the job record is removed, state requirements, and what role reason/exchange play.

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 short sentence, front-loaded with the action and with no wasted words. Its brevity is efficient, though the cryptic 未実行 phrase mildly reduces immediate comprehensibility.

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 mutation tool with no annotations, no output schema, and 0% schema coverage on three parameters, the description is far too thin. It provides one behavioral note but leaves parameter semantics and usage context essentially unaddressed.

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% across three parameters, and the description mentions none of them (job_id, reason, exchange). The reference to 'a job' only implicitly maps to job_id via the tool name and adds no meaning beyond the schema.

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

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

"Cancel a job" names a specific verb and resource, and the appended note about Jw_cad reporting 未実行 clarifies the side effect. It is distinguishable from siblings like gaihen_jobs or gaihen_status, though it never explicitly contrasts itself 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?

There is no statement of when to use this tool versus alternatives, nor any prerequisite such as the job needing to be in a cancellable state. Usage is only inferable from the verb 'Cancel'.

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 implies a read/list operation via 'List' and notes the pending-response state, but discloses nothing about permissions, ordering, filtering, or what happens to listed jobs. Significant gaps remain for a tool with zero annotation coverage.

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 compact sentence with the purpose front-loaded. It is efficient and wastes no words, though it leaves the parameter and behavior unexplained.

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 no output schema this is roughly adequate - it tells the agent what the tool returns conceptually. However, the lone undocumented parameter and lack of any guidance on the pending-job workflow leave it thin for coordinated use with gaihen_respond/gaihen_cancel.

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?

There is one optional parameter (`exchange`) with 0% schema description coverage, and the description never mentions it or explains what filtering by exchange would do. Because the schema (and description) leave the parameter undocumented, an agent cannot know how to scope the list.

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 ('List jobs sent from Jw_cad') and adds a clarifying definition of what a job is (one 外部変形 run awaiting a response). It is understandable on its own, though it doesn't explicitly contrast itself with close siblings like gaihen_status or gaihen_read.

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 that jobs are 'waiting for a response' implies usage (check pending work before responding), but there is no explicit when-to-use guidance or direction to alternatives like gaihen_status or gaihen_respond. Usage is only inferable.

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 does disclose the important out-of-band mechanism (writes a file that the user must manually process via a .bat) rather than mutating the drawing directly. It does not disclose overwrite behavior for the outbox file, error/failure modes, or prerequisites on the Jw_cad side.

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

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

Two tight sentences with no filler, and the core action is front-loaded before the follow-up workflow detail. Nothing is padded, though it could be slightly more structured about parameters.

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 4-parameter tool with no annotations, no output schema, and 0% schema description coverage, the description explains the key mechanic but leaves parameter meaning undocumented. It is enough to understand the workflow, but not enough to invoke it correctly with confidence.

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

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

Schema description coverage is 0% across 4 parameters. The description addresses 'drawing' and 'raw entities' loosely, but the 'notice' and 'exchange' parameters receive no explanation at all, and there is no format guidance for the entity objects. It only partially compensates for a complete coverage gap.

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

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

The description states a specific action (place a drawing or raw entities) into a named target (outbox/IMPORT.txt), which is more concrete than a bare restatement. It implies the tool's role in a prepare-then-import workflow, distinguishing it from read/query siblings. However it does not explicitly contrast itself with siblings like drawing_import_jww or scan_vector_import.

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

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

The description lays out the two-step workflow (prepare here, then user runs JWMCP_import.bat in Jw_cad), which implies when the tool applies. But there is no explicit when-to-use-vs-alternative guidance, and with sibling import tools present the agent gets no routing signal for choosing among them.

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

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

No annotations are provided, so the description carries the full disclosure burden. It conveys only the output medium (PNG), saying nothing about whether rendering requires the job to be in a particular state, whether it has side effects, whether it is read-only, or how large/slow the result is.

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 tight sentence with the verb and result front-loaded and no filler. It is arguably too terse given the documentation gaps, but as pure structure it is efficient.

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

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

For a tool with no annotations, no output schema, and three undocumented parameters sitting in a dense sibling ecosystem with three other preview tools, the description omits far too much: no parameter guidance, no job-state prerequisites, and no sibling routing.

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% across three parameters. The description implies job_id via "a job's selected entities" but adds nothing about the exchange parameter or the width_px sizing control, leaving two parameters wholly undocumented in both schema and description.

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 (render) plus the resource (a job's selected entities) and the output format (PNG image), which is clear. However, it does nothing to distinguish itself from siblings drawing_preview and jww_preview, which presumably also render previews, so an agent cannot tell which preview tool applies to which domain without guessing.

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 indication of when to use this over drawing_preview, jww_preview, or gaihen_read, nor any prerequisite such as required job state or a prior gaihen_setup/gaihen_jobs call. Usage must be inferred entirely 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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose the payload contents and notes pagination via limit/offset, which is useful beyond the schema. It says nothing about read-only guarantees, permissions, error behavior for a missing/invalid job_id, or stable ordering across pages.

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 plus a short imperative second sentence; the core payload description is front-loaded and no sentence is filler. Slightly compressed to the point of being list-like, but nothing is wasted.

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 read tool with no output schema, no annotations, and 0% schema coverage, the description covers the content of the return well and the pagination knobs, but omits the 'exchange' parameter's meaning and any routing against the sibling gaihen_jobs/gaihen_status 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% across 4 parameters. The description explains limit/offset semantics ('for big selections') and job_id is implied by 'one job', but the 'exchange' parameter is completely undocumented in both schema and description, leaving an orphan parameter.

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

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

States a specific verb and resource ('Read one job') and enumerates what the read returns (scales per layer group, selection range, picked points, write settings, layer names, entities in real mm). The 'one job' phrasing implies single-job detail as opposed to the sibling gaihen_jobs list, but it never names that sibling, so differentiation is left to inference.

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 trailing 'Use limit/offset for big selections' is real usage guidance for pagination, but there is no statement of when to prefer this tool over gaihen_status, gaihen_jobs, or gaihen_preview, nor any prerequisite on how a job_id is obtained.

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 does disclose real behavior: entities are injected once the .bat sees the file, delete_selected=true replaces the originally selected figures, notice posts a message into Jw_cad, and coordinates are real mm relative to the job's layer group scales. It omits failure modes, timing/async behavior, and what happens if both entities and drawing are supplied.

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 with the core action, then mode selection, then the destructive flag and coordinate convention. Information density is high and there is little wasted text, though the '.bat' reference is opaque shorthand.

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 6-parameter mutation tool with no annotations and no output schema, the description covers the core write path but leaves job_id, exchange, error behavior, and any return confirmation unaddressed, so an agent cannot fully predict the call's effect.

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 entities, drawing, delete_selected, and notice, and cross-references the drawing_add schema for entity shape. It says nothing about job_id (the sole required parameter) or the 'exchange' parameter, leaving two of six parameters undocumented anywhere.

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 'Answer a job' plus the mechanics of entities being drawn into the Jw_cad drawing state a specific action and resource, which an agent can distinguish from siblings like gaihen_read, gaihen_status, and gaihen_jobs. However, the phrasing is jargon-heavy ('as soon as the .bat sees the file') and never explicitly contrasts itself with those 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?

It does specify the two mutually exclusive input modes ('Give either entities ... or drawing=<name>'), which is genuine routing guidance. It stops short of saying when this tool is the right one versus gaihen_cancel, gaihen_prepare_import, or gaihen_status, so overall guidance is implied rather than complete.

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 filesystem side effect (folder + three .bat files) and the wait semantics, but says nothing about overwrite/idempotency behavior, required permissions, or errors if the folder already exists.

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

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

The description is compact, front-loads the primary action, and then unpacks each parameter in a single clause. No filler, though the parameter glossary reads as a flat list rather than tightly flowing 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?

For a mutating setup tool with no output schema and no annotations, the description covers what is created and what each argument means, but omits overwrite behavior, prerequisites, and success/failure signaling, which are relevant for a first-time setup step.

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: exchange is defined as a machine-local folder with its default and env fallback, win_exchange as the same folder as seen from the Windows PC with a concrete example, and wait as the response timeout in seconds.

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: creating an exchange folder and three named .bat files (JWMCP_send / send_all / import) for Jw_cad 外部変形. It's clear what the tool does, though it does not explicitly position itself against siblings like gaihen_status or gaihen_prepare_import.

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

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

There is no explicit when-to-use, prerequisite, or when-not guidance. The setup intent is only implied by the name and the creation verb. An agent cannot tell from the text whether this must run once before the other gaihen_* tools or can be re-run safely.

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 the full behavioral burden. It implies a read-only inspection but never states that it is non-mutating, what permissions/auth it needs, or how the output is shaped — for a status endpoint this is thin but not misleading.

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 fragment that front-loads the subject ('Bridge status') followed by a colon-delimited list of reported items. No filler, though the fragmentary style is terse rather than polished.

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

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

With no output schema, the description usefully enumerates the three things the status returns, which partially compensates. However, it leaves the single input parameter undefined and gives no usage context, so an agent still lacks what it needs to invoke 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?

There is one optional 'exchange' parameter with 0% schema description coverage, and the description never explains what it does. The phrase 'exchange folder' only loosely hints that the parameter might filter or target a folder; format, defaults, and behavior remain undocumented in both schema and 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 names the resource (the bridge status) and enumerates exactly what it reports: exchange folder, pending jobs from Jw_cad, and unconsumed responses. That is specific enough for an agent to know it is an overview/status tool, though it never explicitly differentiates itself from the closely related sibling gaihen_jobs.

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 when-to-use guidance, no prerequisites, and no named alternative. Given the crowded gaihen_* family (gaihen_jobs, gaihen_read, gaihen_preview), it is unclear when an agent should call gaihen_status instead of gaihen_jobs to inspect pending jobs.

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 does not state that this is a read-only operation, whether it hits the network or filesystem, what happens on malformed input, or that results are paginated despite limit/offset parameters existing. It adds almost nothing beyond the bare action.

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

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

A single front-loaded sentence with the verb and resource first; there is no filler. It is arguably too terse rather than bloated, and the parenthetical example is the only mildly expendable 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 no annotations, no output schema, 0% parameter coverage, and unmentioned pagination parameters, the definition is underspecified for a parsing tool that produces entities. An agent knows what it does but not how to call it safely or how to handle the returned/paginated data.

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% across three parameters. The description only loosely implies that 'path' points at a JWC_TEMP.TXT file and says nothing at all about limit/offset, which appear to be pagination controls with defaults 500/0 — a notable omission an agent would need to know to page through large files.

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

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

The description gives a clear verb ('Parse'), a specific resource ('JWC_TEMP.TXT-format file'), and names the output ('into entities'), which is more informative than most siblings. It does not, however, explicitly distinguish itself from related siblings like drawing_import_jww, jww_info, or jww_to_dxf, leaving the agent to infer why one would parse a JWC_TEMP.TXT rather than import a JWW.

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 '(e.g. one saved manually from Jw_cad)' implies the intended context — a hand-saved JWC_TEMP.TXT file — which is genuinely useful scoping. But there is no explicit when-to-use versus alternatives, no stated prerequisites, and no indication of when parsing is preferable to the import/convert siblings.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose the return content in useful detail (including that the bounding box is in real mm), which substitutes for the missing output schema, but it says nothing about side effects, whether the file is modified, or failure modes such as a missing/corrupt .jww file. Read-only behavior is only inferable from 'return a compact summary'.

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

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

A single front-loaded sentence: action first ('Open a .jww file and return a compact summary'), then a tight colon-delimited list of returned fields. No filler, 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?

The tool is low complexity (one parameter, no nested objects) and the description does the work the absent output schema would otherwise do by enumerating the summary fields. What is missing is failure/error behavior and any path expectations, which for a file-opening tool is a real but modest 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% for the single required 'path' parameter. The description only implies that path identifies a .jww file; it does not state expected format (relative vs absolute), whether the file must exist, or any constraint. Minimal added value over the bare string 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 (open) and resource (.jww file) plus an explicit, enumerated summary scope: version, paper, layer groups with scale, entity counts, bounding box, text sample. That enumeration naturally separates it from jww_texts (text extraction), jww_preview (rendering) and jww_query, so an agent can route 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 only implied: the description makes clear this is the metadata/summary inspection tool, so an agent knows the general context in which to reach for it. There is no explicit when-to-use statement, no exclusion, and no pointer to alternatives like jww_query or drawing_info for deeper inspection.

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 does disclose the meaningful behavior: the tool returns an image, bbox is in real mm and zooms, lg restricts to one layer group. It says nothing about permissions, whether out_png writes a file to disk, or whether the operation mutates anything, so a full transparency credit is not earned.

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 tight clauses, front-loaded with the core action, then the two pieces of non-obvious parameter semantics, then a one-line usage cue. No filler sentences; every clause carries 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?

A 6-parameter render tool with no annotations, no output schema, and 0% schema coverage needs the description to fill more gaps. Return-value guidance is adequate ("return the image"), but out_png, width_px, and show_text are left entirely for the agent to infer.

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% across 6 params, so the description must compensate. It explains the two non-obvious ones well — bbox's coordinate order and mm units, and lg's layer-group meaning — but says nothing about out_png (which implies a file write), width_px, or show_text, leaving half the parameters undocumented in both places.

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+output: render a .jww (or a region) to PNG and return the image. That is clearly distinguishable from lookup siblings like jww_info and jww_query. It stops short of explicitly naming an alternative sibling, so it is clear but not sibling-differentiated.

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?

"Use this to *see* the drawing" gives implied usage and subtly signals the visual-vs-textual split with siblings. There is no explicit when-to-use vs when-not, and no named alternative (e.g. drawing_preview or gaihen_preview) for the agent to route between.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that coordinates are in real millimeters and that results are paginated, but omits whether the operation is read-only, permission needs, and default limit/offset values that affect result volume. More disclosure is warranted for a query tool with zero annotation coverage.

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 tight paragraph, front-loaded with verb and resource, then filters, then pagination. Every clause carries information and there is 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 an 8-parameter query tool with no annotations and no output schema, the description covers filtering well but leaves the return shape, default pagination values, and read-only nature unstated. It is adequate but not complete for an agent to 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 coverage is 0%, so the description must compensate, and it largely does: it names the valid type values (line, circle, arc, text, point, solid, dimfigure), explains lg/ly as layer group/layer, gives the bbox ordering [min_x,min_y,max_x,max_y], and identifies pattern as a regex on text. Only path and the limit/offset defaults are left implicit.

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 (query) and resource (entities of a .jww file), with the scope qualifier 'real-mm coordinates'. An agent can distinguish this as an entity-extraction tool from siblings like jww_info, jww_texts, or jww_preview, though it never names those alternatives 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?

Usage is only implied through the enumerated filter options (types, lg, ly, bbox, pattern), which tells the agent what can be narrowed but not when to prefer this over jww_info, jww_entities, or jww_texts. No when-to-use/when-not guidance or alternatives 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 full burden. It doesn't disclose whether the operation is read-only, how results are ordered or paginated, what happens with empty files, or any permission requirements. A read-only list operation is likely, but not stated.

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 compact sentence that front-loads the core action and resource. Efficient, though it packs return-field detail into a tool-definition slot where parameter documentation would be more valuable.

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 4-parameter tool with zero schema description coverage, no annotations, and no output schema, the description is too thin. It should at minimum explain path, limit, pattern, and lg, and indicate the operation's safety profile.

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 document the four parameters, but it only alludes to a subset via 'position, layer and size' – which are return fields, not parameters. The params path, lg, limit, and pattern go entirely 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?

States a specific verb (list) and resource (text strings of a .jww file), plus examples of content types (room names, dimensions, notes). It does not explicitly differentiate from the sibling scan_texts or jww_query, but the .jww-specific scope is clear.

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

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

Usage is implied by the verb and scope, but there is no explicit guidance on when to use this vs. jww_query, scan_texts, or drawing_entities. The agent must infer the right choice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool returns the output path, but does not cover permissions, whether it overwrites files, error conditions, or side effects. The mention of 'using ezjww' is implementation detail, not behavioral context an agent needs for invocation.

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

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

The description is a single efficient sentence that front-loads the conversion action and mentions the default. It is concise, though it could be slightly more informative without being verbose.

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 3-parameter conversion tool with no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It should clarify parameter roles, return behavior, and any prerequisites. The current description leaves significant 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 description coverage is 0%, so the description should compensate but does not. It mentions a default version 'AC1024' but does not explain the 'path' parameter (input file path) or 'out' parameter (output file path). An agent cannot infer the meaning of these parameters from the description alone.

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+resource: 'Convert a .jww to DXF.' It also mentions the default output version and the library used, which distinguishes it from sibling tools like drawing_import_jww or jww_info. This is clear and actionable.

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

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

No explicit guidance on when to use this tool versus alternatives such as drawing_import_jww or drawing_export. The description only states what it does, not the context or prerequisites for choosing 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 the payload content ('group/layer names and per-type defaults') and the read-only nature is implied by 'List', but nothing is said about ordering, whether presets are project- or installation-scoped, or whether the catalog can change. Adequate but not rich, and it is a harmless zero-parameter read so the risk is low.

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, and the most decision-relevant information (what is listed and where it can be used) is front-loaded.

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 zero parameters, no output schema, and no annotations, the description is the only source of information and it covers purpose, output categories, and consumer tool. It is slightly thin on the shape of the returned records ('per-type defaults' is vague), but nothing essential for calling the tool is missing.

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

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

The tool takes no parameters, so the baseline is 4. The description uses the sentence well by explaining what the parameter values it returns are for, linking preset names to drawing_new's preset argument, rather than wasting space documenting nonexistent inputs.

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?

Specific verb ('List') plus a precise resource ('layer presets'), and it names the consuming call (drawing_new(preset=...)), which lets an agent place it among the many *list siblings. It stops just short of an explicit contrast with sibling list tools like drawing_list or scan_list, all of which are structurally similar.

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 'usable in drawing_new(preset=...)' effectively states the use case: call this to discover valid preset values before invoking drawing_new. It does not state any when-not condition or alternative source of presets, but the implied workflow is unambiguous.

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 burden. It discloses mode alternatives and the origin_px default (bottom-left), but says nothing about whether calibration overwrites prior values, persistence, or effects on later operations—material gaps for a mutation 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?

A single dense paragraph front-loaded with the core purpose and mode options; every clause is functional. The parenthetical 'scale=<denominator>' and paper note are slightly cryptic but 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 9 params, 0% schema coverage, no annotations, and no output schema, the description covers the calibration modes well but leaves 'page' behavior, mutation/overwrite semantics, and any result info unaddressed—gaps that matter for a state-changing 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 coverage is 0% across 9 params, so the description must compensate. It meaningfully explains p1, p2, distance_mm, px_per_mm, scale, paper, and origin_px, covering 7 of 9. It omits any meaning for 'page' (relevant for multi-page PDFs) and leaves scan_id implicit.

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 precise verb+resource: 'Define how pixels map to real mm.' An agent can tell this is a calibration operation, distinct from conversion tools like scan_px_to_mm. No sibling is named, so it stops just short of explicit differentiation.

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 lays out the three mutually exclusive calibration modes (p1/p2+distance_mm, px_per_mm, or scale+paper), which is genuine invocation guidance. It does not say when this tool is needed versus scan_open/scan_px_to_mm or what prerequisites must exist first.

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, and it discloses almost nothing: whether "opened" means in-memory/session state versus persisted files, whether this requires a prior scan_open, or whether results are paginated. A single read-only-sounding sentence is insufficient disclosure for a tool whose state semantics are the main question.

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 short, front-loaded sentence with no filler or redundancy. It is efficiently structured, though its brevity is under-specification rather than disciplined conciseness.

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 list tool with no output schema, the description should at least indicate what is returned and what "opened" scopes to. It is minimally viable but leaves the central ambiguity (session-scoped vs. all scans) unresolved.

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

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

The tool takes zero parameters and the schema is trivially complete, so the baseline is 4. There is no parameter syntax the description could add.

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?

"List opened scans" names a verb and resource, so the basic action is discernible, but the qualifier "opened" is never defined and no sibling (scan_open, scan_view, scan_texts, drawing_list) is referenced to distinguish this list from other enumerations. The purpose is implied rather than stated precisely.

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 when-to-use guidance, no prerequisite (e.g., must a scan be opened first via scan_open?), and no mention of alternatives among the many scan_* siblings. The agent must infer everything about 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 must carry the full behavioral burden. It does disclose a real side effect (page rendering to PNG) and the return content (page sizes, vector/raster classification), which is useful. It omits whether files are written to disk, permission/format constraints, rate limits, and any session 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?

Three compact sentences, front-loaded with the core action and outcome, then the branching rule. No filler, no restatement of the tool name.

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

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

No output schema exists, and the description partially compensates by naming the return values (page sizes, vector vs raster flag). However, for a 4-parameter, 0%-coverage opening tool with no annotations, the missing semantics of scan_id and dpi leave an agent guessing about session reuse and render resolution.

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% across all four parameters, so the description is the only source of parameter meaning — yet it mentions none of path, dpi, pages, or scan_id explicitly. 'Pages are rendered' weakly hints at a pages selector, but dpi and especially scan_id (likely the session handle reused by the other scan_* tools) are left entirely 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?

States a specific verb (open) and resource (scanned drawing / PDF or image) plus the concrete outcome (pages rendered to PNG for CAD conversion). It also routes the agent to the correct sibling depending on file type (scan_vector_import vs scan_view), so it is distinguishable from siblings without opening schemas.

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

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

The description clearly frames this as the entry point that produces either a vector or raster result and names the correct follow-up tool for each branch. It does not state prerequisites (e.g., required format support, file size limits) or when to prefer scan_list instead, so it stops short of explicit when/when-not 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?

No annotations provided, so the description carries full burden. It mentions a calibration prerequisite, which is valuable, but says nothing about side effects, whether it renders or generates an image, or what happens with invalid scan_id. Behavioral disclosure is thin.

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

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

Very short and front-loaded with the main action. The parenthetical calibration note and the region_px comment are packed in, though slightly terse.

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 6-parameter tool with no annotations, no output schema, and 0% schema description coverage, this description is far too sparse. Key parameters and the rendering/output behavior are undocumented.

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 briefly explains region_px ('zooms') and draws attention to calibration, but leaves page, alpha, width_px, drawing, and scan_id entirely unexplained despite 6 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?

States a specific verb and resource: draw/overlay a drawing on a scan to check alignment. It's distinguishable from siblings like scan_view or drawing_preview. Slightly informal ('Draw a drawing') but the purpose is clear.

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

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

Only hints usage via 'needs calibration', pointing implicitly at scan_calibrate, but gives no explicit when-to-use vs scan_view/scan_preview alternatives. An agent could confuse this with other scan rendering 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. It does not state whether an uncalibrated page errors, whether supplying both px_points and mm_points is invalid, precedence rules, or what the response shape is — all material for a coordinate-transform 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?

A single front-loaded sentence with the core verb and resource first, and the reverse-mode hint parenthesized. No filler, though the brevity comes partly at the cost of necessary detail elsewhere.

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

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

With no annotations, no output schema, and four parameters at 0% schema coverage, the description leaves the agent without error behavior, return format, or the meaning of half the parameters. It is too thin for a geometry-transform tool that depends on prior calibration state.

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 only partially does: it explains the roles of px_points and mm_points (input/output direction). It says nothing about the required scan_id or the page parameter and its default of 1.

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+resource ('Convert pixel positions ... to real mm') and even notes the reverse direction via mm_points, so the agent knows exactly what the tool computes. It does not differentiate from siblings, but no sibling competes for this conversion job.

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?

'on a calibrated page' implies the prerequisite that calibration must precede use, and naming mm_points implies the reverse-direction mode. However, there is no explicit when-to-use/when-not guidance, no mention of what happens on an uncalibrated page, and no named alternative for related scan operations.

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 does disclose a key limitation—only works on vector PDFs—and indicates the return format includes pixel and mm positions. However, it omits whether this is a read-only operation, any authentication or permission requirements, error behavior, or pagination. The disclosure is minimal.

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 fragmentary sentence with no clear structure or front-loading. While it is short, it is under-specified for the task and lacks the essential parts of a tool definition, such as an action verb and parameter 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 no output schema, no annotations, and 0% parameter description coverage, the description is far from complete. It provides a vague hint about return values (text with positions) and a vector PDF limitation, but an agent lacks the information needed to invoke the tool correctly, such as what scan_id represents or how to handle non-vector PDFs.

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 two undocumented parameters. It hints at the 'page' parameter by mentioning 'a PDF page', but gives no details on its default or valid range. The required 'scan_id' parameter is not mentioned at all, leaving a critical 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 is a noun phrase that restates the tool name ('Text strings embedded in a PDF page') rather than stating an action. It adds some detail about pixel/mm positions and a vector PDF constraint, but never uses a verb to clarify what the tool does (extract, list, return). Compared to siblings like scan_view or scan_px_to_mm, it is unclear whether this retrieves, extracts, or lists text.

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 when-to-use guidance, no alternatives, no prerequisites are mentioned. The agent is left to infer that this tool should be called instead of scan_view or other scan tools, with no explicit context or 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?

With no annotations, the description carries the full behavioral burden. It adds useful context: region_px limits the area, line properties are set via lg/ly/lc/lt, and tag enables later removal. But it omits whether the operation is destructive to existing drawing contents, permission requirements, 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?

Three sentences with the core purpose front-loaded and no wasted verbiage. It is tightly written, though the parameter explanations are compressed into a single clause that reduces clarity.

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

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

For a 12-parameter mutation tool with no annotations and no output schema, the description is too thin. It omits prerequisites (e.g., whether the scan must be calibrated or open), the effect on existing drawing entities, and the semantics of most parameters.

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 region_px, lg/ly/lc/lt, and tag, but leaves scan_id, drawing, page, solid_ly, min_len_mm, and include_solids completely undocumented. The meaning of lg/ly/lc/lt is also only gestured at ('set ... for the imported lines') without explaining what each controls.

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 ('import'), resource ('page's line work'), destination ('into a drawing as lines'), and unit conversion ('real mm'). It also clearly scopes the tool to vector PDFs exported from CAD, distinguishing it from sibling tools like scan_texts and scan_overlay.

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 a clear usage condition ('For vector PDFs (exported from CAD)'), which helps an agent choose this tool over raster-based or text-focused siblings. However, it does not explicitly state when not to use it or name a concrete alternative for different PDF types.

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 a behavioral trait beyond the schema: a red pixel ruler is rendered over the output for coordinate reporting. It does not state that this is a read-only/non-mutating operation, nor what the return artifact is (image?), which matters for an agent deciding how to consume the result.

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

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

Two tight sentences with no filler; the core action is front-loaded and the region syntax follows immediately. Slightly dense, but every clause contributes.

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?

No annotations and no output schema, with only 1 of 5 parameters documented, so the description is the sole source of context. It covers the viewing purpose and the ruler/coordinate rationale well, but omits what max_px and grid control and what the tool returns, leaving meaningful gaps for an agent.

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 does resolve the trickiest parameter, defining region as [x0,y0,x1,y1] and clarifying the dual pixel/fraction units. It leaves grid, page, max_px, and scan_id entirely unexplained, so four of five parameters 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 ('Look at') and resource (a page or zoomed region of a scan), which is clearly distinct from mutation siblings like scan_calibrate or scan_overlay. It does not explicitly name which sibling it replaces, but the purpose is unambiguous.

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

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

It hints at context by saying the ruler exists 'so you can report pixel positions for scan_calibrate / placement,' which implies this is a step preceding calibration. However, it never states when to use this versus scan_overlay, scan_preview, or scan_calibrate directly, nor any preconditions (e.g., scan must be opened first).

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