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 valuable context: steel material, BOM part number/description being set, nominal modeled size without threads, and geometric meaning of position/direction, but it does not state mutation side effects, validation behavior, or failure cases.

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

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

The description is front-loaded with the core action and then supplies dense, useful details without redundant restatement. It is slightly cluttered as a single long paragraph, but every clause earns its place.

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

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

Given no annotations, 0% schema descriptions, and an output schema present, the description is largely complete for correct invocation: it defines the tricky geometry and key parameter rules. It lacks sibling-routing guidance and explicit mutation side effects, which keeps it from being fully complete.

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

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

Schema description coverage is 0%, so the description must explain parameters, and it does so for the most ambiguous ones: kind enum values map to ISO standards, length is mm under the head and required for bolts, and position/direction are defined geometrically. It leaves doc and name largely unexpanded, though those are comparatively obvious.

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 specific verb and resource: generating a parametric ISO-style fastener, with four concrete fastener kinds mapped to standards. It is clear what the tool does, but it does not explicitly distinguish itself from siblings such as add_primitive or insert_library_part.

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

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

It provides useful parameter-usage guidance, including that length is required for bolts and how position/direction should be interpreted. However, it does not say when to use this tool versus alternatives such as add_primitive, insert_library_part, or hole, nor does it state 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?

Although no annotations are provided, the description discloses key behavioral conventions: units are millimetres, default position is the origin, rotation defaults to 0 about Z, and each shape's origin is defined (box min corner, cylinder/cone base circle centre). It does not mention document-state requirements or failure behavior, but the geometric creation semantics are unusually well specified.

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

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

The description is dense but front-loaded, starting with the core action before geometry details. Every sentence conveys necessary parameter semantics or coordinate conventions, with no filler.

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

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

The tool has an output schema, so return-value explanation is unnecessary, and the description is complete enough to call the tool correctly for most parameters. It does not cover sibling selection or document-state expectations, but the critical nested dimensions and coordinate semantics are present.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, and it does: it maps dimensions keys per shape, defines position anchor semantics and rotation defaults, lists valid material values, and gives the color component range. It provides exactly the semantics the schema does not.

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

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

The description opens with a specific verb and resource: "Add a primitive solid," and immediately enumerates the supported primitive shapes. This distinguishes it clearly from siblings like import_step, extrude_polygon, and boolean without requiring the agent to inspect the schema.

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

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

Usage is implied by "Add a primitive solid" and the shape list, but the description does not say when to choose this over import_step, insert_library_part, extrude_polygon, or other modeling siblings. There are no explicit alternatives or exclusions.

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

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

With no annotations, the description carries the full load and does well: it discloses the merge rule (part_no+material+description, quantities summed), the side effect of writing CSV and Markdown files, and the mass derivation formula. It doesn't say whether existing files are overwritten or what happens when metadata is missing.

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 sentences, front-loaded with the core purpose, then behavior, then outputs and the mass formula. No filler, though the parenthetical field list slightly interrupts the flow.

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?

Outputs are covered by the output schema, so the return-value summary is a bonus. However, for a tool that writes files and has an undocumented `objects` parameter, the definition leaves material gaps an agent would need to guess at.

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 only indirectly explains `doc` via the output path (workspace/bom/<doc>/) and says nothing about `objects` — whether it filters to a subset of parts or defaults to all objects in the document.

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: builds a bill of materials from object metadata, with explicit merge/sum rules and file outputs. It is clearly distinguishable from siblings like mass_properties or export, though it doesn't name 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?

Implies a prerequisite by naming the set_properties fields (part_no, description, material, supplier, quantity) that must be populated first, and by scoping outputs to workspace/bom/<doc>/. But it never states when to prefer this over export or mass_properties, nor any exclusions.

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

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

With no annotations present, the description carries the safety burden and does so well: it discloses the destructive default (inputs deleted unless keep_inputs=true), where the result lands (result_name), and that material is inherited from the base. It does not cover failure modes (non-solid bodies, empty intersection) or which document the inputs/result must live in.

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?

Four tight sentences, front-loaded with purpose before operations, then side effects, then the practical caveat. Every sentence carries distinct information with no repetition of schema structure.

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

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

An output schema exists, so return values need not be described; the description instead covers the operation matrix, destructive behavior, result naming, material inheritance, and the main geometric pitfall. That is sufficient for an agent to invoke this six-parameter tool correctly.

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

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

Schema coverage is 0%, so the description must compensate, and it explains the semantics of base, tools, operation, keep_inputs, and result_name — five of six parameters. Only 'doc' is left implicit, which is a minor gap given its self-evident meaning.

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

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

Opens with a specific verb+resource ('Boolean combine objects') and then defines all three operation modes in terms of base and tools. No sibling tool performs boolean operations, and the description makes that scope 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?

Clearly states the condition for each mode (cut, fuse, common) and gives a practical usage caution about coplanar/tangent tool faces with a concrete remedy. It does not, however, name any alternative tool or exclusion (e.g., when to use 'hole' or 'pocket' instead of a cut).

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 mutation on a solid, but it does not explain whether the solid is modified in place or a new result is created (`result_name`), what happens if `edges` is null, or what permissions/state are required.

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

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

Two short sentences are front-loaded with the core operation and key parameter semantics, with no filler. Every clause contributes directly to understanding what the tool does.

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

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

An output schema exists, so return values need not be explained. But for a five-parameter mutation tool with no annotations and no schema descriptions, the definition omits too much: target solid naming, edge defaults, result behavior, and prerequisites are all unspecified.

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

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

Schema description coverage is 0%, so the description must compensate for five undocumented parameters. It clarifies `size` as an equal-distance bevel in millimeters and loosely explains `edges` via fillet rules, but `doc`, `name`, and `result_name` remain undefined, leaving most parameter semantics unresolved.

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 CAD operation — beveling (chamfering) solid edges — with the governing dimension (`size` mm, equal distance). It also differentiates edge selection from the sibling `fillet` by saying the rules are the same, so an agent can distinguish chamfer from fillet immediately.

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 references the sibling `fillet` for edge-selection behavior, which gives useful context. However, it does not say when to choose chamfer over fillet, what prerequisites exist (e.g., needing an existing solid), or when not to use the 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 burden and does disclose the key behavioral traits: exactness, that results are threshold-filtered and sorted by distance, that closest points are included, and that 0 means touching/overlapping. It omits cost characteristics of an exact all-pairs comparison and any auth/permission context.

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

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

Two sentences, no filler, with the core behavior (all-pairs minimum distance, exact) front-loaded and the interpretive caveat plus sibling pointer trailing it.

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

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

An output schema exists, so return structure needn't be spelled out, and the description still covers threshold semantics and the ambiguity of zero distance. The remaining gap is that a 3-parameter tool leaves objects entirely unexplained and gives no sense of computational cost for a non-annotated analysis call.

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 define report_below_mm's meaning (pairs closer than that threshold) but never mentions the objects parameter, which silently scopes which solids are compared, and gives no hint about the required doc argument.

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?

