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: optimistic version checking, no URL/S3 fetching, and that conflicts are not retried. It omits auth requirements, return shape, and what happens on a version conflict beyond 'not retried', but the concurrency semantics are unusually well disclosed.

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

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

Three tight sentences, zero filler, and the core action is front-loaded. Each sentence delivers a distinct fact (format, input mode, conflict behavior).

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

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

For a 7-required-parameter mutation tool with no annotations and no output schema, the description covers concurrency and input mode but leaves coordinate/size semantics, the base64 size ceiling, and failure behavior unexplained. It is coherent but not sufficient on its own for confident 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% across 7 required parameters, and the description explains none of them beyond implying bytes come inline rather than via URL. Nothing clarifies what x/y mean (origin, units, top-left vs center) or how width/height relate to the source image, leaving most calling decisions to guesswork.

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: 'Add PNG/JPEG bytes', with the target implied by the required drawingId parameter. It is distinguishable from drawing-level siblings like create_drawing, though it never explicitly says it inserts the image into a drawing or names the sibling operation it differs from.

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 such as apply_drawing_ops or other element-mutating tools. The only usage-adjacent statement is a negative input constraint ('No URL fetch or S3 credentials'), which tells the agent what it cannot pass but not when to pick 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?

With no annotations, the description carries the full burden. It valuably discloses atomicity (all-or-nothing) and a batch cap of 50, but says nothing about failure/rollback behavior, permission requirements, or the destructive nature of ops like delete and revert_to_snapshot. Solid but incomplete behavioral coverage for a write 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?

Three compact sentences, front-loaded with the core purpose and constraint. Nothing is wasteful, though 'the summary' is slightly ambiguous about which tool/artifact it points to.

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?

This is a high-complexity tool (nine op types, batches up to 50, atomic mutation) with no annotations and no output schema. The description does not describe the operation categories, return behavior, or failure semantics, leaving the agent under-informed for such a rich 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 coverage is 0%, so the description must compensate. It meaningfully explains drawingId (with fallback to the selected drawing) and the 50-op cap on ops, but clientBatchId is never mentioned and the nine op types are left entirely to the schema. Partially compensating, not fully.

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 ('apply ... semantic operations') and a key scope constraint ('Atomically apply up to 50'). The batch-mutation role is clear, and the reference to reading 'the summary first' implies the sibling get_drawing_summary, though no alternative is named explicitly.

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

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

'Read the summary first' gives an explicit prerequisite/ordering hint, and 'Uses drawingId when provided, otherwise the selected drawing' tells the agent how the target is resolved. It stops short of naming when-not-to-use cases or explicit alternatives, 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.

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 and largely fails. It hints at ownership semantics with 'owned' but says nothing about permissions, whether duplicate names are rejected, what happens on success, or whether the operation is reversible.

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

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

A single front-loaded sentence with zero waste, but it is under-specified rather than genuinely concise — brevity here comes at the cost of missing information rather than from tight editing.

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 creation tool with no annotations and no output schema, the description should explain what a created collection is, what 'owned' means, and what the caller gets back. None of that is present, leaving an agent guessing about core 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?

The single required parameter 'name' has 0% schema description coverage, and the description never mentions it or its constraints (minLength 1, maxLength 100). With low coverage, the description was expected to compensate and 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?

States a specific verb (create) and resource (collection), so an agent can tell it apart from the drawing-oriented siblings at a glance. However, the modifier 'owned' is unexplained and there is no differentiation from other collection tools like rename_collection or list_collections.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives (e.g., create_drawing for drawing creation). The agent must infer the entire usage context from the name alone.

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

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

No annotations are provided, so the description carries full responsibility. It discloses the optional selection side effect but omits details about permissions, return values, failure modes, or the meaning of 'default target.' This is insufficient for a mutation tool.

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

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

The description is a single, front-loaded sentence with no wasted words. It begins with the action and covers the core purpose efficiently.

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

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

