EaseWeb

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

Annotations already cover safety (readOnlyHint=false, destructiveHint=false, openWorldHint=false), so the bar is lower. The description adds real behavioral context the annotations cannot: the visibility/audience model — the owner sees the note in the viewer, and thread replies are visible to the owner and the thread starter.

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

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

A single dense sentence that front-loads the action and the three modes. The parenthetical parameter references are compact and earn their place, though the run-on structure is slightly harder to parse than a bulleted mode list would be.

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

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

No output schema, but annotations carry the safety profile and the description covers action, scope, mode selection, and audience. The only real omission is the return value (e.g., the created note's id), which is a minor gap for a 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 the schema already documents all four parameters (baseline 3). The description goes beyond that by tying 'slide_id' to slide-level notes and 'reply_to' to answering an existing thread, clarifying the mutually-influential mode selection that the flat schema does not express.

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 ('Leave a note') and enumerates the three creation modes: slide-level via 'slide_id', presentation-level, and thread reply via 'reply_to'. This is enough for an agent to distinguish it from list_comments, delete_comment, and resolve_comment without opening their schemas.

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

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

Gives clear context for use: 'on any presentation you can see', plus the parameter-selected modes for slide vs. whole-presentation vs. reply. It does not name an alternative tool or state when not to use this one, so it falls short of an explicit routing statement.

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

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

Annotations declare the mutation profile (readOnlyHint=false, destructiveHint=false), so the safety burden is partly lifted. The description still adds value by disclosing the edit-permission requirement and, with no output schema present, stating the return ('the new slide with the ids of its blocks').

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

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

Two tight sentences, front-loaded with the action and followed by placement, optionality, and return value. No filler.

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

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

For a 9-parameter mutation tool with full schema coverage and no output schema, the description covers purpose, permission constraint, and return value, which is what the missing output schema would otherwise need. Only minor gaps (no error/collision behavior for the target position) remain.

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 the schema already documents all nine parameters, including the 1-based position and the block objects format. The description adds marginal framing ('at the end or at position', 'optionally with its blocks') but no meaning beyond the schema, so the baseline 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 names a specific verb and resource ('Add a slide to a presentation') and clarifies scope: placement at the end or at a 1-based position, optionally with blocks. An agent can distinguish it from delete_slide, update_slide, or reorder_slides without opening the schema, though no sibling 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?

Usage is implied ('Add a slide to a presentation you may edit') and the permission prerequisite is hinted at, but there is no explicit when-to-use or when-not-to-use guidance and no alternative sibling is named.

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

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

Annotations declare destructiveHint=false, readOnlyHint=false, and openWorldHint=false, so the mutation/scope profile is already covered. The description adds only the role-override behavior and its default; it says nothing about required permissions, whether a decline is reversible, or whether a prior answer can be changed.

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

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

Two tight sentences with the action front-loaded and no filler. The parenthetical role note is slightly awkwardly placed but earns its space by clarifying the default.

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?

Adequate minimum for a 3-parameter mutation tool with no output schema, but it omits how to obtain request_id, who may answer a request, and the effect of approve=false — all gaps an agent would benefit from knowing.

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 67%; role's enum and request_id are already documented in the schema. The description adds the useful default semantics for role ('what was asked for'), but the required 'approve' boolean carries no description anywhere, leaving its false-means-decline meaning to inference.

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 pair (approve/decline) and a specific resource (access request for one of your presentations), which distinguishes it from siblings like request_access and set_access. However, it doesn't explicitly name those siblings to sharpen the boundary.

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

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

Usage is implied — you call this to answer a pending access request — but there is no explicit when/when-not guidance, nor a pointer to list_access_requests as the source of request_id. An agent must infer the workflow.

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

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

Annotations already declare this is a write operation (readOnlyHint=false), not destructive, and not open-world. The description adds useful behavioral context: the tool can create a presentation with all slides at once, blocks can link to other slides via a 1-based index, and it returns the new presentation with slide and block IDs. It doesn't cover permissions or limits, but with annotations providing the safety profile, this is a solid addition.

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 dense paragraph that front-loads the purpose and then explains the nested format. Every clause carries information, though the structure is slightly hard to parse due to inline object examples.

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 nested slide and block objects, the description explains slide-level keys and block linking but never defines what a block object itself looks like, making complete creation of presentations with content underspecified. It does state the return value (new presentation with IDs), and annotations cover safety, but the nesting gap leaves it only minimally complete.

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

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

Schema description coverage is 75%, so the schema carries most parameter documentation. The description meaningfully augments the 'slides' parameter, which the schema only calls 'Slides with their blocks (optional)', by specifying the expected keys and the inter-block linking syntax. It doesn't explain the 'description' parameter, leaving one gap.

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

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

The description opens with a specific verb+resource: 'Create a new presentation'. It also clarifies scope by saying it can be empty or complete in one call, distinguishing it from incremental tools like add_slide or update_presentation.

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 'empty or complete in one call' gives clear context for when to use this tool: either to create an empty presentation or to create one with all slides in a single request. It doesn't explicitly name alternatives or state when not to use it, so it falls short of a 5.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is known. The description adds genuinely new behavioral context: the cascade that removes replies when the note is a thread starter, and the authorization requirement. It stops short of stating irreversibility or error behavior on unauthorized calls.

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

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

Two sentences, front-loaded with the action and its cascade, followed by the permission rule. No filler and no redundancy.

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

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

For a one-parameter destructive tool with annotations covering the safety profile, the description supplies the two facts that matter most: what else disappears (thread replies) and who may invoke it. Missing only edge cases such as failures on unauthorized callers or missing IDs.

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 the single required parameter, so the schema already carries the semantics. The description adds nothing about the id beyond repeating the note/comment mapping, making the baseline 3 correct.

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 (Delete) and resource (a note), and adds scope detail: replies are removed when the note starts a thread. The resource domain is clearly distinct from the other delete siblings (delete_slide, delete_presentation) without needing to name them.

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

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

The description gives a permission precondition ('Its author or the owner of the presentation may do it'), which tells the agent when the call is allowed. However, it never contrasts deletion with the sibling resolve_comment, leaving the agent to infer which one to use for closing out a discussion.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, lowering the bar. The description adds real context beyond them by stating the presentation 'disappears from the site and from the list of presentations', clarifying the user-visible effect of the destructive action. It stops short of stating irreversibility or restore options.

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 parenthetical carries only relevant effect information. Nothing needs to be trimmed.

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-parameter destructive tool with full schema coverage and annotations covering the safety profile, this is nearly complete. Only the absence of irreversibility/ownership requirements keeps it from being fully self-contained.

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

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

Schema description coverage is 100% and the single 'slug' parameter is fully documented in the schema, including its address form. The description adds no parameter-level detail, so the baseline 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?

States a specific verb ('Delete') and resource ('one of your presentations') and the parenthetical clarifies the effect. It is clearly distinguishable from the numerous sibling delete_* tools because it names the resource (presentation vs comment vs slide).

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

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

Usage is implied by the obvious delete semantics, but there is no explicit when-to-use/when-not guidance, no mention of required ownership or permissions, and no reference to alternatives or prerequisites. The 'your' qualifier hints at ownership scope but is not explained.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows this mutates and destroys. The description adds real value beyond that by disclosing the side effect that inbound links become dangling, but says nothing about irreversibility, required permissions, or whether the deletion can be undone.

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

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

Two short sentences, front-loaded with the action and immediately followed by the consequence. No filler and nothing redundant with the title or schema.

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

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

For a destructive, non-open-world tool with full schema coverage and no output schema, the definition is adequate: annotations cover the safety profile and the description covers the link side effect. It is still thin on recoverability and permission requirements, which matter for an irreversible-seeming delete.

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 two fully documented parameters (slug address format, slide_id stability vs. position), so the schema carries the semantic load. The description adds nothing about parameters, which is the expected baseline here.

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 a slide of your presentation'), which cleanly separates it from the sibling delete_presentation and delete_comment by resource noun. It does not explicitly name or rule out any alternative, so it stops short of a 5.

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

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

No when-to-use, when-not-to-use, or prerequisite guidance is given, and no alternative tool is named (e.g. reorder_slides or restore_version for recovering content). The second sentence describes a consequence, not a usage condition.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds real operational behavior beyond that: partial-prop updates, the 'inside' rectangle scoping rule, silent skipping of props a block type lacks, default top vs at_bottom placement, and the return value. It stops short of mentioning permissions, error handling, or reversibility given 'delete' is offered under destructiveHint=false.

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

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

Front-loaded with the core operation, then organized as three labeled modes, so all content earns its place. It is dense and quote-heavy to the point of being slightly hard to scan (the stray line-break quote before 'add' hurts readability), keeping it short of a 5.

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 multi-mode mutation tool with no output schema, the description covers add/update/delete, the scoping nuances, and even states the return value ('the slide with the ids of its blocks'). Only the failure/auth paths (invalid block ids, permission requirements) are unaddressed, a minor gap for a well-annotated 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, but the description meaningfully elaborates the parameter shapes beyond the terse schema text: the three update forms (id, ids[], inside), the semantics of 'inside' matching a card's background block and everything inside its rectangle, and the default behavior of at_bottom. That is genuine added meaning rather than restatement.

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 (change blocks) plus scope ('leave the others alone, in one step') and enumerates the three supported modes: add, update, delete. This cleanly separates it from siblings like update_slide (slide-level) and add_slide, letting an agent select it without opening the schema.

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

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

Usage is only implied through the mode semantics: you learn that 'update' touches only given props and 'inside' scopes to a card's rectangle. There is no explicit 'use this instead of update_slide/delete_slide' routing or statement of when block-level editing is inappropriate, so alternatives remain unaddressed.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safe-read profile is covered. The description adds useful content context by naming the returned fields (level, roles, pending requests), though it says nothing about permissions needed, pagination, or result shape.

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

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

A single sentence with no wasted words, leading with the resource being described. It is a noun-phrase fragment rather than a verb-led statement, which slightly weakens the front-loading of intent but keeps it tight.

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

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

With no output schema, the description carries the burden of explaining what comes back, and it does enumerate the returned fields (level, roles, pending requests). Combined with annotations that fully cover the safety profile, this is adequate for a single-parameter read tool, though the overlap with sibling tools remains unaddressed.

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

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

Schema description coverage is 100% for the single slug parameter, and the schema already explains the slug format (/movie/<slug>/). The description adds no syntax or usage detail beyond the schema, so the baseline 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 specifies the resource (access settings of a presentation) and enumerates exactly what is returned: level values, who has access and their role, and pending requests. It is not a bare tautology, but it omits an explicit verb and never distinguishes itself from overlapping siblings such as list_access_requests or get_presentation.

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

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

There is no when-to-use guidance and no alternatives are named. An agent is left to infer from the name that this is a read of access configuration rather than, say, set_access or list_access_requests, whose scopes partially overlap with the 'pending requests' content mentioned here.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false, so the agent knows this is a safe local read. The description adds useful scope (what the reference contains), but says nothing about the return format, size, or whether the reference is static/authoritative, so it adds only partial value beyond the annotations.

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

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

A single front-loaded sentence that leads with the purpose ('complete reference of what a slide can contain') then enumerates the covered areas. The list is dense but every item earns its place; only slight run-on density keeps it from a 5.

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

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

With no output schema, the description does describe the content of the return, but it omits the return shape/format and any usage framing, which an agent needs to consume a reference document correctly. Adequate but with clear gaps.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; per the rubric this is the baseline 4. The description correctly implies a parameterless reference lookup.

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 resource delivered: a complete reference of slide block types, props, defaults, allowed values, ranges, colours, link kinds, fonts, shapes and themes. It is specific about content and implicitly distinguishable from the mutation/CRUD siblings, but it uses no verb and does not name a sibling to contrast against.

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

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

There is no when-to-use guidance at all. The obvious condition an agent needs — call this before edit_blocks/add_slide to learn valid block props and enumerated values — is never stated, nor is any when-not or 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 already declare readOnlyHint, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavioral context beyond that: the presence of a 'can_edit' permission flag and the fact that link fields carry both 'slide' and 'slide_number', which tells the agent how to interpret the payload.

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 with the return-content summary front-loaded and no filler. The parenthetical asides ('ids and complete props', '"can_edit" says whether you may') are slightly dense but each carries information.

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

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

No output schema exists, so the description must describe the return shape, and it does so reasonably: slides, blocks, ids, props, playback order, slide/slide_number links, and can_edit. It omits any note on size or pagination for large presentations, which is the main remaining 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 a single 'slug' parameter that the schema fully documents as the presentation's address. The description adds no syntax or format detail beyond the schema, so the baseline of 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 resource and its scope: a presentation with every slide and block in playback order, with ids and complete props. However, it never explicitly differentiates itself from the sibling read_presentation, nor does it name a retrieval verb, so sibling disambiguation is left implicit.

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 line 'Use the ids to edit slides and blocks' implies this is a fetch-for-editing tool, which is useful context. But it offers no explicit when-to-use vs read_presentation or get_slide, and no exclusions, so usage 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile needs no restating. The description adds useful context beyond the annotations: with no output schema, specifying that the result contains all blocks with their ids and complete props tells the agent what it will receive.

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 payload description ('ids and complete props') is the most important detail and arrives immediately. Slightly terse, but every clause earns its place.

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

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

With no output schema and full schema coverage on inputs, the description responsibly covers the return shape (blocks, ids, props). It omits access-failure behavior and any mention of how this pairs with edit_blocks or update_slide, which keeps it short of fully complete.

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

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

Schema description coverage is 100% and both parameters (slug, slide_id) are well documented, including the stability caveat on slide_id. The description adds only the loose 'presentation you can see' phrasing, so the baseline 3 applies since the schema carries the semantics.

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

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

States a specific verb and resource: fetch one slide of a presentation, including all of its blocks with ids and complete props. This is clear, but it does not explicitly differentiate itself from siblings like get_presentation, read_presentation, or get_version, which an agent would need to disambiguate.

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

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

There is no explicit when-to-use guidance or named alternative. The phrase 'a presentation you can see' weakly implies an access/visibility precondition, but no condition for choosing this tool over get_presentation or read_presentation 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful behavioral context about the shape of the returned content (markdown vs. full JSON) and that markdown is the default, but says nothing about error behavior for a nonexistent slug/version.

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

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

One compact sentence organized around the format options, with no filler. It is efficient, though the format detail is front-loaded ahead of a plain statement of what the tool fundamentally does.

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

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

With no output schema, the description does the work of explaining the return shape (markdown slides/texts vs. complete JSON content), which is the key thing an agent needs. It omits error/empty-version behavior, a minor gap for a read-only lookup 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 67% — slug and number are documented in the schema, but the format enum carries no schema description. The description fills exactly that gap, explaining both enum values and marking markdown as the default, which is genuine added meaning beyond the structured fields.

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

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

The description states what the tool returns — the content of a presentation at a specific version — with a concrete verb-like framing ('What a presentation looked like in a version'). It is clearly distinct from write siblings, but it never names or contrasts with near-neighbors like get_presentation, read_presentation, get_slide, or list_history, leaving the agent to infer the boundary.

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

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

There is no when-to-use guidance, no mention of the alternative tools that also read presentation content, and no note on prerequisites such as the version needing to exist. The agent must guess whether this or read_presentation/get_presentation is the right call.

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

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

Annotations already declare it as a safe, read-only, closed-world operation, so the safety profile is covered. The description adds the meaningful behavioral nuance that incoming defaults to pending-only and include_decided expands to all. It does not cover ordering, pagination, or return shape, but the pending-vs-all distinction is genuine added 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?

It is short and front-loads the default value, which is good. However, it is written as two quoted enum fragments rather than a coherent sentence, and the tool's actual function is never stated plainly, which slightly undermines structure.

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

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

For a simple two-optional-parameter read tool with annotations covering safety and no output schema, the description gives enough to call it. But it omits usage routing relative to siblings and any sense of the listed items' fields, leaving it minimally viable rather than complete.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It does this well for both parameters: direction's two enum values are defined, and include_decided's effect is explained (include decided requests). This meaningfully compensates for the undocumented 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 explains the semantics of the two direction values, which clarifies what the tool lists. However, it never states the core action in a standalone verb+resource form (e.g. 'List access requests'); the purpose is only inferable from the enum explanations and the title. It's adequate but not self-contained.

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

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

It describes what each direction value means but gives no explicit when-to-use guidance or alternatives. Siblings like get_access, set_access, and answer_access_request exist, yet none are referenced to help route the agent. Only implicit context is provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. Beyond that, the description adds genuinely non-obvious behavior: results are filtered by viewer role (owner sees every note, others only their own threads), which materially affects interpretation of results and cannot be derived from the schema.

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

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

Three short sentences, no filler, with the result shape and visibility rule stated before the filtering caveat. The opening noun phrase is slightly terse but effective and appropriately front-loaded.

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

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

With no output schema, the description covers the important agent-facing concerns: what is returned (threads with replies), who sees what, and the default open-only filter. Ordering, pagination and thread field details are unstated, but nothing blocks a correct call.

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

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

Schema coverage is 67%, and the one undocumented parameter is exactly the one the description explains: include_resolved governs whether resolved threads appear. slug and slide_id are already well documented in the schema, so the description usefully compensates for the gap rather than merely restating.

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 identifies the resource precisely (notes/comments on a presentation, structured as threads with replies) and the title supplies the read verb. It is distinguishable from the mutation siblings add_comment, delete_comment and resolve_comment, though it never states the list verb 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?

It gives a concrete usage rule for include_resolved: omitting it returns only open threads. It also clarifies the permission-scoped result set (owner vs. everyone else), which tells the agent what to expect for a given caller. It does not name alternative tools such as resolve_comment for acting on the threads it returns.

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

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

Annotations already declare readOnlyHint and destructiveHint=false, so safety is covered. The description adds genuinely useful behavior beyond that: newest-first ordering, the fields returned, and the non-obvious coalescing rule ('changes of one author in a row within 10 minutes are one version'). It stops short of noting pagination or a default limit, which the schema partially covers.

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, each earning its place: the first front-loads the resource, ordering, and return fields; the second supplies the aggregation rule. No filler.

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

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

With no output schema, the description correctly takes on the burden of describing the return shape (number, author, timestamp, diff) and the version-grouping rule. It omits pagination/limit interaction and permission behavior, both minor gaps for a read-only list tool whose parameters are documented.

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% (both slug and limit are documented in the schema), so the baseline is 3. The description adds no extra semantics about how slug or limit behave, leaving the schema to do all the work.

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 identifies the resource (versions/history of a presentation) and describes what each entry contains, so an agent knows this is a chronological change-log reader. However, it never explicitly contrasts itself with neighbors like get_version or restore_version, so sibling differentiation is left to inference.

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

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

There is no when-to-use or when-not guidance. The phrase 'you can see' hints at access-based filtering but does not tell the agent when to reach for this tool instead of get_version, nor does it name any 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 already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description contributes useful access semantics beyond that, notably that 'open' presentations are readable and editable by any signed-in person or agent, but it omits return-count, pagination, and ordering behavior.

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

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

The scope definitions are front-loaded and each sentence carries information an agent needs to pick a scope and understand the result. There is little filler, and the returned-field list is compact.

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

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

With no output schema, the description valuably enumerates returned fields and explains access semantics, so an agent has enough to call the tool correctly. Minor gaps remain around pagination, result ordering, and total counts, but nothing critical 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 description carries the full burden — and it does define all three enum values plus the default ('mine'). This meaningfully compensates for the undocumented schema, though it does not clarify behavior for an omitted/unknown value beyond the stated default.

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/title give a clean verb+resource, and the description adds a concrete return-shape ('Each has slug, id, title, description, theme, access level...'), which implies a listing of presentation summaries. It is clear but does not explicitly state 'returns a list' or distinguish itself from siblings like get_presentation or read_presentation.

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 carefully explains each scope value ('mine' default, 'shared' = other people's accessible to you, 'open' = anyone's readable/editable), which is real usage guidance at the parameter level. However, it gives no guidance on when to call this tool versus get_presentation/read_presentation or any other sibling, so tool-level selection is left 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?

Annotations only declare readOnlyHint/destructiveHint, so the description carries the real burden — and it does, disclosing what the read returns (texts in reading order, picture descriptions, code, link destinations) and how cards are grouped as one entry with block ids. It stops short of stating limits such as pagination or handling of very large decks.

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

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

Purpose and access scope are front-loaded and the sentences are dense with useful detail. The parenthetical on visibility and the mid-paragraph card definition slightly interrupt the flow, but nothing is pure filler.

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

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

With no output schema, the description must describe return shape, and it does so concretely (per-slide content, reading order, images, code, link targets, card grouping, two output formats). Missing only operational details such as size limits or pagination.

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 50%: slug is documented in the schema, but format is only an enum. The description compensates by explaining format semantics ('markdown' default is compact; 'json' is structured) and clarifying the card structure that the json form yields.

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 ('read any presentation') scoped by access visibility, and it explains the rendering model ('the way a person sees it: slide by slide'). It does not explicitly distinguish itself from siblings like get_presentation or get_slide, so an agent must infer that this returns a human-rendered view rather than raw data.

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

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

The visibility constraint ('not private, or shared with you') implies when the tool is callable, but there is no explicit when-to-use guidance versus get_presentation, get_slide, or get_format, and no mention of prerequisites like needing a slug from list_presentations.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds one genuinely useful behavioral trait: 'order' must list ALL slide ids, signalling a full-replacement rather than incremental reorder. It does not say what happens if a slide is omitted, duplicated, or unknown, which limits it to a 3.

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

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

A single front-loaded sentence that states the operation before the constraint. It is efficient, though the nested quoting around "order" is slightly awkward and the sentence conflates operation and parameter constraint.

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 only two required primitive parameters, full schema coverage, and annotations covering the safety profile, the description is adequate for correct invocation. It stops short of covering failure behavior for invalid or incomplete id lists, which is the main remaining gap for a full-replacement mutation.

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 both parameters are already documented in the schema; the baseline is 3. The description reinforces the 'every slide id, once' constraint for 'order', but adds no syntax, format, or validation detail beyond what the schema states.

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

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

The description names a specific verb+resource combination ('Set the playback order' of slides) that is clearly distinct from siblings like update_slide or add_slide. It does not explicitly name an alternative, but the operation it performs is unambiguous. A 4 rather than a 5 because it relies on the tool name for the 'slides of a presentation' framing.

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

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

Usage is implied by the description ('set the playback order'), and the reader can infer it should be used when the slide sequence must change. However, there is no explicit when-to-use statement and no contrast with siblings such as update_slide, which is the obvious confusion point. Implied-only guidance caps this at 3.

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 only cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=false). The description adds real behavioral context: the request is reviewed asynchronously by the author on the site, approval binds access to the account and all its agents, and repeating the call updates rather than duplicates the pending request. The only gap is how the caller learns the outcome (presumably get_access), which is left implicit.

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

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