Names a specific verb and resource: computes the exact minimum distance between every pair of solids and returns sub-threshold pairs sorted with closest points. It also explicitly separates itself from check_interference ("use check_interference for volume"), so an agent can route between the two without opening either 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?

Explicitly routes the volume/interference case to check_interference and explains what distance 0 means, which is a genuine usage cue. It does not say when to narrow the search with the objects parameter or when this check is unnecessary, so guidance is strong but not 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 and largely meets it: it discloses the two-stage algorithm, the threshold-based reporting rule, the zero-volume exclusion, and the meaning of the `clean` result. Not disclosed are cost/performance on large assemblies or that the operation is non-destructive (only implied).

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 sentences, front-loaded with the operation, then the threshold rule, then the exclusion and result flag. No filler, and the return-detail clause stays brief.

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

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

An output schema exists, so return-shape explanation is not required, and the description still adds result semantics usefully. For a three-parameter geometric query the only real omission is the meaning of `objects` and any note on cost, which keeps it from a 5.

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

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

Schema description coverage is 0%, so the description must explain all three parameters. It only explains `tolerance_mm3` (pairs above it are reported). `doc` and especially the optional `objects` list — which presumably restricts the tested solids, though the text says 'every pair of solids' — are never mentioned or reconciled with the described behavior.

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

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

States a precise verb and resource ('Pairwise interference test' on solids) plus the exact method — bounding-box prefilter followed by intersection-volume computation. This distinguishes it clearly from volumetric/clearance siblings such as check_clearance without needing to name 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?

Gives a clear usage condition implicitly (every pair whose bounding boxes touch) and an explicit exclusion: 'Face contact (zero volume) is not interference.' It also defines the success signal (`clean: true`). It stops short of routing the agent between this and a clearance check, which would be the fifth point.

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

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

With no annotations, the description carries the burden and does well: it explains plane orientation/normals, offset direction, construction-geometry semantics, and that closed loops become faces with nested loops becoming holes. It also explains the return signal (closed/open wire counts, DOF 0 = fully constrained). It omits that this mutates the document by adding an object, and says nothing about required preconditions or failure modes.

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

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

Verb and resource are front-loaded, and the dense geometry/constraint reference is justified by the empty schema. The block is cramped and run-on in places, but almost every clause carries operational detail rather than filler.

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

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

For a complex 6-parameter tool with an output schema and no annotations, the definition covers the hard parts: the geometry DSL, constraint vocabulary, and DOF interpretation. Gaps remain around `doc`/`name` semantics, document-existence preconditions, and the fact that a new object is added to the document.

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 largely does: `plane` values are mapped to world axes and normals, `offset` direction is defined, and the geometry and constraint item shapes are spelled out field-by-field including index and point-id conventions. Only `doc` and `name` go undefined, though their meaning is largely self-evident.

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

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

The opening sentence names a specific verb and resource ("Create a 2D sketch") and immediately qualifies it with the engine (FreeCAD Sketcher with a real constraint solver), which separates it from add_primitive and the downstream solid features. An agent can tell this is the 2D-profile entry point rather than a 3D operation.

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

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

The closing line "Next: pad, pocket, revolve, loft or sweep" explicitly positions this tool as the prerequisite for the sibling feature tools, which is real routing guidance. It stops short of saying when NOT to use it (e.g. versus add_primitive for a quick 3D shape) or what prerequisites like an existing `doc` are required.

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

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

With no annotations, the description carries the full disclosure burden. It implies a destructive mutation but says nothing about reversibility (undo exists as a sibling), cascade effects on dependent features/assemblies, required permissions, or confirmation behavior. For a delete operation this is a significant omission.

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 zero waste, but its brevity comes from under-specification rather than discipline. It earns its place as a purpose statement but nothing more.

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 destructive 2-parameter tool with no annotations and 0% schema coverage needs substantially more explanation of target identification and consequences. The output schema does relieve the description of return-value detail, but the mutation semantics and parameter meaning remain unexplained.

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 neither 'doc' nor 'name' is documented structurally. The description only loosely gestures at them ('one object', 'the document') without explaining whether 'name' is an object identifier, whether it is case-sensitive or path-qualified, or how 'doc' is referenced. The description does not compensate for 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?

The verb 'Delete' and resource 'object' are stated, but 'object' is ambiguous in a CAD context (solid body, feature, sketch, face?) and the description gives no differentiation from siblings such as list_objects, object_history, or undo. An agent knows it removes something, but not precisely what class of entity.

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

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

There is no guidance on when to use this versus alternatives — notably undo (which may reverse a deletion) or other modifier tools. No prerequisites, no mention of what happens to dependent features, no exclusions. The agent must infer everything from the verb alone.

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

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

With no annotations, the description carries the full burden; it does disclose the returned data set and implies a passive read, but says nothing about permissions, whether it mutates state, or performance characteristics. It stops short of the behavioral context expected of an unannotated tool.

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

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

One compact sentence that front-loads the resource and lists payload contents with no filler. Efficient, though it could be organized as purpose plus parameter note.

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

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

An output schema exists so return values needn't be explained, and the description broadly matches it. The remaining gap is the undocumented 'doc' parameter, which is the only thing the agent truly needs to supply.

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

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

Schema coverage is 0% and the description never clarifies what 'doc' is — document name, path, index, or object handle. For the sole required parameter, that ambiguity is a real invocation risk.

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 resource (a document) and enumerates exactly what the summary contains (file size, object names, bounding box, undo depth, last 5 operations). It reads as a read-only inspection tool, distinguishable from mutation siblings like transform or boolean, though it doesn't explicitly separate itself from list_history/object_history.

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 call this versus list_history, object_history, list_objects, or list_documents, and no prerequisites or context given. The agent must infer usage from the field list alone.

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

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

With no annotations, the description carries the full behavioral burden. It usefully states the output directory pattern, default object selection, supported formats, and that an absolute path is returned, but it omits overwrite behavior, permissions, error conditions, and whether existing files are replaced.

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 short sentences, front-loaded with purpose and scope. Every sentence adds useful information: supported formats, return path, and the DXF sibling alternative.

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

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

An output schema exists, so return-value explanation is not strictly required, though the description still gives the return path. The main remaining gap is filename and overwrite behavior, which is relevant for a file-exporting tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explains fmt by listing supported formats and explains objects by stating the default-all-solids behavior, but it does not clarify doc or filename semantics.

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 (export objects) with explicit scope details: default all solids, supported formats, output directory, and returned path. It also distinguishes itself from export_dxf by naming the DXF alternative 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?

Gives clear usage context by specifying that objects default to all solids and by routing DXF/laser-cutting use to export_dxf. The alternative and its selecting condition are stated explicitly.

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 disclosure burden and does well by stating the output format, DXF entities used, units (mm), and save location under `workspace/exports/<doc>/`. It does not mention overwrite behavior or permissions, so it stops short of full behavioral transparency.

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

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

