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

Annotations only provide a title, so the description carries the behavioral burden. It reveals prerequisites (tag must exist), supported item types (sticky_note, card), and a voice-friendly output example. 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?

Extremely concise: two sentences for core purpose, then structured USE WHEN, FAILS WHEN, and VOICE-FRIENDLY sections. Every sentence adds value 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?

The description covers prerequisites, failure cases, and usage examples. With an output schema present, return values are handled separately. All necessary context for a simple attachment tool is provided.

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 100% with descriptions, but the description adds context: tag_id must exist on the board, and item_id must be a sticky_note or card (schema restricts to sticky note, description adds card). This adds value 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 the tool attaches an existing tag to a sticky note or card, specifying verb, resource, and target. It distinguishes from siblings like miro_create_tag and miro_detach_tag.

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 usage examples and failure conditions are provided. It explains when it fails (tag doesn't exist, wrong item type) and implies using miro_create_tag first. Could be slightly more explicit about alternatives like miro_detach_tag for removal, but overall clear.

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

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

No annotations exist, so description carries full burden. Adds max-20 constraint but does not disclose atomicity, partial failure behavior, or side effects beyond 'Created 5 items on the board'.

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

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

Three sentences each adding distinct value: purpose+limit, alternative, usage examples. No redundant text, 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?

Has output schema so return values are covered. Missing mention of board existence prerequisite, but overall sufficient for a bulk create tool given schema and sibling context.

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

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

Schema coverage is 100% so all parameters are documented. Description adds max-20 limit and example usage but not extra semantic 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?

Clearly states 'Create multiple items at once (max 20)' with a specific verb and resource, explicitly distinguishes from sibling miro_create_sticky_grid via naming.

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-not-to-use advice ('For creating only stickies in a grid, use miro_create_sticky_grid instead') and lists example user queries under 'USE WHEN'.

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, description adds 'Cannot be undone' and advises dry_run for safety, fully disclosing 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?

Very concise, with purpose and warning front-loaded. The voice-friendly line is extraneous but not distracting.

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 essential aspects: purpose, limits, safety, and parameter hint. With output schema present, return values need not be explained. Sufficient for an agent.

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

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

Schema already covers parameters (100% coverage), but description adds value by explaining dry_run's purpose and confirming the 20-item limit.

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 the tool deletes multiple items at once with a max of 20, distinguishing it from single-item delete or other bulk operations among siblings.

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

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

Provides clear warning about irreversibility and recommends using dry_run for preview, guiding safe usage. Could explicitly mention alternatives but not necessary.

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 fails to disclose behavioral traits beyond the obvious mutation (update). No annotations provide info on idempotency, permissions, or side effects. The VOICE-FRIENDLY snippet adds an example but no 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?

The description is two sentences plus a VOICE-FRIENDLY line, all concise and front-loaded. Every sentence earns its place 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?

With 100% schema coverage, an output schema, and only 2 parameters, the description covers the key constraints (max 20, partial updates). It is mostly complete, though it could mention error handling for partially successful updates.

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 covers 100% of parameter descriptions, but the description adds semantic value by noting the partial update strategy ('Only provide fields you want to change') which is not captured in the schema.

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

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

The description clearly states 'Update multiple items at once (max 20)', specifying the verb, resource, and constraint. The tool is distinct from siblings like miro_update_item by targeting multiple items in one call.

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 guidance to 'Only provide fields you want to change' and notes the max 20 limit. While it doesn't explicitly exclude alternatives, the context implies this tool is for bulk updates, leaving single updates to other tools.

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

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

With no readOnlyHint or destructiveHint annotations, the description carries the burden of behavioral disclosure. It states 'Copy an existing Miro board', which implies a non-destructive read (the original is unchanged) and creates a new board (a write operation). However, it does not mention specific permissions required, rate limits, or what happens to the original board's content (e.g., dependencies on attached items). The description is adequate but minimally informative.

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 very short: one sentence stating the purpose and a voice-friendly example. It is front-loaded with the essential information. The voice-friendly line, while not strictly necessary, provides a concrete illustration. The brevity is effective, though the example could be considered extraneous.

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 (4 parameters, all documented in schema) and the presence of an output schema (as per context signals), the description doesn't need to explain return values. It provides the core functionality. However, it could mention that the copy results in a new board with a new ID, or potential side effects like duplicating content. Still, for a copy operation, it is reasonably 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 100% with descriptions for all 4 parameters. The description does not add any extra meaning beyond what the schema already provides (e.g., the name defaults to 'Copy of {original}'). Thus, the description adds no value over the schema, earning the baseline score of 3.

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

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

The description clearly states the verb 'Copy' and the resource 'existing Miro board', making the tool's purpose unmistakable. It distinguishes itself from sibling tools like miro_create_board (which creates a new board from scratch) and miro_find_board/search_board (which locate boards without creating copies).

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 no guidance on when to use this tool versus alternatives, such as miro_create_board for a new board or miro_share_board for sharing. There are no exclusions or context about prerequisites (e.g., the user must have access to the original board). The voice-friendly line is not 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?

Annotations are minimal, so description carries full burden. It states creation but does not disclose side effects, permissions, or error conditions. Basic transparency but no extra context beyond the action itself.

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

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

Very concise: two brief sentences plus targeted USE WHEN and VOICE-FRIENDLY examples. No wasted words, front-loaded with key 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?

Covers purpose, differentiation, and provides example usage. Output schema exists, so return value explanation not needed. Minor gap: no mention of required parameters like board_id, but schema covers that.

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 100%, so baseline is 3. Description mentions 'custom fields and status indicators' but does not add meaning beyond the schema definitions. No additional parameter 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 creates an app card with custom fields and status indicators, distinguishing it from miro_create_card for simple cards. The verb 'create' and resource 'app card' are 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?

Explicitly tells when to use this tool vs alternative: 'For simple cards with due dates, use miro_create_card instead.' Also provides 'USE WHEN' phrases, giving clear context for 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?

Annotations provide no readOnlyHint or destructiveHint, so the description carries full burden. It merely states creation without behavioral details like immediate effect, permissions, limits, or response structure. The VOICE-FRIENDLY gives a sample output but no deeper traits.

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 very short and includes a voice-friendly example. It is efficient, though it could be more structured to mention output schema or 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 simple create tool with 3 parameters (1 required) and an output schema, the description is minimally adequate. It lacks mention of return values, but output schema exists separately, so not a critical 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 100%, with each parameter already described. The tool description adds no extra meaning beyond schema, so baseline score of 3 applies.

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 new Miro board' with a specific verb and resource. It distinguishes from sibling tools like miro_update_board or miro_delete_board. The VOICE-FRIENDLY example adds concrete context.

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

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

No guidance is provided on when to use this tool versus alternatives such as miro_copy_board or miro_find_board. No prerequisites, exclusions, or context for use are mentioned.

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 are minimal (only title), so the description must carry the behavioral burden. It states 'Create' (a mutation) but does not disclose side effects, authentication needs, or rate limits. The mention of card features (title, description, due dates) is basic, not behavioral.

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 with three sentences plus USE WHEN and VOICE-FRIENDLY examples. It is front-loaded with the core action and 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 full schema coverage and an output schema (though not shown), the description is largely complete. It does not describe return values, but output schema likely covers that. It covers purpose, usage, and distinction from siblings.

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 100%, so baseline is 3. The description does not add meaning beyond the schema; it only reiterates that cards have title, description, and due dates. No parameter-specific extra context.

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

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

The description clearly states 'Create a card on a Miro board' with a specific verb and resource. It differentiates from the sibling tool miro_create_app_card by noting the latter is for cards with custom fields and status.

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 USE WHEN examples are given ('add a card', 'create a task card', 'card with due date'). It also specifies when not to use (for custom fields/status, use miro_create_app_card).

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 reveals it creates a connector (mutation) and lists style/cap options, but does not disclose side effects, failure modes, or that items must be on the same board. No annotations provide behavioral hints, so the description carries the burden but falls short.

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 concise sentences: first states core purpose, second lists configurable options. No redundant words, front-loaded with critical 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?

With 7 parameters fully described in schema and an output schema present, the description covers the essential action and customization. Missing context about prerequisite item existence or board scope, but acceptable for a straightforward creation tool.

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

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

Schema coverage is 100%, so baseline is 3. Description adds detailed enumerations for style and caps (e.g., 'straight, elbowed (default), curved') beyond the schema's brief phrases, adding value for parameter selection.

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 'Create a connector line between two items' with clear verb and resource. Lists style and cap options, distinguishing from sibling create tools like miro_create_shape or miro_create_card.

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

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

No guidance on when to use this vs alternatives, no prerequisites mentioned (e.g., items must exist on the board), and no exclusion criteria for when not to use 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?

Annotations are minimal (only title), so the description carries the transparency burden. It discloses the operation (create), supported Markdown elements, and a voice-friendly confirmation message. It does not mention authorization or side effects, but the context is straightforward for a create operation.

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

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

Well-structured with sections (USE WHEN, PARAMETERS, EXAMPLE, RELATED, VOICE-FRIENDLY) and front-loaded main sentence. No redundant information, though sections like PARAMETERS partially overlap with schema. 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?

With output schema present, description does not need to explain return values. It covers purpose, usage context, parameter behavior, examples, and related tools. Missing error handling or permission details, but sufficient 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?

Schema coverage is 100%, baseline 3. The description adds value by listing `board_id`, `content`, `x`, `y`, `parent_id` with brief meanings, notes that `content` supports specific Markdown features, and includes a concrete example. This exceeds the baseline.

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 (create), resource (rich text document on Miro board), and input format (Markdown). It distinguishes from sibling 'miro_create_document' which is for URL-based documents, and 'miro_create_text' for plain text, making the purpose unambiguous.

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

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

Provides explicit 'USE WHEN' section listing typical user prompts like 'add a document' or 'create a doc from markdown', and a 'RELATED' section naming alternatives such as miro_get_doc, miro_delete_doc, and miro_create_document, clearly guiding when to use vs. other tools.

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

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

Annotations provide no behavioral hints (e.g., readOnlyHint, destructiveHint), so the description must fully disclose behavior. It only says 'Add' (implying creation) but omits side effects, permission requirements, success/failure responses, or limits on file size/type. The output schema exists but the description does not reference what happens on completion.

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

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

Two sentences convey the purpose, a key constraint, and an alternative tool. No redundant information; 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?

The description covers the main action and a critical condition, but given the parameter count (7) and the existence of an output schema, it could mention positioning (x, y), parent frame, or result details. It is adequate but not fully comprehensive.

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 100%, but the description adds value beyond schema: it clarifies that the URL must be publicly accessible and specifies allowed document types ('PDF, etc.'). These constraints are not present in the parameter 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 the verb 'Add', the resource 'document', and the source 'from a URL'. It specifies document type (PDF, etc.) and the URL accessibility requirement. It distinguishes from the sibling tool miro_upload_document by indicating the alternative for local files.

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

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

The description explicitly states a key precondition (URL must be publicly accessible) and directly points to the alternative tool miro_upload_document for local file uploads. This provides clear guidance on when to use this tool versus its sibling.

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

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

Description clearly indicates a create operation (embedding), but lacks details on permissions or side effects. No annotations beyond title, so description is adequate.

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?

Concise, front-loaded with purpose, uses bullet points for usage guidance. 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?

Covers main use case and includes examples. With output schema present, return details are implicit. Minor gap: does not explicitly state that board_id and url are required, but schema handles that.

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 100%, so description adds limited value beyond schema. It lists supported URL providers, which aids understanding but is not critical.

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 the tool embeds external content as live preview, lists specific providers, and distinguishes from sibling tools like miro_create_image and miro_create_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?

Provides explicit 'USE WHEN' examples and alternatives, making it easy for an agent to decide when to use this tool versus siblings.

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

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

Discloses async behavior (returns job ID for monitoring) and enterprise-only restriction. Annotations lack readOnlyHint/destructiveHint, so description compensates by implying non-destructive export. Could mention rate limits or auth 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?

Two impactful sentences with no wasted words. Front-loads purpose and critical constraint (enterprise only).

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, async behavior, enterprise restriction, and follow-up step. Output schema exists, so return value details not needed. Complete for a straightforward export job creation.

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 describes all 4 parameters with full coverage. Description adds no extra parameter details beyond schema, so baseline 3 is appropriate.

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 verb 'Export' and resource 'boards', with specific formats (PDF, SVG, HTML). Differentiates from sibling create tools by focusing on export.

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

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

Explicitly notes 'ENTERPRISE ONLY', guiding when not to use. Advises to monitor via miro_get_export_job_status, providing post-call guidance. Does not explicitly exclude alternatives, but no competing export tools 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 are minimal (only title), so the description carries the burden. It discloses that the tool uses the v2-experimental API and that shape types may change when moving to GA. While it doesn't discuss permissions or side effects, the experimental warning adds important behavioral context. 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?

The description is well-structured with clear sections: overall description, USE WHEN, PARAMETERS, and NOTE. It is concise with no redundant sentences, and each section is front-loaded with the most important 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?

Given the presence of an output schema, the description need not explain return values. It covers purpose, usage guidelines, experimental API warning, and parameter details comprehensively. The description is complete for an agent to understand and 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?

Schema coverage is 100%, so baseline is 3. The description adds value by listing supported shape types, providing example hex values for fill_color and border_color, and mentioning default sizes. This goes beyond the schema descriptions, helping the agent understand valid inputs.

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

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

The description clearly states the purpose: to create a flowchart shape using the experimental API, and it distinguishes from the sibling tool miro_create_shape by noting it supports additional stencil shapes beyond standard shapes. The verb 'create' and resource 'flowchart shape' are 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?

The description explicitly provides 'USE WHEN' conditions, listing user phrases that should trigger this tool, and directly states that for standard shapes, use miro_create_shape instead. This gives clear guidance on when to use the tool versus an alternative.

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 are minimal (only a title), so the description carries the burden. It discloses that a frame is a visual container, but does not discuss any behavioral traits such as destructive nature, authorization requirements, rate limits, or side effects. The behavior is predictable as a creation tool, but more detail would benefit the agent.

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 consists of two sentences that are concise and front-loaded. Every word adds value, with no extraneous 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?

Given that all parameters are described in the schema and there is an output schema, the description sufficiently covers the tool's purpose and differentiation from a sibling. It could mention the visual nature more explicitly, but overall it is complete 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?

Schema description coverage is 100% for all 7 parameters, so the baseline is 3. The description does not add any parameter-specific meaning beyond what the schema already provides. It does not explain defaults (e.g., width=800, height=600) or constraints.

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

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

The description clearly states 'Create a frame container to group items visually', specifying the verb 'create', the resource 'frame container', and the purpose 'group items visually'. It also distinguishes from the sibling miro_create_group by noting the difference between visual and logical grouping.

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 guidance on when to use this tool versus miro_create_group for logical grouping without a visual border. However, it does not mention any other usage contexts, prerequisites, or scenarios where this tool should not be used.

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 provide only a title, so description carries burden. It discloses that grouped items move and resize together, but does not mention permissions, reversibility, or whether original items are modified. Some behavioral context is given but lacks depth.

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 concise sentences plus a voice-friendly line. No filler, every sentence adds value. Action and key differentiator are 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?

For a simple 2-parameter tool with full schema coverage and an existing output schema, the description is largely complete. It explains grouping behavior and differentiates from frame. Minor omission: no mention of whether groups can be nested or modified afterward, but overall 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 coverage is 100% with descriptions for both parameters (board_id and item_ids). Description does not add parameter-specific details beyond the schema. Baseline 3 per instructions.

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 the action: group items logically, and specifies that grouped items move and resize together. It differentiates from miro_create_frame by noting that frame provides a visible container with border and title. The verb 'group' and resource 'items' are explicit.

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?

Description explicitly tells when not to use this tool (for a visible container, use miro_create_frame), providing a direct alternative. It also includes a voice-friendly example, guiding the agent on phrasing.

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 behavioral constraints (publicly accessible URLs) and aspect ratio preservation. Annotations are minimal, so description carries burden; could mention error handling or idempotency but covers key trait.

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, front-loaded key info, no redundant sentences. Efficient and clear.

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

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

Output schema exists (not needed in description), all 7 parameters covered, usage guidelines and behavioral note present. Complete for invocation.

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

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

Schema coverage is 100% with descriptions; description restates parameters without adding significant new meaning beyond the schema, baseline 3 is appropriate.

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 'Add' and resource 'image to a Miro board from a URL', distinguishing it from siblings like miro_upload_image for local files.

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

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

Includes explicit 'USE WHEN' trigger phrases and a 'RELATED' alternative (miro_upload_image), providing 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?

Annotations provide no hints (no readonly/destructive), so the description carries the burden. It states 'create' (mutation) and covers parent_id and node_view, but does not disclose error handling, limits, or side effects like ignored x/y for children. Acceptable but not thorough.

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 extremely concise: two sentences, no filler. Every word adds value. Front-loaded with the main 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?

Given the presence of an output schema and the tool's simplicity, the description covers core usage. It could mention board_id context or how to verify creation, but it's sufficient for a create tool.

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

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

Schema coverage is 100%, baseline 3. The description adds value by explaining when to use parent_id (root vs child) and providing the default for node_view, going beyond 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 mindmap node' with a specific verb and resource. It distinguishes from sibling tools like miro_create_card or miro_create_sticky by focusing on mindmap nodes. The details about root vs child nodes further clarify 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?

The description provides clear instructions: 'Omit parent_id for root; add parent_id for children' and mentions node_view defaults. It does not explicitly compare to alternatives, but the context of mindmap-specific tools and the name itself guides usage adequately.

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 lack behavioral hints, so the description carries the burden. It describes the creation action, required parameters, and return values (item ID, shape type, position, size, view link). However, it does not mention permissions or side effects, which would be beneficial but not critical for a straightforward creation 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 well-structured with clear sections (USE WHEN, SHAPE TYPES, PARAMETERS, RETURNS, RELATED, EXAMPLE). It is concise yet informative, with no unnecessary text.

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

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

For a tool with 10 parameters (2 required), the description covers all essential aspects: purpose, shape categories, parameter descriptions, defaults, return type, and a related tool. The example further aids 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 coverage is 100%, but the description adds value by grouping shape types (Basic, Flow, Flowchart) and providing default values for width, height, x, y. It also includes an example showing parameter usage.

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 shape on a Miro board' and lists specific shape types. It distinguishes from sibling tool miro_create_flowchart_shape, making the tool's purpose unambiguous.

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

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

The description includes explicit 'USE WHEN' triggers (e.g., 'add a rectangle') and points to an alternative tool for flowchart-specific shapes, providing clear 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?

No annotations beyond title, and description only says 'Create' without detailing side effects, permissions, or limitations. The voice-friendly example adds minimal 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?

Extremely concise, front-loaded with core purpose, then alternatives and use cases. 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?

For a simple single-item creation tool with output schema, description covers purpose, alternatives, and examples. No gaps given tool 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?

Input schema has 100% coverage, so baseline 3. Description adds example color list and position defaults but no deeper semantics 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?

Description clearly states 'Create a sticky note on a Miro board' and distinguishes from sibling tools like miro_create_sticky_grid and miro_bulk_create.

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 USE WHEN phrases and mentions alternatives, making it clear when to use this tool vs others.

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 reveals a key behavioral trait: max 50 stickies. The VOICE-FRIENDLY example hints at the output format. However, with no annotations beyond title, it could disclose more about potential side effects or auth requirements.

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 very concise: only three sentences plus structured USE WHEN and VOICE-FRIENDLY sections. It is front-loaded with the core purpose and contains 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?

The description covers the main purpose, usage guidelines, constraints, and an example output. With output schema existing, return values are covered. However, it omits details like grid layout behavior (e.g., row filling) and default parameter values.

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 100%, so the schema already documents all parameters. The description adds little extra meaning beyond the schema, though the VOICE-FRIENDLY example indirectly references columns. Baseline 3 is appropriate.

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 multiple sticky notes arranged in a grid layout (max 50).' It distinguishes itself from the sibling miro_bulk_create by advising 'For mixed item types, use miro_bulk_create.' The USE WHEN phrases further clarify the specific use case.

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 scenarios via USE WHEN phrases and gives an alternative tool for mixed item types. While it doesn't mention miro_create_sticky, the grid layout implies it's for multiple items, and the max limit is 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?

The description implies mutation (create), lists allowed colors, and provides an example output. However, it does not disclose permission requirements, board-scoping, or whether the tag is created unattached. With no annotations, the description carries the burden but offers only minimal behavioral detail.

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 short and front-loaded with the action. The VOICE-FRIENDLY line is a minor addition but does not detract from clarity. It is efficient 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 presence of an output schema and full parameter coverage, the description adequately covers the tool's purpose and inputs. It does not mention post-creation steps (attaching), but for a simple creation tool, it is sufficient.

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

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

Schema coverage is 100%, so parameters are already documented. The description adds a list of colors (duplicating schema) and an example voice-friendly message, providing slight reinforcement but no new semantic 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 'Create a tag on a Miro board' which is a specific verb and resource. It does not differentiate from siblings like miro_attach_tag, but the purpose is unambiguous.

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

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

No guidance on when to use this tool versus alternatives such as miro_attach_tag or miro_update_tag. The description lacks context on the typical workflow of creating and then attaching tags.

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 are minimal (only title), providing no readOnlyHint or destructiveHint. The description does not disclose behavioral traits such as whether the tool is idempotent, required permissions, or side effects. Given the lack of annotation support, the description should have provided more 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 extremely concise: two sentences plus a list of use cases. Every sentence provides distinct and valuable information without redundancy or verbosity.

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 (8 params, 2 required), the description is fairly complete. It covers purpose, usage, and alternatives. The presence of an output schema reduces the need to explain return values. Minor lack of behavioral transparency prevents a perfect score.

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 100% with all 8 parameters described. However, the description adds no additional meaning beyond the schema's minimal descriptions (e.g., 'X position', 'Text color'). Baseline of 3 is appropriate as per guidelines when coverage is high but description adds no extra value.

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: 'Add free-floating text to a Miro board with no background or border.' It explicitly distinguishes this tool from siblings miro_create_sticky and miro_create_doc, providing specific differentiators.

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 states when to use alternatives: 'For notes with colored backgrounds, use miro_create_sticky. For rich Markdown documents, use miro_create_doc.' It also provides example user intents like 'add a title', 'put heading text', which guides the AI agent effectively.

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 signal destruction; description adds 'Cannot be undone' and preview suggestion, which are behavioral traits beyond what destructiveHint provides. 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?

Three concise sentences: purpose, warning, voice-friendly confirmation. No filler, efficient 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 output schema exists and schema covers all parameters, description is fairly complete. The warning and dry_run hint cover the most important behavioral context. Could optionally mention permissions or async behavior, but not required.

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 100%; description adds the dry_run use case (preview before delete) beyond schema, but no extra meaning for board_id or item_id.

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 starts with 'Delete an app card from a Miro board' — a specific verb+resource combination that clearly distinguishes it from sibling create and update 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?

Includes a warning about irreversibility and suggests using dry_run=true for preview, which guides usage, but lacks explicit comparison to other delete tools like miro_delete_item or miro_delete_board.

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 context beyond annotations: explains permanence and preview option. No contradiction with destructiveHint=true.

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

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

Two sentences, front-loaded with purpose, then essential warning. No extraneous 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?

Covers main behavioral aspects (permanence, preview) and has output schema. Missing permissions or ownership requirements, but sufficient for a simple delete tool.

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

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

Schema coverage is 100% with descriptions for both parameters. Description adds emphasis on dry_run but no new semantics 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?

Clearly states verb 'Delete' and resource 'board permanently'. Distinguishes from sibling tools like miro_delete_item because it specifies deletion of the board itself.

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

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

Explicitly warns that the action cannot be undone and recommends using dry_run=true to preview. Does not compare to alternatives like miro_delete_item, but provides clear safety 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 mark destructiveHint=true. The description adds valuable context: 'Cannot be undone' and recommendation to use dry_run. However, it does not mention error handling (e.g., if connector not found) or authorization requirements.

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 extremely concise with three sentences, includes a clear warning, and is front-loaded. Every sentence adds value with no redundancy.

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

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

For a delete tool with an output schema and three parameters, the description covers purpose, irreversible effect, and a preview option. It is complete enough for correct invocation.

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

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

Schema coverage is 100%, so baseline is 3. The description mentions dry_run in the warning but does not add additional meaning beyond the schema's parameter 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 'Delete a connector from a Miro board,' which is a specific verb+resource+scope. It easily distinguishes from sibling tools like miro_create_connector and miro_update_connector.

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 guidance: 'WARNING: Cannot be undone. Use dry_run=true to preview first.' This tells when to use (with precaution) and suggests an alternative approach (dry_run) to test without consequences.

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 set destructiveHint=true, and the description adds a clear warning that the action cannot be undone and recommends using dry_run=true to preview. This provides important behavioral context beyond the annotation.

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 for purpose, usage, parameters, warning, and related tools. It conveys all essential information in a concise, front-loaded format with no unnecessary 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 delete operation, the description covers purpose, usage guidelines, parameters, and important warnings. Since an output schema exists, the lack of return value explanation is acceptable. The context is complete 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?

Schema coverage is 100%, so the description adds minimal value beyond what the schema already provides. The description lists parameters with similar wording, but does not add new semantic depth or examples.

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

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

The description clearly states it deletes a doc format item from a Miro board, using a specific verb and resource. It distinguishes from sibling tools like miro_delete_item by specifying 'doc format item' and mentions related tools miro_get_doc and miro_create_doc.

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?

Includes explicit 'USE WHEN' triggers such as 'remove the document' and 'delete that doc'. Provides warning about irreversibility, suggests dry_run for preview, and directs to miro_get_doc for inspection before deletion.

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 critical details beyond destructiveHint annotation: items are ungrouped, operation cannot be undone, and suggests dry_run preview. 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?

Three efficient sentences covering purpose, warning, and voice-friendly feedback with no redundant text.

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

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

Adequately covers behavior, safety, and usage; missing mention of prerequisites like valid board_id, but sufficient for a delete operation given output schema 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 covers all parameters; description adds context for dry_run parameter, enhancing understanding beyond schema alone.

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

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

Clearly states 'Delete a frame' and distinguishes behavior by noting items inside are not deleted but ungrouped, differentiating it from siblings like miro_delete_item.

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 cautionary note about irreversibility and recommends dry_run=true for preview, but does not explicitly contrast with alternative deletion tools.

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

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

The description adds significant value beyond the destructiveHint annotation by explaining the default behavior (items released), warning that item deletion is irreversible, and suggesting a dry_run preview. All behavioral traits are 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 concise yet comprehensive, organized into clear sections (USE WHEN, WARNING, VOICE-FRIENDLY). 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?

All necessary aspects are covered: purpose, usage, parameter behavior, and important warnings. The description is complete for confident tool invocation, given the supporting schema and annotations.

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

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

Schema coverage is 100% with each parameter described. The description enhances understanding by clarifying the effect of delete_items (default false) and how dry_run works, providing practical context 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 'Delete a group' and distinguishes between two modes: deleting only the group (ungrouping items) or deleting both group and items. This differentiates from sibling tools like miro_delete_item.

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 scenarios ('USE WHEN: deleting a group OR ungrouping items') and explains the behavior of the delete_items parameter with default values. While it doesn't mention alternatives explicitly, the guidance is clear and practical.

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 context beyond the destructiveHint annotation by explicitly stating 'Cannot be undone' and recommending dry_run for preview. No contradiction with annotations (destructiveHint: true 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 two sentences: the first efficiently states the purpose, and the second adds a critical warning. Every sentence is necessary and front-loaded, with no extraneous 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?

For a simple deletion tool with an output schema, the description covers the essential purpose, irreversible nature, and dry_run option. However, it could be more complete by clarifying its scope relative to sibling tools (e.g., for generic items vs. specific types), but overall it is 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 input schema has 100% parameter description coverage, so the description does not add meaning beyond what the schema already provides. The mention of dry_run in the description aligns with its schema description but doesn't add new information.

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 deletes an item from a Miro board, using a specific verb and resource. Among siblings with many specific delete tools (e.g., delete_app_card, delete_board), this tool is for generic items, distinguishing it effectively.

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 includes a warning about irreversibility and recommends using dry_run, but it does not provide guidance on when to use this tool versus alternatives like miro_bulk_delete or other specific delete tools. Usage context is implied but not explicitly contrasted.

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 goes beyond annotations by revealing cascading effects on children ('Deleting a parent may affect children'), the destructive irreversible nature ('Cannot be undone'), a preview option, and the experimental API version, though it omits authorization or rate limits.

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

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

Description is two sentences and a warning, front-loaded with core action, but could be more compact without losing nuance.

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

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

Output schema exists, so return value explanation is unnecessary. Description covers destructive nature, side effects, and dry_run option adequately for a simple deletion 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?

Input schema has 100% description coverage, so description adds marginal value by reinforcing dry_run usage, but does not provide novel semantics 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?

Description clearly states 'Delete a mindmap node' with a specific verb and resource. It also adds context about parent-child effects, but does not explicitly distinguish from sibling delete tools (e.g., miro_delete_app_card).

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?

Description mentions using dry_run=true to preview, which provides usage guidance, but does not explicitly specify when to use this tool versus alternatives or when not to use 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?

Beyond the destructiveHint annotation, the description discloses that the tag is removed from all items (a key side effect) and emphasizes irreversibility, adding valuable behavioral context not in 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 concise, with three short sentences covering action, warning, and voice-friendly response. Every sentence adds value with no redundancy.

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

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

Given the tool's destructive nature, the description covers essential context: what it does, side effects (removes from items), irreversibility, and a safe usage tip. With an existing output schema, return value details are unnecessary.

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 already provides full descriptions for all three parameters (100% coverage). The description only reiterates the dry_run usage, adding no new semantic value 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 the action (delete a tag from a board) and the scope (removes from all items), distinguishing it from siblings like miro_create_tag, miro_attach_tag, and miro_update_tag.

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 warns that the action cannot be undone and suggests using dry_run=true to preview, giving practical usage guidance. However, it does not explicitly contrast with alternative tag tools or specify when not to use.

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 discloses that the tag remains on the board for reuse, which is a key behavioral trait beyond the minimal annotations (only title). It does not mention permissions or idempotency, but for a simple detach operation, this is sufficient.

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 concise sentences plus a usage line, no redundancy, front-loaded with action and resource.

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 simplicity, full schema coverage, and presence of output schema, the description covers all necessary context: what the tool does, how it differs from sibling (miro_delete_tag), and example commands.

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 100% description coverage, so the parameters are already well-documented. The description adds no additional parameter-level details beyond usage examples.

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

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

The description clearly states the verb 'Remove' and resource 'tag from a sticky note or card'. It distinguishes from deletion by noting the tag stays on the board, and provides example usage phrases.

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 includes a 'USE WHEN' section with concrete examples and explicitly directs to miro_delete_tag for full deletion, providing clear guidance on when to use this tool versus an alternative.

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