Three sentences, front-loaded with the action and role meanings, then the approval workflow, then the re-ask rule. Each sentence carries information; only the opening phrase mildly duplicates the title 'Ask for access'.

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

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

For a 3-parameter, no-output-schema tool, the description covers purpose, role semantics, the human-approval lifecycle, and idempotent re-asking. It leaves one loose end: no indication of how or when the caller discovers the approve/decline result.

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 role, slug, and message are already documented, including the enum values. The description restates role semantics with a useful contextual twist ('view' for a private one, 'edit' for one that is not open) but adds no syntax, format, or constraint information beyond the schema, so the baseline 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?

States a specific verb and resource ('Ask the author of a presentation for access') and immediately scopes it with the two role modes. It is clearly distinguishable from siblings like get_access, set_access, list_access_requests, and answer_access_request, which are different actors' sides of the same workflow.

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 concrete triggering conditions: use 'view' to read a private presentation, 'edit' to change one that is not open. It also clarifies the re-ask behavior. It does not, however, name the alternatives (e.g., get_access to check status, set_access to grant, answer_access_request for the author side), so the agent must infer routing from sibling names.

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

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

Annotations only declare the mutation/safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=false); the description adds genuinely new context by disclosing the authorization requirement (owner or thread starter) and the reversible toggle behavior. It doesn't mention error behavior on already-resolved threads or idempotency.

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

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