The description is front-loaded with the purpose, then explains modes and output details in dense, useful sentences. 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?

Given the output schema exists, return values need not be described, and the description adequately covers the core invocation modes, units, entities, and save path. Remaining gaps around `name`/`filename` and overwrite behavior keep it from being fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It usefully explains `face` and `plane` + `offset` semantics, including coordinate frame and cross-section meaning, but leaves required `name` and optional `filename`/`doc` largely undefined.

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 specific verb and resource ("Export a 2D DXF outline") and names the intended use case (laser/waterjet cutting). It is clearly distinguishable from the generic sibling `export` because it specifies 2D DXF cutting output.

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

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

It explicitly presents the two invocation modes: `face` for one planar face or `plane` + `offset` for a cross-section. It does not explicitly compare against sibling tools, but the mode-selection guidance is clear.

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

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

No annotations, so the description carries the full burden, and it discloses genuine behavioral traits: coordinate-to-axis mapping per plane, direction of extrusion, that offset applies along the extrusion axis before the extrude, and that holes are cut out of the profile. It omits what doc/name/color/material do and what happens on self-intersecting or open polygons, which is a real gap for a 9-parameter geometry mutation.

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 verb and units, then plane conventions, then offset/holes semantics, and it closes with a concrete L-bracket example that carries real information about ordering and closure. Dense and largely waste-free, though the plane sentence is a run-on that could be tabulated.

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

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

An output schema exists, so return values needn't be explained, and the geometry semantics that determine correctness (plane, axis, offset, holes, point ordering) are all present. Missing identification of doc/name/color/material and any statement of validity constraints or failure behavior keeps it from 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 coverage is 0%, so the description must compensate, and it explains 5 of 9 parameters meaningfully: points (with the no-repeat-first-point rule), height (mm), plane (enum values each spelled out with axis mapping), offset, and holes. doc, name, color, and material are not addressed anywhere, leaving roughly 45% of 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+resource: 'Extrude a closed 2D polygon' with explicit units (height mm), and it implies the difference from a sketch-based sibling like pad by accepting an inline point list. It never names a sibling (pad, pocket, revolve), so an agent still has to infer the boundary itself.

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

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

Usage is only implied by the shape of the input: pass points in, get a solid body out. There is no statement of when to use this over pad/revolve/loft, no prerequisites (does a document need to be open, is a name collision a problem), and no failure cases.

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 mutation semantics (in-place unless `result_name` is given) and a failure mode (radius too large for geometry yields a clear error). It does not say whether a new object is a copy of the original or what happens to the source object.

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?

Four short clauses, each carrying distinct information (action, edge reference, mutation mode, failure mode), with the core action front-loaded and no filler.

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

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

An output schema exists so return values need not be described, and the edge/failure/mutation context is present. The remaining gap is the undocumented required `doc` and `name` parameters, which an agent must guess for a 5-parameter tool.

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

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

Schema description coverage is 0%, so all five parameters rely on the description. It explains `edges` (1-based indices or selector string, default all), `radius` (mm), and implies `result_name` semantics, but leaves the required `doc` and `name` parameters 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 and resource ("Round edges of a solid") with the key unit (radius in mm). It is clearly distinguishable from the sibling `chamfer`, and it points at `list_edges` for the edge reference format.

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?

Gives concrete operating context: default is all edges, edge references come from `list_edges`, and in-place vs. new-object behavior is tied to `result_name`. It stops short of naming `chamfer` as the alternative when a bevel rather than a round is wanted.

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 real work: it discloses in-place modification of the named solid, the coordinate meaning of `position` and `direction` (into material), the through-all default, and the hard failure condition "Fails if no material was removed." It omits authorization/undo implications and return behavior, keeping it below a 5.

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 action and mutation scope, then parameter semantics, then the failure condition and pointer to list_faces. Dense and telegraphic, but nearly every clause conveys information an agent needs; the kind-condition shorthand is terse but parseable.

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

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

An output schema exists, so return values need not be explained. Given 10 parameters and no annotations, the description covers the risky and ambiguous parts well (direction, depth, kind variants, failure), leaving only minor gaps such as `doc` and diameter units.

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 non-obvious ones: position (surface start point), direction (into material with an example vector), depth (None = through all), and the kind-conditional cbore/csink parameters with the 90-degree cone detail. `doc`, `name` (only partly implied), and `diameter` remain undocumented.

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

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

States a specific verb and resource ("Drill a hole into solid `name`") plus the crucial in-place mutation scope. The operation is clearly distinct from siblings like pocket, fillet, chamfer, or boolean, so an agent can route 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?

Gives conditional guidance: `depth` None means through-all, counterbore requires cbore_diameter and cbore_depth, countersink requires csink_diameter, and it points to list_faces to find surface points. It stops short of saying when to prefer this over pocket or boolean for material removal, so no explicit alternative routing.

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

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

With no annotations, the description carries full behavioral burden and falls short: it doesn't say what happens if an object named `name` already exists (overwrite or error), whether the target `doc` must be open/active, how units or materials are applied, or what failure modes exist for a bad path.

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 filler, and the key constraint (absolute path) is placed early. It is efficient, though its terseness borders on under-specification rather than a structural flaw.

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 presence of an output schema relieves the description of return-value detail, but for a 4-parameter mutation tool with no annotations and 0% schema coverage, the description leaves too much (doc target, material handling, name collision behavior) 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 description coverage is 0%, so the description must compensate, yet it only clarifies `path` (absolute) and `name` (the new object). The required `doc` parameter and the optional `material` parameter are completely 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 ('Import') and resource ('STEP file'), plus the resulting side effect ('as a new object `name`'). It's clear what the tool does, but it offers no explicit contrast with related siblings such as insert_library_part or export.

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 indication of when to use this versus alternatives (e.g. insert_library_part, run_script, new_document), no prerequisites, no exclusions. The agent must infer usage 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 burden. It discloses that insertion may be followed by rotation/translation, but says nothing about what happens on a name collision, whether the insert is atomic, or what document state is required for a mutation of this kind.

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 the action and scope front-loaded, followed by the optional secondary step. No filler, nothing repeated from the schema.

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 mutating tool with no annotations, the description is thin: it omits the role of `doc`, the meaning of `material`, collision handling, and coordinate conventions. Return values need not be described since an output schema exists, but the invocation-side gaps remain significant.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate and largely does not. It covers `name`, `library_path` implicitly, and the rotation/position idea, but leaves `doc` and `material` undefined and gives no shape for `position`/`rotation_axis` or units for `rotation_deg`.

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: inserts a STEP file sourced from the parts library, names the resulting object via `name`, and points at list_library as the source of library paths. This reasonably distinguishes it from import_step (external file) and from transform, though it never says so 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 parenthetical '(see list_library)' routes the agent to the tool that produces `library_path`, and 'optionally rotate/translate it' hints at doing orientation inline rather than calling transform afterward. But there is no explicit when-to-use vs import_step, and no stated prerequisites such as an open document.

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

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