For a simple two-parameter create operation, the description is adequate but not fully complete. It does not clarify what 'default target' means, what the tool returns, or any side effects, and with no annotations, additional context would be valuable.

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 does not explain the 'name' parameter or adequately detail the 'select' parameter. It says 'optionally select' but fails to convey that this controls the boolean 'select' field or how 'name' is used.

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

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

The description clearly states the tool creates a new empty Excalidraw drawing and optionally selects it as the default target. It uses a specific verb and resource, distinguishing it from sibling tools like select_drawing or list_drawings.

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

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

The description implies usage when a new drawing is needed, but it does not explicitly mention when to use this tool versus alternatives or any exclusions. It lacks clear guidance on the decision between creating and selecting an existing drawing.

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

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

Beyond the destructiveHint annotation, the description discloses real side effects: shares are also removed, drawings survive but become unorganized, and trash is undeletable. That is genuinely useful context for a destructive operation, though reversibility and permission requirements remain unstated.

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 clauses, front-loaded with the action and immediately followed by consequences and the key constraint. No filler; each clause carries distinct 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?

For a single-parameter destructive tool with no output schema, the description covers the action, cascade effects, and a failure case. It could say more about permissions or whether deletion is reversible, but nothing essential for correct invocation is missing.

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

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

Schema description coverage is 0%, so the schema documents nothing about collectionId. The description adds no param detail either, but the single parameter's name and 'owned collection' framing make its meaning largely self-evident, so this lands at an adequate baseline rather than a serious gap.

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

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

States a specific verb and resource ('Delete an owned collection') and clarifies scope ('and its shares'). It does not explicitly distinguish itself from delete_drawing among siblings, but the resource noun is unambiguous, so an agent will not confuse them.

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

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

The constraint 'Trash cannot be deleted' tells the agent one case where this fails, and 'owned' implies an ownership prerequisite. There is no explicit when-to-use or alternative routing (e.g., toward remove-from-collection style siblings), so guidance is only implied.

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

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

The destructiveHint=true annotation already flags this as a destructive operation, and the description adds genuinely useful context beyond it: the deletion is permanent and cannot be recovered via Trash. It still omits prerequisites such as required permissions or what happens to elements/collection memberships belonging to the drawing.

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

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

Two short sentences with zero filler; the destructive action is stated first and the recovery caveat immediately follows.

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 single-parameter destructive tool with no output schema and destructiveHint already declared, the description covers the essential irreversible-deletion behavior. Minor gaps remain around auth requirements and side effects on related entities.

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

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

There is one parameter, drawingId, at 0% schema description coverage, so the schema only supplies type and minLength. The description says nothing about the ID's format or provenance, but the name is self-explanatory for a delete-by-id tool.

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

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

States a specific verb and resource ('Permanently delete a drawing') and clarifies the scope of the deletion as irreversible rather than a soft delete. It doesn't name any sibling, but deletion is unambiguous against siblings like create_drawing, rename_drawing, or list_drawings.

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

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

No when-to-use or when-not-to-use guidance is given, and no alternative (e.g., moving to a collection/trash) is named. The 'not a move to Trash' line is a behavioral caveat about permanence, not routing 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?

With no annotations, the description carries the full burden and does disclose meaningful behavior: AND combination, exact matching for id/type, case-sensitive literal substring for text, and exclusion of deleted elements. It still omits read-only safety, pagination behavior, authorization needs, and return format, so it is partly but not fully transparent.

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

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

The description is a single compact statement, front-loaded with the filter semantics and the deleted-element exclusion. Every phrase contributes directly to invocation behavior, with no redundant or filler content.

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

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

For a 6-parameter search tool with no annotations, no output schema, and 0% schema description coverage, the description is too thin. It omits the required drawingId context, pagination behavior for limit/offset, read-only nature, and any indication of what is returned, so an agent lacks enough context to invoke it confidently.

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

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