Two tight sentences with the primary action front-loaded and the permission rule appended as a constraint. Nothing is redundant, though the mid-sentence parenthetical for the toggle adds slight cognitive load.

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 two-parameter mutation with no output schema, the definition covers the action, the reversible flag, and the authorization gate, which is most of what an agent needs. Remaining gaps (idempotency, error on already-resolved, confirmation of return value) are minor.

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 baseline is 3, but the description goes beyond the schema's bare 'Default true' by explaining that resolved:false reopens the thread — meaning the agent learns the semantic effect of the parameter, not just its type. comment_id gets no elaboration, but its schema description is adequate.

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

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

Names a specific verb+resource ('Mark a thread as done') and clarifies the inverse operation (reopening with resolved:false), which is enough to separate it from siblings like delete_comment or add_comment. It does not explicitly contrast itself with any sibling by name, so it falls short of the top band.

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 conveys when the action applies (thread completion, with an undo path) and states the precondition that only the presentation owner or thread starter may perform it. It gives no explicit guidance on when to choose resolve_comment over alternatives such as delete_comment, leaving usage 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?

Annotations declare readOnlyHint=false, destructiveHint=false, so the write-but-safe profile is set; the description goes further by explaining that the restore itself becomes a new version and is therefore undoable. That reversibility detail is genuine added value beyond the annotations.

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

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