No annotations are provided, so the description carries the burden, and it does disclose the key behavioral distinction: fuse=false creates numbered copies while preserving the original, and fuse=true returns one solid containing all instances. It still omits permission requirements and failure behavior, but the main outcome semantics are well covered.

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

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

The description is three tight sentences: the first defines the operation, the second explains fuse semantics, and the third gives a typical use case. It is front-loaded and contains no filler.

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

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

An output schema exists, so return values need not be described. The description covers the critical mode distinction and a practical example, but for a seven-parameter CAD operation it could say more about doc, name, and direction format.

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 usefully explains count including the original, spacing in mm, direction, fuse output behavior, and result_name for copies, but it does not explain doc or name, leaving part of the seven-parameter surface 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?

The description states a specific verb and resource: repeat an object count times along a direction at a given spacing. It also distinguishes the two operating modes via fuse=false versus fuse=true, making the tool's purpose 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 gives a concrete typical use case: pattern a cylinder 'tool', then boolean cut it from a plate. This clarifies context, but it does not explicitly name alternatives such as polar_pattern or mirror when a linear pattern is not appropriate.

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

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

With no annotations, the description carries the full burden. It does disclose scope ('all documents in the workspace') and the fields surfaced (size, modification time), but says nothing about pagination, ordering, depth/recursion, or whether it includes only currently open documents. Useful but incomplete for an unannotated read 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 no filler; the resource and the returned fields are stated immediately. Nothing to trim.

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

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

An output schema exists, so return values need not be described, and with no parameters the calling surface is simple. The remaining gap is behavioral: ordering, pagination and recursion are unstated, which matters for a workspace-wide listing.

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 there is no parameter semantics to explain; baseline 4 applies. The description does not introduce any confusing claims about 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?

States a specific verb and resource ('List all documents in the workspace') plus the fields returned (size, modification time). It is distinguishable from the object-level siblings like list_objects and document_info, though it never explicitly contrasts itself with document_info, which also concerns a single document's metadata.

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 document_info, list_objects, or list_history. The only implicit cue is 'all documents in the workspace', which hints at bulk enumeration, but the agent must infer that on its own.

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 discloses the conjunctive selector behavior and describes what fields are returned, but it does not explicitly confirm read-only safety, permissions, invalid-selector behavior, or pagination handling.

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

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

The description is two compact sentences, front-loads the tool purpose and returned fields, then gives the selector grammar as a focused token list. There is no redundant or 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?

An output schema exists, so return values need less explanation, and the description still usefully clarifies output composition and selector semantics. The main gap is that required 'doc' and 'name' parameters are not described, but overall the definition is sufficient 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 must compensate for all parameters. It adds substantial meaning for the selector parameter through token grammar and examples, but the required 'doc' and 'name' 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?

The description states a specific verb and resource ('List edges') and immediately specifies the returned attributes: index, curve type, length, midpoint, direction or radius. This clearly distinguishes it from sibling tools such as list_faces, list_objects, and object_history.

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

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

It explains selector filtering semantics ('space separated, all must match') and gives concrete token examples, which is useful invocation guidance. However, it does not explicitly state when to use this tool versus list_faces/list_objects or when not to use a selector, so usage remains implied rather than fully guided.

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 well by disclosing return fields, index invalidation after edits, and detailed selector behavior. It does not explicitly confirm read-only operation or mention performance/rate limits, leaving some gaps.

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

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

The description is front-loaded with purpose, then moves to usage and selector details. Every sentence is informative and there is no wasted text; the example at the end is particularly helpful.

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

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

Given the tool's complexity (selector syntax) and the presence of an output schema, the description covers essential behavior: return fields, index invalidation, and selector usage. Minor gaps like handling of empty results are acceptable given the output schema.

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

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

Schema description coverage is 0%, so the description must compensate. It thoroughly documents the complex `selector` parameter with token syntax and examples, but does not explicitly explain the `doc` and `name` parameters, which remain implicitly understood.

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

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

The description states a specific verb and resource ('List faces of an object') and details what fields are returned (index, surface type, area, centre, normal/radius/axis). It does not explicitly name a sibling tool for contrast, so it falls short of the highest bar.

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 clearly indicates the primary use case: providing indices needed by run_fem and fillet, and warns that indices change after geometry edits, so re-listing is necessary. However, it does not state when not to use the tool or name alternative tools for face listing.

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 discloses the journal contents and newest-last ordering, but does not state whether the operation is read-only, whether permissions are required, or how the `limit` affects results.

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

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

The description is a single front-loaded sentence with no wasted text. It efficiently states the resource, contents, and ordering.

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

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

An output schema exists, so the description need not explain return values in detail. However, for a tool with no annotations and 0% schema description coverage, the description remains incomplete regarding the optional `limit` parameter and usage context.

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

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

Schema description coverage is 0%, and the description only implicitly identifies `doc` as the target document. It does not explain the `doc` parameter's expected format or the meaning and default behavior of the `limit` parameter.

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

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

The description states a clear resource: a journal of modifying operations applied to `doc`, with time, operation, and abbreviated arguments, ordered newest last. This is specific enough to understand what the tool returns, though it does not explicitly distinguish itself from the sibling `object_history`.

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 only explains what the history contains and its ordering. It gives no guidance on when to use this tool versus alternatives such as `object_history`, `undo`, or document inspection 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, so the description carries the burden; it does disclose the filesystem source, the env var and default path, and that matching is case-insensitive substring. It omits what happens if the library folder is missing/empty, whether the listing is recursive, ordering, or size limits — meaningful gaps for a filesystem-backed 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?

Two tight sentences: capability and scope first, filter and follow-up action second. The env var/default parenthetical earns its space by telling the agent where files actually come from.

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?

Output schema exists so return shape needn't be explained, and the description covers source, filtering, and the natural next call. Only the edge-case behavior (missing folder, recursion, sort order) is absent.

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

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

Schema coverage is 0% and the single param 'query' is undocumented in the schema, but the description compensates by defining it as a case-insensitive substring filter with a default of no filtering. That's the key semantic (substring, not glob/regex) the agent needs.

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+resource: lists STEP files (.step/.stp) in the local parts library, including where that library lives (FREECAD_MCP_LIBRARY, default ./library). It also names the sibling (insert_library_part) it feeds, so it's distinguishable from import_step and list_objects.

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

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

Explicitly frames the optional substring filter and directs the agent to use the returned relative path with insert_library_part, which establishes the lookup-then-insert workflow. It doesn't state when to prefer this over, say, list_documents or import_step, so not a full 5.

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

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

No annotations are provided, so the description carries the full behavioral burden. The word "List" strongly implies a read-only operation, and the description lists returned object attributes, but it does not explicitly confirm no side effects, state permissions, or mention pagination/performance behavior.

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

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

