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

Beyond annotations (readOnlyHint=false, destructiveHint=false), description adds risk class 'medium (reversible write-new on working copy; original untouched)', advises rendering before trusting, and mentions restore_snapshot as revert option. This provides valuable behavioral 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?

Well-structured with clear sections: purpose, when-to-use, parameter details, return shape, example, and risk note. Every sentence adds value without being verbose.

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

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

Complete for a gradient-adding tool: describes return shape (CreateResult with object_id and bbox=None), provides usage example, risk assessment, and verification steps. Output schema exists but description sufficiently explains output.

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

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

With 0% schema description coverage, the description compensates by explaining stops parameter in detail (offset, color, opacity) and vector coordinates (x1,y1 to x2,y2) with defaults. Not every parameter is fully detailed (doc_id implied, object_id not mentioned), but the essential semantics are covered.

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

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

The description clearly states the tool adds a <linearGradient> to the document <defs>, with a specific verb and resource. It distinguishes from sibling add_radial_gradient by explicitly contrasting usage.

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

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

Explicitly states when to use (directional colour fade) and when not (centred/radial fade, recommending add_radial_gradient). Provides a usage example and mentions applying the gradient via set_fill, giving clear context for selecting this tool.

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

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

Describes return shape (CreateResult with object_id and pipeline fields), warns about rendering before trusting, and classifies risk as medium (reversible write-new). This adds context beyond annotations, though no auth or rate limit details.

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

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

Compact yet comprehensive: one paragraph with clear sections (action, usage, key params, return shape, example, risk warning). Every sentence adds value, no fluff.

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

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

Given the tool has an output schema, the description covers everything needed: what it does, when to use, parameter details, return shape, example, and safety warning. No gaps for an agent to misuse.

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

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

With 0% schema description coverage, the description compensates well by explaining stops (with format), cx, cy, r, fx, fy and their defaults. An example is provided. However, doc_id and object_id are not explained, but they are standard parameters.

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

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

The description clearly states it adds a radialGradient to the document defs, and distinguishes from the sibling tool add_linear_gradient by specifying when to use each.

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 specifies when to use (centred/radial colour fade), when not to (directional fade -> use add_linear_gradient), and how to apply the gradient afterwards with set_fill.

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

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

The description adds significant behavioral context beyond the annotations: it describes atomicity, reversibility, two-phase validation (validate-then-apply), all-or-nothing rollback, risk classification (medium vs high based on delete_object), requirement for approval_token for high risk, and the snapshot mechanism for revert. Annotations only indicate destructiveHint: true; the description enriches this with detailed operational 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 well-structured and front-loaded with the core purpose, then usage guidance, parameter details, validation, risk, and return shape. However, it is relatively verbose; while every sentence adds value, a slightly more condensed presentation could be achieved without losing clarity. Still, it's highly effective and organized.

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 (batch edits with many op types), the description is remarkably complete: it covers purpose, when to use, parameter semantics, validation behavior, risk levels, return shape (BatchEditResult with pipeline fields), and includes an example. The schema and annotations are supplemented well, and the description leaves no major gaps for an agent to invoke the tool correctly.

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

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

The input schema has 0% description coverage for top-level parameters, so the description bears the full burden. It thoroughly explains the `edits` parameter: a non-empty ordered list (max 64) of typed edits, each with an `op` field, lists all supported ops, and provides examples. It also explains `approval_token` context (required for high risk). This adds extensive meaning beyond the schema's raw structure.

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

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

The description clearly states: 'Apply an ordered list of typed DOM edits to a document as ONE atomic, reversible operation.' It distinguishes from siblings by specifying that for a single edit use the dedicated tool, and for path geometry or cross-document composition use those tools directly. This provides a specific verb+resource and differentiates from 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?

The description explicitly includes a 'When to use' section: 'making SEVERAL edits to one document in a single call... instead of N separate tool round-trips.' It also states: 'For a single edit, call the dedicated tool... for path geometry or cross-document composition use those tools directly (they are NOT batchable).' This gives clear when-to-use and when-not-to-use guidance, referencing alternatives.

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

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

Annotations show destructiveHint=true; description adds validation fails before mutation, single snapshot for reversal, risk class, and return shape. Discloses preview recommendation.

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?