Two tight sentences with no waste; the effect of the operation is front-loaded and the undo caveat follows immediately.

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

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

With no output schema and a simple two-param signature, the description covers what changes and the reversibility semantics well. It could say more about the edit-permission requirement it only hints at, but nothing essential 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 100% with only two params (slug, number), so the schema already fully documents inputs. The description adds nothing about parameter format or constraints, making the baseline 3 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?

States a specific verb+resource: restoring a presentation to a prior version, and enumerates what is affected (slides, blocks, order, title). It does not explicitly distinguish itself from siblings like get_version or list_history, so it stops short of a 5.

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

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

Usage is implied — the phrase 'a presentation you may edit' signals a permission precondition — but there is no explicit when-to-use, when-not-to-use, or named alternative such as get_version for previewing before restoring.

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 only readOnlyHint=false and destructiveHint=false from annotations, the description adds real context: what 'open' grants (everyone reads/edits, full history), what 'public' and 'private' grant, and that 'revoke' removes usernames' access. It stops short of stating authorization requirements (e.g., must the caller own the presentation) or whether changes are 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 dense sentence with zero filler, front-loaded on the resource being modified. The quoting-and-dash formatting for parameters is slightly awkward to parse but nothing is wasted.

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

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

A write tool with no output schema and partial annotations; the description covers what the mutation does and all enum/vocabulary semantics, which is what an agent needs. It omits permission preconditions and any note on partial success when combining level and revoke.

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 only 33% (slug only), so the description carries the burden for the other two params — and it does: it fully spells out the three 'level' enum values and defines 'revoke' as usernames losing access. It does not clarify whether level and revoke can be applied together, leaving a minor gap.

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

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