The description is two sentences, front-loaded with the core action and followed by a concise usage note. The returned-field list is relevant and no sentence 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?

An output schema exists, so the description need not fully document return values, and the usage note helps for a simple listing tool. However, with no annotations and 0% schema description coverage, the unexplained `doc` parameter leaves a meaningful gap 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?

The only parameter is `doc`, and schema description coverage is 0%. The description mentions "`doc`" but does not explain whether it is a document name, ID, handle, or object, so it adds little semantic meaning beyond the schema. This is a notable gap for a required parameter.

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

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

The description uses a specific verb, "List," and a clear resource, "every solid/shape object in `doc`," then enumerates the returned properties. It differentiates itself implicitly from siblings like list_faces, list_edges, and list_documents by focusing on solid/shape objects, though it does not explicitly name those alternatives.

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

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

It gives a clear usage context: "Use this to inspect state after each modelling step." That tells the agent when this tool is appropriate, but it does not state when not to use it or name specific alternative tools.

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

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

With no annotations, the description carries the full disclosure burden; it does contribute real preconditions (profiles must be closed, at least two, order matters) and the ruled/smooth distinction that the schema does not express. It says nothing about the mutation side though — whether a new body is created, whether input sketches are consumed, what happens on result_name collision, or what errors to expect from open profiles.

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 sentences, zero filler, with the core operation front-loaded and the optional modifier explained second. Nothing is repeated from the schema and every clause adds 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?

An output schema exists, so return values need not be explained, and the description covers the essential geometry semantics for a 5-parameter tool. What is missing is small but real: the role of `material`, the meaning of `result_name` in the document, and any failure behavior for invalid profile input.

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 all five parameters. It meaningfully explains `sketches` (closed profiles, ordered) and `ruled` (straight vs smooth transitions), but leaves `doc`, `material`, and `result_name` entirely to the bare titles — a substantive gap given no schema help. Partial compensation warrants a mid score.

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

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

The description opens with a specific verb+resource combination ('Loft a solid through two or more closed sketch profiles') and adds a scoping constraint (ordered profiles, minimum of two), which is enough to separate it from sweep, pad, revolve and the other geometry siblings. It stops short of explicitly naming which sibling to use instead for adjacent operations.

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

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

The example ('sketches on parallel planes with different `offset`') hints at the intended modeling situation, so usage is implied rather than merely absent. There is no explicit when-not-to-use condition and no pointer to sweep/revolve for alternative transition behaviors, so an agent must infer the boundary itself.

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

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

With no annotations, the description does real work: it discloses the side effect (writes SVG, PDF and PNG into workspace/drawings/<doc>/), the exact return payload (paths plus a PNG image), and the default scale-selection behavior. It does not say whether existing files are overwritten or how expensive the operation 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?

The core capability and the output guarantee are front-loaded in one dense sentence, followed by a short `scale` clarification. The title-block parenthetical lists details that could be trimmed, but overall it is efficient for the amount of information conveyed.

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?

Return values are fully covered in prose, so the absent output schema is not a gap. However, a 7-parameter tool at 0% schema coverage with only one parameter documented leaves an agent guessing about `doc` format, `objects` filtering and the effect of toggling `hidden_lines`.

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, yet the description explains only `scale` (paper:model ratio with an example and the default rule). The required `doc`, plus `sheet`, `author`, `objects` and `hidden_lines`, get no explanation at all, and the `objects` subset filter is a substantive omission.

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 a precisely specified resource: a third-angle engineering drawing with named views, hidden-line removal, dimensions, diameter callouts and a title block. It is clearly distinguishable from siblings like render_view, section_view and export_dxf, which produce different artifacts.

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 output description implies this is the tool for multi-view orthographic documentation rather than a presentation render or a raw export, but the description never names alternatives or states when not to use it. An agent must infer the routing decision from sibling names alone.

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

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

With no annotations, the description carries the full load and does well: it discloses units (g, mm, g*mm2), the reference frame for the inertia tensor (about the combined centre of mass, world axes), the density resolution precedence (per-object material, then material/density_kg_m3 overrides applied to all objects), and the degradation path when material is missing.

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 output quantities and their units are front-loaded in the first clause, followed by the density-resolution rules. It is dense but every sentence adds information; the only cost is a slightly run-on second sentence.

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

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

An output schema exists, so the description needn't enumerate return values, yet it goes further by specifying units and frames that matter for interpretation. Coverage of the density fallback is complete; the remaining gap is the scope semantics of the objects parameter and the doc handle.

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 partly does. It clarifies the semantics of material and density_kg_m3 (overrides applying to all objects) but leaves doc and objects unexplained, including what happens when objects is null or omitted.

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 exact computed quantities (volume, mass, centre of mass, inertia tensor) and their units, so an agent knows precisely what the tool returns. It stops short of naming how it differs from siblings like bom or document_info, which also surface physical/aggregate 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?

Usage is implied rather than stated: the description explains that density comes from each object's material unless overridden, and that objects without material report volume only, which implicitly tells the agent when results will be partial. There is no explicit when-to-use guidance, no mention of alternatives such as bom, and no statement of prerequisites for the referenced set_properties step.

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

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

With no annotations, the description must carry behavioral disclosure. It does explain the axial sliding (`axial_offset` in mm) and the `flip` direction reversal, which are key behavioral traits. However, it does not state that this mutates assembly constraints, what happens on invalid face selections, or whether the constraint persists across document changes.

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 tightly written sentences front-load the core operation, then add examples and workflow suggestions. Every clause adds useful information without repetition.

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

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

Given seven parameters, zero schema descriptions, and no annotations, the description covers the main mating semantics and a follow-up workflow. It still leaves gaps around `doc`, face identifier formats, failure behavior, and mutation side effects, so it is adequate but incomplete.

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

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

Schema description coverage is 0%, so the description compensates by explaining `moving`/`fixed` as parts and `axial_offset` as an axial slide in mm, plus `flip`. It does not explain `doc`, nor does it clarify the valid formats for `moving_face`/`fixed_face` (integer, array, or string identifiers), leaving key parameter semantics underdocumented.

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 precise verb and resource: making cylindrical faces of `moving` and `fixed` coaxial, with optional axial slide. It implicitly differentiates from `mate_faces` by assigning `mate_faces` to seating tasks while this tool establishes the coaxial alignment.

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

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

It provides clear usage context, including examples (`bolt shank`, `hole`) and a combined workflow with `mate_faces` followed by `check_interference`/`check_clearance`. It lacks explicit when-not-to-use conditions or failure caveats, but the intended scenario is clear.

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

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

With no annotations, the description carries the burden well: it explains the geometric effect, the sign convention for offset, the exact-one-face constraint, and optional rotation about the contact normal. It omits persistence/undo behavior and explicit error behavior when a face spec matches zero or multiple faces, keeping it from a 5.

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

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