Well-structured with sections, but slightly lengthy. Front-loaded with purpose. Each sentence adds value.

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

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

Covers purpose, usage, parameters, return shape, error handling, risk, and preview recommendation. Output schema exists, so return is explained. Complete for a complex 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?

Despite 0% schema coverage, description explains mapping validation (typod colors rejected with ToolError), scope_ids confinement, and provides example. Fully compensates.

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

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

Clear verb+resource: 'Apply many colour replacements in a single reversible operation.' Distinguishes from siblings like replace_color, set_fill, set_stroke.

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 when-to-use: 're-theming / rebranding a document's colours in one shot.' Provides alternatives: for single swap use replace_color; for specific objects use set_fill/set_stroke.

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

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

Annotations mark as readOnlyHint=true and destructiveHint=false; description adds details like rendering full canvas without UI chrome, indexing behavior (monotonic, survives restart, no clobber), and risk class (low, no overwrite). No contradiction with annotations.

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?

Well-structured with sections (purpose, when to use, key params, return shape, example, risk). Slightly lengthy but all information is valuable and front-loaded. Could be slightly more concise.

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 6 parameters and output schema, description covers indexing, artifact path, return shape (FrameResult fields), inline vs. structured, and risk. Example provided. Completeness is high.

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

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

Schema has 0% description coverage, but description explains key parameters: series (sanitized, defaults to run), label (folded into name), inline (controls output), and max_output_bytes. Width_px is not elaborated, so not fully exhaustive.

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?

Clearly states the tool captures the next numbered PNG screenshot in a per-run frame series. Distinguishes from siblings by mentioning render_preview for one-off checks and list_frames for gathering series.

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 provides when to use (documenting scripted edit sequences) and when not to, with alternatives: render_preview for one-off, list_frames for finished series.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. Description adds significant context: probes extension-socket and DBus independently, safe regardless of live mode, and no session assumption. No contradictions.

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?

Well-structured with bullet points, front-loaded purpose, and every sentence adds value. Efficient use of words with no 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?

Given zero parameters, rich annotations, and output schema reference, the description is complete: covers usage, behavior, return shape, example, and risk class.

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?

No parameters exist, and schema coverage is 100%. The description explains that no params are needed, and adds value by describing the probe behavior and return shape.

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

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

The description clearly states the tool reports which live transports are available, specifies it's read-only and no-connection, and distinguishes from siblings like live_connect, live_install_helper, and list_capabilities. It uses a specific verb and resource.

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

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

Explicitly states when to use ('checking live readiness before live_connect') and lists alternatives ('live_install_helper', 'list_capabilities'). Provides clear context and 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?

Discloses deep-copy, scaling behavior, grid fill order, cell bound, reversibility, risk class; annotations are minimal so description carries full burden and excels.

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?

Well-structured with sections (purpose, when to use, key params, return, example, caution). Slightly verbose but every sentence adds value; no fluff.

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 complexity (10 params, output schema exists), description covers purpose, usage, behavior, parameter semantics, return shape, and risk. Output schema handles return details.

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?

Adds meaning beyond schema: explains source mode (doc_ids vs object_ids+source_doc_id), scale_to_fit default, gap/padding, target_doc_id. With 0% schema coverage, description compensates well but not every param is detailed.

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?

Specifies verb 'compose', resource 'grid of different assets', scope 'one reversible call', and distinguishes from siblings 'tile' and 'insert_svg_fragment'.

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

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

Explicitly states when to use (multi-asset sheet) and when not (use 'tile' for repeating one object, 'insert_svg_fragment' for single subtree), plus key param 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?

Discloses that it creates a new element, mentions reversibility via restore_snapshot, and risk class medium. Adds context beyond annotations.

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?

Organized with clear sections: purpose, usage, params, return, example, safety. Every sentence adds value, no fluff.

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?

Covers all necessary aspects: function, parameters, return shape, example, safety. Output schema exists for return values, and the description completes the picture.

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?

Explains key parameters like r>0, cx, cy, fill, stroke, stroke_width, parent_id, object_id with validation notes. With 0% schema coverage, it compensates well, though doc_id is only in example.

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

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