Schema description coverage is 0%, so the description must compensate. It adds useful semantics for id, type, and text, including exact-match and case-sensitive substring behavior plus AND combination. However, it does not explain the required drawingId parameter or the limit/offset pagination parameters, leaving half the parameters without added 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 name and description imply a search over elements, and the filter semantics ('AND filters: exact id/type and case-sensitive literal text substring') are specific. However, the description never states what resource is being searched or that it operates within a drawing, leaving the core purpose vaguer than it should be and failing to clearly distinguish it from siblings like inspect_drawing_element.

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 no guidance on when to use this tool versus alternatives such as inspect_drawing_element or get_drawing. It describes filtering behavior and excludes deleted elements, but provides no context, prerequisites, or exclusions to help an agent choose it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose one genuinely useful trait — that files may be authenticated references rather than embedded bytes — which affects how the caller handles the result. But it says nothing about read-only safety, missing-drawing behavior, or payload size/cost, leaving meaningful 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?

Two short sentences with no filler, and the core purpose is front-loaded. The second sentence is terse but earns its place by warning about the reference-vs-bytes return shape.

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

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

With no annotations and no output schema, the description must carry the full load, and it only partially does. It covers the return-shape caveat but omits parameter usage, error/not-found behavior, and how the returned 'scene and version' relate to sibling tools.

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

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

There is one required parameter, drawingId, with 0% schema description coverage, so the schema adds no semantics. The description never mentions the parameter at all — not its format, whether it must come from list_drawings/select_drawing, or what an invalid id does — so it fails to 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?

States a specific verb+resource ('Get full scene and version') and the word 'full' implicitly contrasts with the sibling get_drawing_summary, which returns a summary. However, 'scene' is domain jargon that is never unpacked, so the exact payload is left partly to inference.

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

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

There is no guidance on when to use this versus get_drawing_summary, get_selected_drawing, or inspect_drawing_element, nor any stated preconditions (e.g. does the drawing need to be selected first?). The description only says what comes back, not when to call it.

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

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

With no annotations available, the description carries the full burden. It discloses the read-only nature ('Read') and the fallback behavior ('Uses drawingId when provided, otherwise the selected drawing'). However, it does not mention potential errors when no drawing is selected or what the returned summary contains.

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

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

The description is two concise sentences with no redundancy. It front-loads the core action ('Read a compact structural summary') and adds only the necessary fallback detail. Every word 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?

For a simple one-parameter read tool, the description covers the main behavior but leaves gaps: no output schema exists, so the return value of the 'structural summary' is not defined. Error handling when neither drawingId nor a selected drawing is available is also 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. It explains the single parameter drawingId's purpose and optionality, including the fallback to the selected drawing. This adds meaningful semantics beyond the bare schema, though it doesn't elaborate on ID format or source.

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

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

The description clearly states the tool's purpose: 'Read a compact structural summary of a drawing.' This uses a specific verb ('Read') and resource ('compact structural summary'), distinguishing it from sibling tools like get_selected_drawing or inspect_drawing_element.

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

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

The description implies when to use this tool (to get a summary) but does not explicitly contrast it with alternatives. It provides context on parameter usage via the fallback rule, but no explicit when-to-use/when-not-to-use guidance is given.

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

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

No annotations are provided, so the description must carry the behavioral burden. It does add useful context by specifying that selection is process-specific and that the action is a non-mutating 'Return'. However, it does not disclose behavior for an empty selection or the exact shape of what is returned.

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 contains all necessary information with no filler or redundancy. It avoids restating the tool name and is appropriately sized for a trivial getter.

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?

While the tool is simple (zero params), the lack of an output schema and annotations means the description should specify what 'drawing' returns (e.g., object, ID) and what happens if no drawing is selected. It covers the core purpose but leaves edge-case and return-shape details undetermined.

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

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

The tool has zero parameters and the schema provides complete coverage (100% vacuously). Per the rubric, zero-parameter tools receive a base score of 4; the description adds meaning by indicating that the tool relies on existing process selection state rather than arguments.

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 ('Return') and a specific resource ('the drawing currently selected by this MCP process'), and it clearly differentiates from sibling tools like list_drawings (returns all drawings) and select_drawing (changes the selection).

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

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