Three sentences, front-loaded with the core operation, then constraints and the optional rotation. Every sentence adds useful information without repetition or padding.

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

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

For a relatively complex assembly-mating mutation with no annotations and an output schema, the description covers most call-critical behavior. It leaves the doc parameter and some operational prerequisites/error cases implicit.

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 the roles of moving and fixed, the units and sign meaning of offset, the face-spec requirement and pointer to list_faces, and the effect of rotate_about_normal_deg; the doc parameter remains unexplained.

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

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

The description states a specific operation on a specific resource: moving an object so one planar face lies against another object's planar face. It clearly separates this from a generic transform or coaxial mate by specifying planar-face contact, normal orientation, and centre alignment.

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

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

It implies the tool is for planar face mating in an assembly and points to list_faces for resolving face specs. However, it does not explicitly say when to use this instead of mate_coaxial or transform, nor does it state prerequisites 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 burden and partially meets it: it defines the offset direction and that fuse=true yields the union rather than two separate bodies, and it gives units (mm). It never says whether the original object is kept, whether a new object is created under result_name, or whether the operation is reversible — key facts for a mutating geometry 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?

Two tight sentences with no waste; the core transformation and its orientation convention are front-loaded, and the fuse behavior follows as a secondary qualifier.

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

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

An output schema exists so return values need no explanation, and the non-obvious geometry parameters are explained. The remaining gap is the mutation contract (original retained or replaced) and the identity of doc/name/result_name, which an agent can likely infer from sibling conventions but is not confirmed here.

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 well on plane (enum meaning per axis), plane_offset (mm along the normal), and fuse (union semantics), but leaves doc, name, and result_name — three of four required parameters — completely undefined.

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 (mirror an object) plus the exact transformation semantics: world-aligned plane, offset along the plane normal, and the plane-to-axis mapping. An agent can distinguish this from transform, boolean, and the pattern tools without opening any 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?

Implied usage is clear (use when a mirrored copy is wanted, optionally fused into one body), but there is no explicit when-to-use/when-not statement and no named alternative such as linear_pattern with two instances or transform with a reflection. Guidance is inferable, 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?

With no annotations, the description carries the full burden and does add real behavioral context: the document starts empty, it is persisted to a specific workspace path, and modelling conventions (mm, +Z up, degrees) apply. It does not disclose behavior on name collision (overwrite vs. error), which is the one significant gap for a create operation.

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

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

Two dense sentences with the primary action front-loaded; the second sentence delivers global unit/orientation context that would otherwise have to be repeated per tool. Nothing is redundant.

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

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

An output schema exists, so return-value explanation is unnecessary, and the description covers identity, persistence, and coordinate conventions. Only the duplicate-name/error case is left unstated.

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: `name` is revealed to be both the document identity and the filename stem (workspace/<name>.FCStd), implying no extension should be passed. It adds no guidance on naming constraints or invalid characters.

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+resource ("Create an empty FreeCAD document") plus the concrete side effect of where it lands (workspace/<name>.FCStd). It also distinguishes itself from the surrounding modeling tools by stating that every other tool consumes the returned doc name.

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?

"Every other tool takes this `doc` name" effectively establishes this as the entry point of the workflow, which is the key selection signal versus siblings like list_documents or import_step. It stops short of explicitly saying when not to use it or what to do if the document already exists.

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 behavioral burden. It usefully discloses that matching is based on journal entries whose arguments mention the object name rather than direct object mutations, but it does not explicitly state read-only behavior, ordering, completeness, or scope limits.

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

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

The description is a single front-loaded sentence with no filler, and the activity list is compact. It delivers the core retrieval behavior efficiently.

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

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

The output schema covers return values, but the description leaves the required `doc` parameter unexplained and does not clarify whether results are scoped to that document. Given the lack of annotations and zero schema description coverage, this is a meaningful gap 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 must compensate for both parameters. It explains `name` as the object name used to match journal arguments, but it never defines the required `doc` parameter, leaving half the input semantics 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?

The description states the returned resource (journal entries) and the filter (entries whose arguments mention object `name`), plus the kinds of activity covered. It is clear about what the tool retrieves, but it does not explicitly differentiate itself from the sibling `list_history` tool.

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

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

There is no explicit guidance on when to use this tool versus `list_history` or other history-related siblings. Usage is only implied by the tool name and the object-name filter.

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 well: it discloses the default direction per sketch plane (XY +Z, XZ -Y, YZ +X), what `reverse` and `symmetric` do to the geometry, and that inner loops become holes. It omits what happens with open/non-closed loops and gives no indication of failure or permission conditions.

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

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

A single dense sentence with the core action front-loaded and directional defaults tucked into a parenthetical. Efficient, though the nested parenthetical makes it slightly harder to scan than two short sentences would.

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

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

An output schema exists, so return values need not be described, and the geometric behavior is well covered for a modeling operation. Gaps remain around the doc reference, the effect of color/material, and error behavior on invalid sketches.

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 meaningfully explains `length`, `reverse`, `symmetric`, `result_name`, and the `sketch` input, but says nothing about `doc`, `color`, or `material`, leaving three of eight parameters with no semantic guidance 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?

States a specific verb and resource ('Extrude the closed loops of a sketch') plus the output ('into a new solid `result_name`'), and notes that inner loops become holes. That distinguishes it from a cutting operation like `pocket` and from `revolve`/`sweep` without needing the schema opened.

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

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

The description explains the mechanics of extrusion but never states when to choose this over siblings such as `pocket`, `extrude_polygon`, or `revolve`. Usage is inferable from the verb and the additive-solid outcome, but no explicit conditions or exclusions 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?

With no annotations provided, the description carries the behavioral disclosure burden and does well: it states that the tool modifies `target` unless `result_name` is supplied, explains the default cut direction, and notes depth and through-all behavior. It could be stronger by clarifying edge cases such as mutually exclusive depth options or failure conditions.

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

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

The description is front-loaded with the core operation, then efficiently covers direction, depth options, mutation semantics, and sketch placement. Every sentence adds useful information without waste.

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 CAD mutation tool with no annotations and 0% schema description coverage, the description provides substantial context: operation type, target modification behavior, depth options, direction, and sketch placement. It remains slightly incomplete because `doc` is unmentioned and there is no guidance on invalid parameter combinations.

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 explains the semantics of most key parameters: `depth` is in mm, `through_all` is an alternative depth mode, `reverse` flips direction, and `result_name` avoids modifying `target`. The `doc` parameter is undocumented, leaving a minor 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 CAD operation: cutting a sketch profile out of a solid `target`. It is clear enough to distinguish from generic mutations, but it does not explicitly contrast with sibling operations such as `pad`, `hole`, or `shell`, so it falls short of full sibling 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?

The description gives operational constraints, such as default opposite cutting direction and placing the sketch on or above the cut surface. However, it does not explain when to use `pocket` rather than alternative material-removal or modeling tools, nor does it state exclusions.

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

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