States a specific verb+resource (change the access of a presentation) and then defines exactly what the operation covers. The open/public/private semantics make the scope unambiguous, so an agent can immediately distinguish it from read-side siblings like get_access or request_access.

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

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

The description explains what each level means, which implicitly guides value selection, but it never states when to call this tool versus alternatives such as get_access, request_access, or answer_access_request, nor any prerequisites. Usage is left to inference.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds real behavioral context beyond that: theme changes are forward-only (new slides/blocks get the defaults, existing slides keep their colours) and the slug/address is invariant. It omits any note on permissions required or partial-update behaviour for omitted fields.

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

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

Three short sentences, front-loaded with the action and scope, followed by the two non-obvious constraints. Every sentence carries information an agent could not get from the schema or annotations.

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

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

For a 4-parameter mutation with no output schema and thin schema descriptions, the definition covers the two genuinely surprising behaviours (theme defaults, immutable slug). Missing only permission requirements and whether unspecified fields are preserved, which are minor for this tool.

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

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

Schema description coverage is only 25% (just slug), so the description must compensate, and it does so meaningfully: it explains that theme sets defaults for future content only, and that slug is a stable address that will not change. Title/description are self-evident and the enum values are already 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?

States a concrete verb plus resource and enumerates the mutable fields (title, description, theme), scoped explicitly to a presentation rather than a slide, which separates it from update_slide. It stops short of naming the sibling alternative outright, but the resource scope makes the distinction 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?