The phrase 'currently selected' implies this should be used after a selection has been made via select_drawing, but the description does not explicitly state when to use it versus alternatives or what happens if there is no current selection. Usage is implied rather than 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 for behavioral disclosure. It implies a read-only operation via 'Inspect' but does not confirm side effects, permissions, or return behavior. 'Bound children' is not defined, and output format is omitted.

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

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

The description is a single concise sentence that front-loads the primary action and includes key selection logic without unnecessary words. It earns its place despite being short.

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 no annotations and no output schema, the description is too minimal. It does not describe return values, the nature of 'bound children', or any operational context, leaving significant gaps for an agent to handle 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 description compensates for the 0% schema coverage by explaining drawingId's selection logic ('Uses drawingId when provided, otherwise the selected drawing'). elementId is only implicitly described as the element to inspect, so not all parameter semantics are fully clarified.

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

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

The description clearly states the action ('Inspect') and the resource ('one element and its bound children'), which distinguishes it from sibling tools like get_drawing_summary or select_drawing. It is specific about the scope of the inspection.

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 useful context by explaining how drawingId is used ('Uses drawingId when provided, otherwise the selected drawing'), giving clear guidance on parameter selection. However, it does not explicitly compare with alternatives or state when-not-to-use, leaving the choice somewhat implied.

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

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

No annotations are provided, so the description carries the full burden. It does disclose something beyond the schema — that results include both owned and shared collections and server ownership metadata — but says nothing about pagination, result size, or any auth/scope constraints.

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 scope qualifier is placed immediately after the resource. It is efficient, though too brief to be exemplary.

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

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

There is no output schema, so the description is the only source of information about what comes back, and it covers that only partially (ownership metadata, owned vs shared) without describing the return structure. For a zero-parameter read tool this is minimally adequate.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The empty schema means there are no parameter semantics for the description to explain or omit.

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

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

States a specific verb (List) and resource (collections) and adds scope: 'owned and shared' plus the fact that ownership metadata is included. This is enough to distinguish it from list_drawings, though it does not explicitly name the sibling alternative.

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

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

No indication of when to use this versus list_drawings or the collection-mutation siblings, and no preconditions or exclusions are given. 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?

With no annotations provided, the description carries the burden of disclosing behavioral traits. It mentions the account API key scope, which is useful, but does not describe pagination behavior, return format, or whether it reads from a cache. For a simple list operation, this is average but not rich in 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 concise: two sentences with no wasted words. The first sentence states the action, the second provides usage context. It is well-structured 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?

The tool is straightforward, and the description provides the essential purpose and temporal usage. However, with no output schema and no annotations, the description does not mention what the tool returns, such as drawing IDs or metadata, nor does it discuss default pagination or search semantics. This leaves some gaps for a complete understanding.

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 does not elaborate on the parameters (limit, offset, search). While the schema provides names and defaults, the description fails to clarify the meaning of 'search' (e.g., search by name, content, etc.) or how pagination works, leaving significant interpretation to the agent.

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 'List' and the resource 'ExcaliDash drawings available to the account API key', which precisely defines the tool's scope. It distinguishes itself from sibling tools like select_drawing by indicating this is a listing operation, not a selection or creation.

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 this before selecting a drawing' provides explicit temporal guidance relative to the sibling tools. It tells the agent when to invoke this tool, though it does not explicitly mention alternatives or when not to use it, leaving some room for ambiguity.

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

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

No annotations provided, so description carries full burden. It states the move action and that null means unorganized, but does not disclose permissions required, whether the drawing must exist, or side effects. Mutation tool with no annotations; this is a gap but minimal disclosure.

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

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

Single, front-loaded sentence with no waste. Appropriately sized for a simple move tool.

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

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

Mutation tool with no annotations, 0% schema coverage, no output schema. Description is too sparse: missing prerequisites, error conditions, and parameter details beyond null 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?