With no annotations, the description carries full burden. It does disclose geometry behaviour ('evenly spaced', angle semantics) and delegates fusing to linear_pattern, but it does not state side effects: whether the original is preserved, how doc/name/result_name mutate the document, or error conditions.

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

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

Two compact sentences with the core action front-loaded and zero filler. 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?

Output schema exists, so return values needn't be described. However, for a document-mutating tool with 0 param coverage and no annotations, the description omits document/name/result_name semantics and mutation side effects, leaving gaps an agent would want filled.

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 8 params. The description meaningfully explains center, count, total_angle_deg, and implicitly axis, but leaves doc, name, result_name, and the exact fuse semantics ('same as linear_pattern') to prior knowledge. Partial compensation warrants a 3.

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 ('rotate copies of an object about an axis through center') and precisely explains the count/total_angle_deg semantics. It also distinguishes itself from linear_pattern and names a concrete use case (bolt circles), so an agent can separate it from siblings.

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

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

The phrase 'Use for bolt circles' gives a clear use context, and the reference to linear_pattern positions it relative to an alternative. It lacks explicit when-not conditions or prerequisite notes, but the intended scenario is clear.

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

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

With no annotations, the description carries the behavioral burden and does disclose key traits: the PNG is saved to workspace/renders/<doc>/, objects are coloured by material, and explode moves objects from the assembly centre. It does not explicitly state whether existing render files are overwritten or whether the document itself is modified.

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

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

The description is front-loaded with the core action, then efficiently covers views, explode, and the saved output path. Every sentence adds useful information without repetition.

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

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

For a six-parameter tool with no annotations and no output schema, the description covers the main workflow, view semantics, object filtering, explode behavior, and output location well enough to invoke correctly. Minor gaps remain around size, title, and overwrite behavior.

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 view meanings in detail, the explode range and effect, and that objects can restrict the render, but it leaves size and title entirely 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?

The description states a specific verb and resource: render the document or listed objects to a PNG. It also enumerates the available views and explains the explode effect, giving an agent enough to distinguish this from export, section_view, or make_drawing 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 gives clear usage context by listing valid views, describing grid as a combined view, and explaining when explode is useful. It does not explicitly say when to choose this over export, make_drawing, or section_view, so it stops short of full alternatives guidance.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose key geometric behavior and a failure constraint, but it does not state that this creates/modifies a solid body, requires an existing document and sketch, or explain the roles of result_name and material.

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 definition is front-loaded and tight: two sentences plus a short example. Every sentence adds useful operational information with no filler.

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

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

The core operation, axis semantics, angle semantics, and profile constraint are present, and the output schema covers return values. However, for a 7-parameter mutation tool with no annotations and zero schema descriptions, several parameters and mutation behaviors remain 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 description coverage is 0%, so the description must compensate. It clarifies axis_point and axis_dir as point plus direction and references angle_deg, including an example axis_dir, but it leaves doc, sketch, material, and the required result_name unexplained.

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

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

The description names a specific CAD verb and resource: revolve a sketch's closed profile about a world-space axis by angle_deg. It is clear enough to separate the operation from generic modeling tools, but it does not explicitly contrast itself with nearby siblings such as extrude, sweep, or loft.

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 a concrete applicability constraint (the profile must not cross the axis) and a useful example (shaft profile in an XY sketch with axis_dir [1,0,0]). It does not state when to choose revolve over alternatives such as extrude or sweep, but the operating context is clear.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the solver stack, expected runtime range, output metrics and plot behavior, the numerical singularity issue at fixed/loaded edges, and the exclude_mm filtering along with raw vs filtered stress values. These are substantive behavioral traits beyond the schema.

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

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

Despite being longer than a simple CRUD description, every sentence carries useful engineering or parameter guidance for a complex FEM tool. It is front-loaded with purpose and returns, then moves into parameter semantics and caveats without wasted prose.

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

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

For a complex 8-parameter simulation tool with no annotations or output schema, the description is substantially complete: it explains return values, runtime expectations, singularity handling, and core parameter usage. Minor gaps remain around plot_view and doc/name semantics, but an agent could invoke the tool correctly from this description.

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 fixed_faces selectors and indices, the loads dict structure with force_n/direction versus pressure_mpa, material defaulting, mesh_size meaning and practical bounds, and exclude_mm behavior. It does not explain plot_view or the doc/name parameters, leaving some gaps, but the critical simulation parameters are well covered.

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

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

The first sentence names the specific analysis method (linear-static FEM with Gmsh/CalculiX), states the exact scope (ONE solid), and lists the returned results. This is clearly distinguishable from CAD modification siblings like fillet, boolean, or mass_properties, and an agent can tell what domain this tool belongs to.

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

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

The description gives clear operational context: it is for one solid, requires fixed faces and loads, defaults material from the object, and recommends mesh sizing and fillet refinement before trusting stress concentrations. It stops short of explicitly naming alternatives or saying when not to use the tool, but the constraints and pitfalls provide strong guidance.

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

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

With no annotations, the description carries the full burden and does well: it discloses the side effect ('doc' is saved afterwards), the injected namespace (App, Part, V, doc, result, add_shape), and that print() output is returned. It omits irreversibility/undo implications of executing arbitrary code, which is the one behavioral 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?

Front-loaded with the essential framing ('Escape hatch'), then namespace, then routing guidance — every clause earns its place. The parenthetical stacking makes it dense, but nothing is wasted or redundant.

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

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

For an arbitrary-code-execution tool with no annotations, the definition covers side effects, the scripting environment, and output channels (print plus result dict), and an output schema exists so return values need no further explanation. Only the risk/undo profile is left implicit.

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 largely does: `code` is defined by the available namespace and the `result` dict contract, and `doc` by the note that it is the document acted on and saved. Neither is exhaustively specified (e.g. accepted doc identifier format), but the semantics are clear.

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?

Names a specific verb+resource ('run arbitrary FreeCAD Python in the worker on `doc`') and frames itself explicitly as an 'Escape hatch', which no sibling claims. Against 40+ dedicated modeling siblings, the boundary 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?

Explicit exclusion: 'Use only when no dedicated tool fits', plus a positive routing rule that geometry should go in via add_shape so other tools see it. It does not name which siblings to prefer for common tasks, but the fallback-of-last-resort rule is clearly stated.

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

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

With no annotations, the description takes on the safety burden well: 'Nothing in the document is changed' explicitly declares non-destructiveness, and it describes the visual result (orange cut faces, 'auto' looks straight at the cut face). It does not say what the tool returns (image/file) or how `size` affects output, leaving a residual 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?

Front-loaded with the core action, followed by a view-parameter sentence and a side-effect sentence; every sentence carries information. The parenthetical example is useful rather than filler, though the run-on first sentence is slightly dense.

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, no-annotation, no-output-schema tool the description covers the operation, the cut-plane semantics, and the non-destructive guarantee. The unexplained `objects` and `size` parameters and the unspecified return value keep it from being fully complete.

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

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