Usage is only implied: 'a presentation you may edit' hints at an edit-permission prerequisite, but there is no explicit when-to-use vs. when-to-use-something-else guidance, and no statement of what to do for slide-level changes instead.

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 cover the safety profile (readOnlyHint=false, openWorldHint=false, destructiveHint=false), so the bar is lower, and the description still delivers real added value by spelling out the replace semantics: blocks with an id are kept and merged, id-less blocks are added, blocks absent from the list are deleted. That merge rule is the single most important behavioral fact for this tool and it is stated explicitly. The residual gap is that the stated block deletion sits in tension with destructiveHint=false, and nothing is said about failure behavior for unknown slide_ids.

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

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

A single dense sentence, but it is front-loaded with the verb and scope and the parenthetical on objects carries the highest-value information rather than filler. Slightly heavy nesting hurts scannability, yet no sentence is expendable.

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 nine-parameter mutation tool with no output schema, the description establishes that unspecified fields are left alone while objects is a full replacement, which is the completeness-critical fact. Missing only edge-case behavior (invalid ids, validation failures, whether the returned representation is the updated slide), and annotations already carry the safety profile.

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

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

Schema description coverage is 100% and all nine parameters carry detailed descriptions (width bounds, fit enum, name length, null-removes-picture, id-vs-number stability), so the schema does the heavy lifting and the baseline is 3. The description does add the objects merge contract on top of the schema's structural description, which is meaningful, but only for one of nine parameters.

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

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