Schema coverage is 0%, so description must compensate. It only clarifies that collectionId can be null for unorganized, which is already in the schema's anyOf. No description of drawingId or collectionId semantics beyond that.

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: moving a drawing to a collection. The 'or null for unorganized' adds behavior. However, does not distinguish from siblings like create_collection or list_collections, but the action is distinct enough.

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

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

No explicit when-to-use vs alternatives. Implied that this is for moving existing drawings, but no exclusions or prerequisites.

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 for a mutation tool. It usefully discloses the ownership requirement and the trash exclusion, but says nothing about reversibility, error behavior on name collisions, or whether the rename affects references elsewhere.

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

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

Two short sentences with the core operation front-loaded and the restriction immediately following. No filler or redundancy.

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

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

A two-required-parameter mutation tool with no annotations and no output schema needs more than two sentences. The eligibility rule is covered, but parameter meaning, failure modes, and the result of the operation are all 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 description coverage is 0%, so the description must compensate and does not. It never mentions the collectionId or name parameters, nor the name constraints enforced by the schema (1–100 chars), leaving both parameters semantically 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?

Specific verb+resource ('Rename an owned collection') with a scope qualifier ('owned') that narrows which collections are eligible. This cleanly separates it from siblings such as rename_drawing, create_collection, and delete_collection.

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 a when-not condition: 'Trash cannot be renamed,' and 'owned' implies a permission precondition. It stops short of naming alternatives or explaining how to handle non-owned collections, so it is clear context without full 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses nothing about required permissions, whether names must be unique, whether the change is reversible, or what the operation returns; for a mutation tool this is a significant gap.

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

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

A single short sentence with no filler, and the operation is front-loaded. It is efficient, though it errs toward under-specification rather than true concision.

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

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

With no annotations, no output schema, and two parameters documented only by name, the description leaves the agent without enough context to invoke the tool confidently. A sentence on permissions, name constraints, or return behavior would close the gap.

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

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

Schema description coverage is 0%, and the description only hints at 'drawingId' via 'by ID' while saying nothing about the 'name' parameter, its 1-200 length bounds, or format constraints. Almost no meaning is added beyond the bare parameter names.

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

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

States a specific verb and resource ('Rename a drawing') plus the identifying mechanism ('by ID'), which is enough to distinguish it from siblings like create_drawing, delete_drawing, or rename_collection. It stops short of any explicit sibling differentiation, so it lands at 4 rather than 5.

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

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

There is no guidance on when to use this tool versus alternatives such as apply_drawing_ops or create_drawing, and no mention of prerequisites or exclusions. Usage is only implied by the verb.

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

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

With no annotations, the description must carry the full behavioral burden. It discloses that the tool sets a process-scoped default target, which is the core behavior. However, it does not mention input validation, behavior on invalid IDs, overwriting previous selections, or return values. This leaves meaningful gaps for a state-changing tool.

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

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

The description is a single sentence of 15 words, front-loading the verb and resource. It contains no filler or redundant information, making it highly concise and well structured.

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

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

For a simple one-parameter tool, the description covers the core purpose, but lacks details about return values (no output schema) and prerequisite steps like listing drawings to get a valid ID. It is adequate for a straightforward selection operation but not fully complete for an agent to invoke with confidence.

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

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

Schema coverage is 0%, and the description adds no information about drawingId beyond its name. It does not explain where to obtain the ID, whether it must reference an existing drawing, or any format expectations. The parameter name is self-explanatory, but the description fails to compensate for the lack of schema details.

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 selects an Excalidraw drawing as the default target for subsequent tools. This is a specific verb+resource+effect combination that also distinguishes it from siblings like get_selected_drawing (retrieve) and list_drawings (list).

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

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

The description provides clear context: use this tool to set a default target before invoking other tools. It does not explicitly mention alternatives or exclusions, but the phrase 'subsequent tools' implies the intended workflow. Since no alternatives are named, 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.