The description clearly states it creates a `<circle>` with center (cx,cy) and radius r. It distinguishes from siblings by mentioning alternatives for ovals and rectangles.

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

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

Explicitly says 'When to use: drawing a circle / disc' and provides alternatives. Lacks explicit when-not but gives sufficient context.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false. The description adds significant context: 'Risk class: medium (creates a new tracked document; no existing state mutated),' explains the generated document is validate_document-clean, and mentions the output shape and tracking features. It could be slightly more concise, but adds value beyond annotations.

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

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

The description is well-structured with clear sections: summary, usage, key parameters, return shape, example, and risk class. Every sentence adds value, though it is a bit long. A minor trim would make it more concise, but still effective.

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

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

With 4 params, no enums, and an output schema, the description covers everything: parameter details, default behavior (viewBox synthesis), return shape references (OpenDocumentResult), risk class, and even an example. It is complete for an agent to understand and use the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate fully. It does: explains width/height are in user units (>0), viewBox is optional with format 'minx miny w h' and synthesized default, background is validated colour types with anti-injection. This adds essential meaning beyond the schema.

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

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

The description explicitly states 'Create a blank, tracked working-copy document from scratch — NO source file required.' and distinguishes from siblings like open_document and set_document_svg, making the purpose very clear and specific.

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

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

The description provides a clear 'When to use' section: 'starting fresh authoring...when there is no SVG to open.' It also states when not to use: 'To open an EXISTING file use open_document; to set the whole SVG body afterwards use set_document_svg.' This gives explicit guidance with alternatives.

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

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

Annotations indicate non-readOnly and non-destructive, and the description adds significant behavioral context: it's a write-new operation on the working copy, reversible, medium risk. It also recommends using render_preview to verify, which aligns with the annotations and provides actionable safety information.

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

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

The description is well-structured with sections (purpose, usage, key params, return shape, example, risk). While it is relatively long, every sentence adds value and is front-loaded with essential information. Could be slightly trimmed but overall effective.

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 (10 parameters, 5 required, output schema exists), the description covers all necessary aspects: creation semantics, parameter constraints, optional styling, return shape, example, and risk/revert guidance. It provides complete context for correct usage.

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

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

With 0% schema description coverage, the description compensates well by explaining all key parameters (cx, cy, rx, ry, fill, stroke, stroke_width, parent_id, object_id) and their constraints. Only doc_id is not explicitly described but is clear from context. It adds meaning beyond the bare schema types.

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

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

The description states the tool creates an `<ellipse>` element with specific parameters (cx, cy, rx, ry). It clearly distinguishes from sibling tools `create_circle` (for perfect circles) and `create_rect` (for boxes), providing a clear and specific verb-resource mapping.

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

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

Explicitly states 'When to use: drawing an oval / ellipse' and directs to alternatives for other shapes. It also provides constraints (rx/ry > 0, parent_id must exist) and a risk classification, offering thorough 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?

Discloses behavior beyond annotations: return shape (`CreateResult` with fields), reversibility via `restore_snapshot`, risk class medium, and warning to render before trusting. No contradictions with annotations.

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?

Well-structured: action, usage guidelines, key params, return shape, example, warning. Every sentence adds value without repetition or fluff.

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?

Covers all necessary aspects: purpose, usage, parameters, return shape, example, and risk. Output schema exists, so description focuses on key points, and example provides minimal but sufficient guidance.

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?