Specific verb plus resource plus an enumerated scope (name, size, background colour/picture, complete block list), so the agent knows exactly what is mutable. It is clearly narrower than update_presentation and distinct from add_slide/delete_slide. It does not, however, distinguish itself from the sibling edit_blocks, which plausibly competes for the same block-editing job.

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

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

Usage is only implied through the conditional 'when "objects" is given', which signals that omitting objects performs a metadata-only update. There is no explicit when-to-use statement, no exclusions, and no pointer to edit_blocks as the alternative for block-only edits, despite that tool existing in the sibling set.

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 only declare it is a non-read-only, non-destructive, closed-world write. The description adds genuine behavioral detail the annotations cannot: accepted formats, a 25 MB ceiling, base64 encoding requirement, and automatic downscaling to 2560 px — a transformation the caller would otherwise not anticipate. It stops short of permissions or idempotency info.

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

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

Two sentences, front-loaded with the core action and benefit, then the constraints and the scaling caveat. Every clause carries information; nothing is padding.

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

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

With no output schema, the description usefully states what the caller receives (the src). For a single-parameter upload tool with rich annotations, this is nearly complete; only auth/precondition context is absent, which is minor here.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real constraints on data_base64 beyond the schema field text: the accepted formats and the 25 MB upper bound. These are payload semantics an agent needs, not a restatement of 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?