Schema coverage is 0%, so the description must compensate, and it does for four of seven params: axis/offset via the z=10 example, `remove` via 'discard the half on the remove side', and `view` via 'auto' vs any render_view name. `doc`, `size`, and `objects` are left entirely uninterpreted, so it only partially fills the 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 operation on a specific resource: cut the model with plane axis=offset, discard half, render the remainder. An agent knows exactly what the tool produces and how it differs from the sibling render_view, which is named explicitly as the source of valid `view` values.

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 use case is clear from 'so internal features (bores, walls, fastener fit) are visible', which implicitly tells the agent to pick this over plain render_view when internals must be inspected. There is no explicit when-not guidance or direct comparison statement, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full behavioral burden for a mutation tool. It usefully discloses downstream effects and the default color behavior, but omits core mutation semantics such as whether properties overwrite or merge, permission requirements, and what happens to omitted fields.

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

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

The description is compact and front-loaded: purpose first, then downstream impact, then key parameter constraints. Every sentence adds useful information with no filler.

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

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

An output schema exists, so return values need not be explained. However, with no annotations and 0% schema description coverage, the description leaves several parameters and mutation behaviors unspecified. It is minimally viable but incomplete for a 9-parameter mutation tool.

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

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

Schema description coverage is 0% across 9 parameters, so the description must compensate. It explains material values, color format/default, and quantity's BOM role, but leaves doc, name, group, part_no, supplier, and description 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?

The description states a specific verb and resource: "Set metadata on an object." It also names the downstream consumers (mass_properties, run_fem, bom, renders), which distinguishes this metadata setter from geometry-mutating siblings. It does not explicitly contrast sibling alternatives, so it stops short of a 5.

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

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

Usage is implied by saying the metadata feeds mass_properties, run_fem, bom, and renders, but there is no explicit when-to-use or when-not-to-use guidance. No alternatives are named, and no preconditions are stated.

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

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

With no annotations, the description carries the behavioral burden and does well by stating the inward wall direction and a concrete failure mode: large thickness relative to features fails and the tool reports it. It does not discuss side effects on the document or whether a new named body is produced, but the main behavioral risk is disclosed.

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

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

The definition is two tight sentences, front-loads the core operation, and uses the second sentence for the important failure constraint. No sentence 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?

An output schema exists, so return values do not need description, and the core shelling operation and failure condition are covered. But with no annotations and 0% schema description coverage, the definition is still incomplete because doc and name semantics are omitted and the mutation side effects are not described.

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 adds useful meaning for thickness (millimeters, inward) and remove_faces (indices or face selector, see list_faces). However, the required doc and name parameters are not explained at all, leaving half the required parameters without semantic guidance.

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

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

The description states a specific verb and resource: hollow out a solid, leaving inward walls of a given thickness and opening specified faces. It also points to list_faces for face selection, making the operation distinguishable from generic boolean or pocket operations.

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

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

The hollowing operation is implied by the verb, and the description notes that large thickness relative to features fails, but it does not explicitly say when to use shell versus alternatives like pocket, hole, or boolean. The reference to list_faces is parameter guidance rather than usage guidance.

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

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

With no annotations at all, the description carries the full behavioral burden, and it does disclose a real geometric precondition: the profile should sit at the path start and be roughly perpendicular to the path. It does not say what happens on failure, whether existing geometry is consumed, or whether path_sketch and path_points are mutually exclusive, leaving substantive gaps for a geometry-creating operation.

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

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

Three sentences, front-loaded with the action, and each carries information: what is swept, the path alternatives, the orientation precondition, and a use case. No filler, though the path-alternative clause is slightly parenthetical.

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

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

An output schema exists, so return values need no explanation, which lowers the bar. Still, for a 7-parameter tool with zero schema descriptions and no annotations, the description leaves the agent guessing about frenet, material and whether a path is required at all — a meaningful gap before invocation.

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

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

Schema description coverage is 0%, so the description must compensate, and it partially does: it explains profile_sketch, names path_points explicitly in backticks, and clarifies that the path may be 'a sketch of connected edges'. Four parameters — doc, result_name, frenet and material — receive no explanation anywhere, so compensation is only partial.

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 ('Sweep a closed profile sketch along a path') and defines what the path can be, so the agent knows exactly what geometry operation this performs. It does not contrast itself with nearby modelling siblings such as loft, extrude_polygon or revolve, which is the only thing keeping it from 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?

'Use for pipes, rails and cable runs' gives a concrete application context that tells the agent when this is the right modelling op. It stops short of naming alternatives (e.g. use loft when the profile varies along the path) or stating exclusions, so it is clear context without routing guidance.

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

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

With no annotations, the description carries the burden and does well: it discloses operation ordering, the default rotation axis (world Z) and center (origin), units (mm, degrees), and the side effect that the original object is moved unless copy_as is supplied. It omits error/failure behavior when the named object doesn't 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?

Three tight sentences, front-loaded with the verb-and-skill summary before the ordering rule and the copy_as nuance. Dense but every clause carries information; only the parenthetical line breaks add slight noise.

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, the description covers the geometric semantics well and an output schema handles return values. It is still thin on identifying what doc/name must reference and what happens on an invalid object, which an agent needs before calling.

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 copy_as, rotation_deg's unit, and the defaults for rotation_axis and rotation_center, but leaves doc, name, translate, and the expected vector formats (3-element arrays) 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 compound operation on a named resource and pins down the important detail that rotation is applied before translation, which an agent could otherwise get wrong. It doesn't explicitly contrast itself with siblings like mirror or linear_pattern, so it stops short of a 5.

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

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

The copy_as sentence gives one concrete usage hint ('use for repeated parts'), which implies when to create a duplicate versus move in place. There is no explicit statement of when to use this versus mirror, linear_pattern, or set_properties, so guidance remains implied.

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

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

With no annotations, the description carries the full burden and does it well: it discloses that the restored version REPLACES the current file, that there is no redo, and that only 20 versions are retained. These are the exact behavioral traits an agent needs before invoking a destructive mutation.

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 sentences, front-loaded with the action, then the behavioral caveats. No filler; every clause adds 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?

An output schema exists so return values need no explanation, and the description covers irreversibility and version limits thoroughly. The only shortfall is that the document identifier parameter and the behavior when fewer than `steps` versions exist are left unstated.

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 clarifies `steps` (how many modifying operations to roll back) and implicitly the default of one, but never explains what `doc` identifies (name, path, or ID) — a gap for the only required 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 (undo) and resource (last N modifying operations on a document), plus the mechanism (restoring a saved version). An agent can distinguish it from siblings like list_history or object_history without opening any 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?

Explicitly directs the agent to check list_history first when unsure, which is a real alternative-routing instruction. It does not spell out when NOT to use it (e.g. a redo path, since none exists) beyond the no-redo warning, but the context is clear.

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