Adds meaning beyond schema: `parent_id` must exist, `object_id` is for pinning the id. Schema coverage is 0%, so description compensates well, though `doc_id` is not elaborated (but is 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 clearly states it creates an empty `<g>` group inside a parent. It distinguishes from siblings by specifying when to use `group_objects` and `reparent_object` for wrapping existing objects or moving one object.

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

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

Explicitly states when to use (making an empty group to populate later) and when not to use (alternatives for wrapping or moving objects). Includes a risk class and advice to render before trusting, providing clear usage context.

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

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

Discloses that out-of-range sizes are rejected before Inkscape runs, out_dir is sandbox-checked, and no partial set is written. Describes return shape and risk class. Adds value beyond annotations which already indicate readOnlyHint=true and destructiveHint=false.

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

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

Well-organized with sections: purpose, when to use, key params, return shape, example, risk. Every sentence earns its place; no unnecessary words.

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

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

Given 4 parameters, presence of output schema, and annotations, description covers usage, param details, output format, example, and risk. Fully sufficient for an agent to understand and invoke correctly.

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

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

With 0% schema coverage, description explains key parameters: sizes constraint (positive integer ≤ cap), out_dir anchoring to workspace root, name_prefix tagging. Adds meaning beyond bare schema.

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

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

Clearly states 'Export a multi-size square PNG icon set from the source document.' Distinguishes from siblings export_web_profile and export_batch by specifying when to use each.

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 provides when-to-use: 'producing a standard square icon set in one call.' Directs to alternatives for other needs, giving clear usage boundaries.

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

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

Annotations already provide readOnlyHint=false and destructiveHint=false. The description adds context: risk class 'medium (reversible write-new)', mentions rendering and revert options, and explains that the original is untouched. This goes well beyond the annotations.

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

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

The description is well-structured but slightly verbose. It front-loads purpose and usage, then details parameters, return shape, example, and risk. However, the return shape explanation is somewhat redundant given the output schema exists, and there is minor repetition (e.g., 'render and look before you trust'). Still clear and effective.

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

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

Given 9 parameters, 5 required, 0% schema coverage, and the presence of an output schema, the description covers everything: purpose, usage, parameter details, return type with field explanations, example, risk classification, and post-usage actions. It is exceptionally 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 fully compensates. It explains each parameter (x1, y1, x2, y2, doc_id, stroke, stroke_width, object_id, parent_id), notes that line is unfilled (no fill), and describes default behavior (unpainted, parent_id default). This adds critical meaning.

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

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

The description clearly states it creates a line segment with specific endpoints (x1,y1 to x2,y2). It distinguishes from sibling tools like create_polyline (multi-segment open) and create_polygon (closed shape), fulfilling the need for specificity.

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

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

Explicitly tells when to use: 'a single straight segment'. Provides direct alternatives: use create_polyline for multi-segment open runs and create_polygon for closed shapes. This gives clear decision 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?

Discloses multiple behavioral details beyond annotations: d validation (strict charset, length-bounded, not fully parsed), optional paint parameters validated like set_fill/set_stroke, default unpainted, parent_id requirement, return shape with bbox=None, and risk class 'medium reversible write-new'. The annotations only indicate readOnlyHint=false and destructiveHint=false, so the description carries the full burden and does so thoroughly.

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

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

The description is well-structured with clear sections (When to use, Key params, Return shape, Example, Render advice, Risk class). It is slightly lengthy but every section adds value. Front-loading the main purpose helps quick understanding.

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

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

The description covers all necessary aspects: purpose, usage conditions, parameter behavior, return shape with example, risk assessment, and integration with sibling and preview tools. Given the tool's complexity and the presence of an output schema (mentioned), the description is highly 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?

With 0% schema description coverage, the description explains most key parameters: d (validation details), parent_id (must exist or default), fill/stroke/stroke_width (optional, validated, default None). However, doc_id and object_id are not explicitly described, leaving a minor gap. Overall, it adds significant meaning beyond the raw schema.

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

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

Clearly states the verb 'create' and resource 'path', with explicit differentiation from sibling tools like create_rect, create_circle, and editing paths via simplify_path. The description includes specific when-to-use guidance, making the purpose unmistakable.

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

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

Provides explicit when to use (freeform/bezier/curve geometry) and when not (prefer primitives for simple shapes; use paths tools for edits). Includes a recommendation to render and inspect via render_preview before trusting the edit, and mentions restore_snapshot for reversion. This offers clear context for safe and appropriate invocation.

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?

Beyond annotations (write, not destructive), description adds risk class (medium, reversible write-new), warns to render before trusting, and notes that changes are reversible via restore_snapshot.

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?

Well-structured into sections (purpose, usage, params, return, example, caution, risk), each sentence adds value, no redundancy, front-loaded with core action.

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?

Covers purpose, usage guidelines, all parameters, return shape, example, and risk; sufficient for an agent to correctly select and invoke the tool.

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

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

With 0% schema coverage, description explains points as at least one (x,y) pair, parent_id must exist or uses default, object_id to pin id, and fill/stroke/stroke_width validated like set_fill/set_stroke with defaults.

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

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

Explicitly states creation of a closed `<polygon>` from points, and distinguishes from siblings by specifying that create_polyline is for open runs and create_path for curves.

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

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

Provides a 'When to use' section with explicit alternatives for open runs and curves, and mentions that parent_id must exist.

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

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

Annotations indicate the tool is not read-only and not destructive. The description adds valuable behavioral context: it creates a new object, inserts into a parent, optionally paints, and notes the risk class as 'medium (reversible write-new).' It also advises rendering a preview before relying on the edit, which goes beyond annotations.

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

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

The description is well-structured and concise: first line states purpose, then usage guidance, key parameters, return shape, an example, and finally safety advice. Every sentence adds value without redundancy.

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

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

Given the tool's complexity (7 params, output schema present), the description covers all essential aspects: purpose, usage context, parameter details, return format, concrete example, and risk mitigation. It feels fully complete for an agent to use correctly.

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

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

The input schema has 7 parameters with 0% description coverage. The description compensates by explaining key parameters: points must be ≥1 (x,y) pairs, parent_id must exist or default to document, object_id pins the id, and fill/stroke/stroke_width are optional. However, doc_id is not explained beyond being required. Overall, it adds significant meaning over the raw schema.

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

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

The description states exactly what the tool does: 'Create an open <polyline> from points (≥ 1 (x, y) pairs).' It clearly names the resource and action, and differentiates from siblings by specifying when to use create_polygon, create_line, or create_path instead.

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

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

The description provides explicit when-to-use guidance: 'a connected open run of segments.' It also gives specific alternatives for closed shapes, single segments, and curves, making it easy for the agent to choose the correct 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?

Annotations indicate write operation (readOnlyHint false) but not destructive. Description adds context: 'reversible write-new', validation of fill/stroke like set_fill/set_stroke, and advice to preview before trusting. However, annotations already convey the basic safety profile.

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?

Description is well-structured with core purpose, usage, params, return, example, risk. Front-loaded but includes some redundancy (e.g., validation detail). Efficient overall.

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 12 parameters, output schema exists, and annotations provide base info, the description adds all needed context: return shape, example, risk class, validation behavior. No gaps.

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

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

Schema coverage is 0%, but description explains key parameters: width/height >0, rx/ry optional, parent_id must exist, object_id pins id, fill/stroke validated like set_fill. Provides meaningful guidance beyond raw schema types.

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

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

Description clearly states it creates a `<rect>` element with position, size, and optional radii. Distinguishes from siblings like create_circle, create_ellipse, create_path by explicitly naming 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?

Explicitly states when to use ('drawing a rectangle / square / box') and when not (ellipse, freeform). Also provides risk class and revertibility advice.

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

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

The description claims a write operation ('write-new snapshot') while annotations declare readOnlyHint=true, creating a direct contradiction. Despite providing additional context like risk class, the inconsistency severely undermines 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?

Four sentences, well-structured with clear sections (purpose, usage, params, return shape, risk). No unnecessary words; every sentence adds value.

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

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

Covers purpose, when to use, key params, return shape (SnapshotInfo with metadata), example, and risk class. Despite annotation contradiction, the description itself is complete for what the tool does.

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

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

With 0% schema coverage, the description adds meaningful detail: label is optional, length-bounded, and over-cap results in rejection. The example demonstrates usage. Could mention doc_id type/format but overall compensates well for schema gaps.

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

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

The description clearly states the verb 'snapshot the current working copy of a document and index it,' specifying both action and resource. It distinguishes itself from sibling tools list_snapshots and restore_snapshot by stating its purpose.

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 guidance on when to use (checkpointing before risky edits) and when not to (browsing or rollback should use other tools). Also notes that mutating tools auto-snapshot, so this is an explicit manual checkpoint.

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?

Discloses text constraints (length-bounded, no control chars except tab/newline/carriage return), parameter validation (fill/stroke like `set_fill`/`set_stroke`), return shape, and risk class medium (reversible write-new). No contradiction with annotations.

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?

Well-structured with labeled sections (When to use, Key params, Return shape, Example, Caution). Every sentence adds value without redundancy. Concise yet comprehensive.

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

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

Given 9 parameters (4 required), output schema exists, and annotations present, the description covers all critical aspects: creation effect, parameter details, return format, example, and safe usage advice. Fully complete for agent selection and 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?

Despite 0% schema description coverage, the description explains key parameters: `text` constraints, `parent_id` default behavior, `fill`/`stroke`/`stroke_width` painting semantics, and `x`/`y` as anchor. Provides example using `fill` parameter.

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

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

The description clearly states it creates a `<text>` element at specific coordinates. It distinguishes from sibling tools like `replace_text` and `set_font`, providing precise purpose.

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

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

Explicitly says when to use (adding new label/caption) and when not (for existing text use `replace_text`, for font use `set_font`). Includes caution to render before trusting and mentions reversibility via `restore_snapshot`.

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

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

The description adds substantial behavioral context beyond annotations. It details the return shape (CreateResult with fields), the translate-scaling trap (x/y as translation before transform, warning not to mix with scaling transform), validation (only same-document #id, rejected external/javascript/url), and risk class (medium, reversible write-new). Annotations already indicate write and non-destructive, which is consistent.

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

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

The description is well-structured, starting with purpose, then usage guidelines, key params with warnings, return shape, example, and safety advice. It is front-loaded with essential information. While it is relatively long, every sentence adds value, and the organization makes it easy to parse. A slight trim could improve conciseness, but it remains highly effective.

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

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

For a tool with 7 parameters, complex SVG behavior, and an output schema, the description is exceptionally complete. It covers the placement trap, validation rules, return shape, and provides a concrete example. The advice to use render_preview and restore_snapshot further ensures safe usage. All aspects necessary for correct invocation are addressed.

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?

Given 0% schema description coverage, the description comprehensively explains key parameters: href_id must name existing element, parent_id must exist or default, x/y translation behavior, and transform usage with the scaling trap. It also notes default parent, object_id optional, and includes an example. This fully compensates for the lack of schema descriptions.

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

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

The description clearly states 'Create a `<use href="#href_id">` referencing an existing same-document object' and distinguishes from siblings by specifying alternatives for deep-copy (duplicate_object) and grid-repeat (tile). The verb and resource are specific, and the tool's unique role in SVG instancing is well-defined.

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 'When to use' context is provided: 'instancing / cloning an existing element so edits to the original propagate.' It also gives clear when-not-to-use examples: 'To deep-COPY (independent) use duplicate_object; to grid-repeat use tile.' Additionally, it advises to render and inspect before trusting, and mentions restore_snapshot for reversion.

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?

Description adds significant behavioral details beyond annotations: deletion is reversible, silently skips non-existing ids, cannot delete document root, requires approval_token, and return shape details. Annotations already indicate destructiveHint=true, so no contradiction.

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?

Well-structured, front-loads purpose, then usage guidelines, parameter details, return shape, example, and caution. Slightly long but all content is useful; no wasted sentences.

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

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

Given output schema exists, description explains return shape (DeleteResult with all EditResult fields plus affected_ids) and edge cases. Also provides risk class and safety steps (render preview, restore_snapshot). Fully adequate.

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

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

Schema has 0% description coverage, but description provides substantial meaning: object_ids as non-empty list with silent skip behavior, approval_token required for high risk (minted out of band), and doc_id implied. This compensates well for the bare schema.

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

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

Clear verb+resource: 'Delete objects by id from a document in ONE reversible, snapshot-backed operation.' Distinguishes from reparent_object and rename_object, providing explicit 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?

Explicitly states when to use (dropping elements without full rebuild), when not to use (moving or renaming), and where to get ids (find_objects/inspect_document). Also covers prerequisites like approval_token for high risk operations.

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

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

The description adds behavioral details beyond annotations: re-runs every call, refreshes cache, reports missing backends in notes without crashing, and clarifies risk class as low. This complements the readOnlyHint and destructiveHint annotations with actionable context.

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

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

The description is well-structured: purpose sentence, usage guidelines, key params, return shape, example, and risk class. Every sentence is informative and concise, with no wasted words.

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

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

Given the tool's complexity (runtime probe with multiple outputs) and the presence of an output schema, the description fully explains the return shape (version, actions, formats, etc.) and side effects (cache refresh). It is complete for agent decision-making.

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

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

With zero parameters and 100% schema coverage, the description adds minimal but helpful confirmation ('Key params: none'). This avoids ambiguity, though it does not add extensive new meaning beyond the schema.

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

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

The description clearly states it probes the local runtime and returns a capability matrix, using specific verbs ('probe') and noun ('capability matrix'). It distinguishes from siblings by explicitly naming alternatives: list_capabilities (cached) and check_live_support (live-transport detail).

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

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

The description explicitly says when to use ('to FORCE a fresh probe') and gives alternatives ('for a cheap cached read use list_capabilities'). It also states key params are none, providing clear context.

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

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

Adds significant behavioral context beyond annotations: the clone re-ids every contained id, rewrites internal references, generates a validated safe new_id, and is reversible (lands on working copy only). Also gives risk class 'medium (reversible write-new)'. No contradiction with annotations.

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?

Well-structured with clear sections: main function, when to use, key params, return shape, example, and caution. Every sentence adds value without redundancy. Efficient for the complexity.

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

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

Covers purpose, usage, behavior, parameters, return shape (EditResult with summary), example, and safety note. Despite having an output schema, the description adds context about what to expect (e.g., 'the new top id is reported in the summary'). No gaps identified.

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

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

Schema has 0% description coverage; the description compensates by explaining what each parameter does: 'the clone re-ids every contained id uniquely... an optional `new_id` (validated safe and unused) names the clone's top element; otherwise a suffixed id is generated.' Includes an example call.

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

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

The description uses a specific verb+resource: 'Duplicate an object or group in place, inserting the clone right after the original.' It distinguishes from siblings by naming alternatives (tile, create_use, rename_object) later in the description.

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 provides when-to-use ('copying one object once') and when-not-to-use with clear alternatives: 'To copy into a grid use `tile`; to instance via `<use>` use `create_use`; to change an id without copying use `rename_object`.'

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

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

The description contradicts the readOnlyHint annotation (true) by detailing that dry_run=False writes files to the workspace. This is a serious inconsistency; the description itself is otherwise transparent about behavior, but the contradiction forces a score of 1.

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

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

The description is front-loaded with the core action in the first line, well-structured with sections for usage, parameters, return shape, and example. Every sentence adds value without redundancy.

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

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

Given the tool's complexity (6 parameters, no schema descriptions, presence of output schema), the description covers purpose, usage context, parameter details, return shape, example, and risk class. It is comprehensively informative.

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

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

With 0% schema description coverage, the description fully compensates by explaining each parameter's purpose, including format options, optional fields, default values, and special behaviors like byte_budget and sandbox-checked out_dir.

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

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

The description clearly states the tool exports a bounded batch of typed export specs. It distinguishes from sibling tools like export_document and export_object for single exports and create_icon_set for icon sets, making the purpose specific and 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?

Explicitly states when to use (exporting many sizes/formats/objects in one call) and when not to (single exports or standard icon sets), naming alternatives. Provides clear guidance on dry-run vs real execution and budget constraints.

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?

Describes sandbox-checked directory, inline behavior, format-specific parameter handling, and return shape. Annotations only indicate readOnly hint; description adds crucial behavioral context beyond annotations.

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?

Well-organized with sections for purpose, usage, key params, return shape, example, and risk class. Every sentence is informative and front-loaded.

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

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

Given the 7 parameters and output schema, the description covers return shape, inline image handling, parameter behavior, and risk class. It is comprehensive for the tool's complexity.

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

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

Despite 0% schema coverage, the description thoroughly explains key parameters (format, width_px, out_dir, name_prefix, inline, max_output_bytes) with constraints and behaviors, adding significant meaning.

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

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

The description clearly states 'Export the whole document to PNG, PDF, or SVG,' specifying the verb, resource, and supported formats. It distinguishes from siblings like export_object, export_batch, and profile tools.

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

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

Explicitly states when to use: 'producing a final file of the whole document' and lists alternatives for one object, batch, or bundle, providing clear 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?

Annotations already indicate safe read-only operation. Description adds extensive behavioral details: validation of object_id charset, sandbox checking for out_dir, inline PNG behavior gated by max_output_bytes, and return shape including stale flag.

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?

Well-organized with front-loaded purpose, clear paragraphs, and an example. Slightly verbose in explaining inline behavior but still efficient overall.

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?

Covers all 8 parameters, explains return shape (ExportResult), mentions risk class, and gives usage context with sibling differentiation. Output schema exists, but description adds value for inline image handling.

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

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

With 0% schema description coverage, the description compensates fully. It explains the role and constraints of object_id, format, out_dir, name_prefix, inline, and max_output_bytes, adding meaning beyond the schema.

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

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

The description clearly states 'Export a single object (by id) to PNG, PDF, or SVG.' It distinguishes from siblings by naming 'export_document' and 'export_batch' as alternatives for different use cases.

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

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

Explicitly states 'When to use: exporting one object, clipped to its own bbox' and provides when-not scenarios with specific sibling tool names.

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

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

Annotations already indicate readOnlyHint and destructiveHint. The description adds valuable behavioral context: output always differs from plain PDF due to PDF version pinning, exports to sandbox-checked dir, no original overwrite.

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

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

The description is well-structured with sections (When to use, Key params, Return shape, Example, Risk class) and front-loaded with the main purpose. Slightly long but every sentence adds value.

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

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

Given the output schema exists, the description explains the return shape and provides an example. It covers complexity well, ensuring an agent can use the tool correctly.

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

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

The schema has 0% description coverage, but the description explains out_dir (anchors to workspace root, sandbox-checked) and name_prefix (tags file). doc_id is not explicitly described but is implied. This compensates for the schema gap.

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

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

The description clearly states the tool exports a print-oriented PDF with specific properties. It distinguishes from sibling tools like export_web_profile and export_document by stating when each should be used.

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

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

The description explicitly provides usage guidelines: use for press-safe PDF, not for web assets (use export_web_profile) or plain export (use export_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?

Annotations declare readOnlyHint=true and destructiveHint=false, indicating a safe read operation. The description adds that the whole set is rejected on any single failure (no partial results) and labels risk as low, composing the per-doc engine. This adds useful behavioral context beyond annotations.

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

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

The description is well-structured with clear sections (purpose, when to use, key params, return shape, example, risk class) and is front-loaded with the main action. It is concise for the complexity but could potentially be shortened slightly.

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

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

Given the tool has 6 parameters, output schema, and complex behavior, the description covers all necessary aspects: purpose, usage, parameter semantics, return shape (per_doc, total_items, total_bytes, consistency with detailed cross-doc verdict), and a concrete example. It feels complete and self-contained.

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

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

With 0% schema description coverage, the description compensates by explaining key params: doc_ids must be non-empty and duplicate-free, specs is identical to export_batch's list, and dry_run/byte_budget/out_dir/name_prefix behave exactly as in export_batch. It also notes name_prefix is recommended to avoid collisions. Not all six params are fully detailed, but the critical ones 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 description explicitly states 'Batch-export a SET of documents in one call' with specific outputs (per-doc results + aggregate + verdict). It distinguishes from siblings like export_batch and create_icon_set, providing clear 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 'When to use' section gives explicit context for multi-document exports and names alternatives (export_batch for single documents, create_icon_set for icon sets). This provides clear guidance on when to choose this tool.

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

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

Annotations indicate readOnlyHint=true and destructiveHint=false. Description adds risk class (low), no original overwrite, sandbox checking, and pixel-capping behavior. No contradiction with annotations.

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?

Well-structured with sections (purpose, usage, key params, return shape, example, risk). Slightly verbose but each sentence adds value. Front-loaded with purpose.

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

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

For a tool with 6 parameters, 0% schema coverage, and an output schema, the description covers parameter interactions, return shape, typical usage, and risk. Output schema is mentioned but not detailed, which is acceptable since it exists.

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

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

Schema coverage is 0%, but description explains key parameters: widths, scales, width_px interaction, out_dir semantics (relative to workspace root, sandbox-checked), and name_prefix. Doc_id is not explained, but the description provides significant value beyond schema.

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

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

The description clearly states it exports a web-oriented asset set (responsive PNGs plus SVG). It distinguishes from siblings like export_print_profile, create_icon_set, and export_document.

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 'When to use' section and alternative tools provided. Clearly specifies when this tool is appropriate and when to use siblings.

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