States a specific verb+resource ('Store a picture') and its outcome ('get its src'), plus the concrete downstream use cases (image block or slide background). An agent can distinguish this from siblings like add_slide or edit_blocks without opening any schema.

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

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

It implies when the tool is useful by naming the consumer of the returned src (image block, slide background), but it never states when to prefer this over alternatives or any preconditions like needing prior access to a presentation. Usage is inferred rather than instructed.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuine value beyond that by enumerating the returned payload (user name, key name, access level, and the 'read'/'write' vocabulary), which is significant given there is no output schema.

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

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

A single compact sentence that front-loads the subject ('who the API key belongs to') and then the permission detail. No filler, no restatement of the name or title.

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 zero-argument, read-only introspection tool with no output schema is largely self-contained, and the description covers the meaningful return fields. It stops short of mentioning failure behavior for an invalid or revoked key, which is the only notable omission.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to clarify beyond the schema, and it does not attempt to invent 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?

States a specific, unambiguous purpose: returns which user the API key belongs to and the key's access level. No sibling tool does anything similar, so an agent can select it without ambiguity.

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

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

Usage is implied by the name and description (check credentials/permissions before acting), but the description never states when to call it, nor any prerequisite or timing guidance. With no competing alternative among siblings, the lack of explicit routing guidance is a moderate rather than severe gap.

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