Whiteboard Animation

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

Annotations already establish that this is a non-destructive mutation, so the description adds valuable context beyond them: credit consumption, asynchronous completion, immediate return of drawing_id, and a multi-minute runtime. It does not cover permissions, failure modes, or cancellation behavior, but the core behavioral traits are disclosed.

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

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

Three tightly written sentences: purpose first, cost second, asynchronous follow-up third. Every sentence adds distinct information and there is 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 tool with six parameters, a nested settings object, and zero schema descriptions, the description is not complete enough. It explains the return and follow-up flow but leaves all input parameters undocumented, which is a major gap for correct invocation.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, yet it explains none of the six parameters. It vaguely gestures at credits and quote but does not clarify image, title, settings, upload_id, max_credits, or quote_version, and the nested settings object is entirely unaddressed.

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: "Draw a picture as a whiteboard animation." This is clearly distinct from get_drawing and list_drawings, though it does not differentiate from creation-adjacent siblings like create_upload or render_link.

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

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

Gives clear usage context: it spends credits and points to quote, and it explains the follow-up step with get_drawing after the immediate drawing_id response. It does not state when not to use it or compare it with other creation tools, but the lifecycle guidance is strong.

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 annotations already declare this is a non-read-only, non-destructive, closed-world operation. The description adds useful behavior beyond that: it returns an upload_url plus headers for PUTting bytes, and the workflow continues via create_drawing. It does not cover URL expiry, auth, or error 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?

Three compact sentences, front-loaded with the main action and followed by the required next step and the key exception. There is no wasted text.

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

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

For this workflow tool, the description explains the response shape and next call, and the schema already carries limits and enum constraints. It is missing only secondary operational details such as URL expiry, authorization expectations, and failure modes.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain file_name, content_type, or size. It only implies image upload generally; schema constraints such as the 10 MB maximum and allowed image types are left entirely to 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 states a specific verb and resource: 'Start uploading a picture.' It also distinguishes this tool from create_drawing by describing the two-step upload flow and the upload_id handoff.

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

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

It explicitly says to call create_drawing afterward with the upload_id and that this tool is 'Not needed when the host attaches the picture to create_drawing itself.' That gives both when-to-use and when-not-to-use 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 declare this is a safe read-only, non-destructive, closed-world operation. The description adds useful behavioral context by noting that export options are available 'once done,' which signals a state-dependent return and connects it to render_link.

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 efficient sentence that front-loads the lookup-by-id purpose and then lists the returned information. Every clause contributes useful context without repetition.

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

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

With no output schema, the description appropriately summarizes the key returned fields and the conditional export options. It does not cover error behavior such as what happens if the id is invalid or the drawing is missing, but it is otherwise sufficient for a simple read-only getter.

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

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

There is one parameter with 0% schema description coverage. The description says 'by id,' which confirms drawing_id identifies the target drawing, but it does not explain the expected id format or where to obtain it.

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 a retrieval operation for a single drawing by id and enumerates what it returns: status, progress, preview page, and export options. It distinguishes itself from list_drawings by specifying lookup by id, though it does not explicitly contrast with siblings like status or wait_drawing.

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: use this when you have a drawing_id and need that drawing's current state and details. However, there is no explicit guidance on when to use this versus list_drawings, status, or wait_drawing.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false with a closed-world scope, so the safety profile is covered. The description usefully adds the 'newest first' sort order, but says nothing about the default page size, whether results are capped or truncated, or what happens when no limit is given.

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

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

A single front-loaded sentence with no filler, and the ordering constraint sits right where the agent needs it. It is arguably under-specified rather than over-long, but nothing in it is wasteful.

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 read-only list tool with one optional parameter and no output schema, the description covers the essentials of what is returned. It stops short of stating default page size, truncation behavior, or the shape of returned items, which matters given the 50-item maximum.

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

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

Schema description coverage is 0% and the single parameter 'limit' has only min/max bounds and no description. The description never mentions 'limit' at all, so it fails to compensate for the coverage gap — an agent cannot tell whether limit means items per page, total items, or how it interacts with the 'newest first' ordering.

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

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

The description names the resource (drawings in the library) and adds the ordering contract (newest first), which is enough to distinguish it from get_drawing (single item) and create_drawing (write). The verb 'list' is only implied via title/name rather than stated, but the intent 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?

There is no statement of when to use this versus siblings such as get_drawing or status, and no mention of pagination behavior or how to continue past the 50-item cap. The agent is left to infer that this is the browse-all entry point.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile needs no restating. The description adds real value by disclosing return semantics (credit cost + a version token consumed by a later create call), but says nothing about quote validity windows or whether repeated calls can change the quoted price.

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, front-loaded with the economic answer (what it costs) before the second return value. Nothing is padded and nothing needs trimming.

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 fully define the return value, and it only names two fields without format, currency-of-account detail, or whether other fields appear in the response. For a zero-parameter pricing tool that an agent must chain into create_drawing, that leaves a meaningful gap around quote staleness and reuse.

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

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

There are zero input parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; no parameter-level guidance is needed 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?

The description states concretely what the call produces: the credit cost of one picture and the quote_version token. It implicitly hooks into create_drawing by saying the version is 'to pass when creating it', which distinguishes it from the actual creation sibling, though it never names that sibling outright.

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 quote_version to pass when creating it' implies the intended sequence (quote first, then create), but the description never says this is a prerequisite, whether quotes expire, or what to do if you skip it. Usage is inferable rather than stated.

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

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

The description adds meaningful behavior beyond annotations: a 20-drawing limit, sequential browser rendering, download behavior, and handling of still-in-progress drawings. Annotations already cover the read-only/open-world/destructive profile, so missing auth or rate-limit details are less critical.

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

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

The description is front-loaded, uses three tight sentences, and every sentence adds useful information: output, browser behavior, and follow-up action. No redundant or filler 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 no output schema and a single top-level parameter containing rich nested options, the description explains the returned link, the rendering workflow, the batch limit, and the wait step. It leaves parameter details to get_drawing export_options, which is a reasonable but not fully self-contained choice.

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 more weight. It correctly explains that each drawing has its own choices and points to get_drawing export_options, but it only names a few of the many nested options and does not explain drawing_id, skip, trace, timing, hand_size, hand_tilt, or hand_direction.

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

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

The description states a specific output and action: 'One link that renders up to 20 of your drawings as files.' It is clear what the tool produces, though it does not explicitly contrast itself with other rendering or waiting tools beyond naming get_drawing and wait_render.

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

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

It gives clear operational context: open the link in a browser, files save to downloads, and follow it with wait_render. It does not state when not to use this tool or name an alternative rendering path, but the intended workflow is clear.

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

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

The annotations already declare this as a safe, read-only, closed-world operation. The description adds useful behavioral context by specifying that it reports on the signed-in workspace and includes queue state and capacity, with no contradiction of 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 extremely concise and front-loads the key directive 'Call first.' The remaining sentence efficiently lists the status fields returned.

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 zero-parameter, read-only status tool with annotations covering safety, the description provides enough detail about what status information is returned. No output schema is present, but the description adequately names the returned fields.

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

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

The tool has no parameters, so the baseline is 4. There is no parameter information needed or missing.

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 as the signed-in workspace and enumerates what it reports: plan, credits left, drawing queue state, and queue capacity. It distinguishes itself from sibling tools, which are drawing-specific operations, though it does not use an explicit retrieval verb.

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 strong usage cue with 'Call first,' establishing that this should be invoked before other tools. It does not describe when not to use it or name alternatives, but the initial-call context is clear.

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

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

Annotations already cover readOnly/non-destructive, and the description adds real behavioral context: it is a blocking wait, it returns when status/progress moves on or after about 50 seconds, and the return shape matches get_drawing. It does not cover error/timeout return specifics, but the added context is substantive.

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 a single sentence with dense, largely necessary information. The 'For the drawing card:' preamble is a slightly awkward framing and the phrasing is convoluted, reducing front-loaded clarity.

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 wait/long-poll tool with annotations present and no output schema, the description covers the trigger condition, timeout, and that it returns a get_drawing result. Remaining gaps (format of status/progress, timeout return behavior) are modest given the structured fields already 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 0%, so the description must compensate. It gives conceptual meaning to status and progress as the last-observed values used to detect change, but drawing_id's role is only implied and the accepted formats of status/progress are not specified, leaving the parameter contract thin.

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 conveys that the tool blocks until the drawing's status or progress changes, or ~50 seconds elapse, essentially returning a get_drawing result. However, the phrasing 'answers get_drawing' and 'For the drawing card' is indirect and requires parsing; it doesn't cleanly state verb+resource up front.

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 'For the drawing card' framing and 'status and progress the card last showed' imply a polling/sync use case, so usage is inferable. But there is no explicit when/when-not guidance versus get_drawing or the sibling wait_render, leaving the agent to infer that it should use this only in card-rendering flows.

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 a safe read (readOnly, non-destructive, closed-world). The description adds context annotations don't cover: it returns as soon as any state changes or after roughly 50 seconds, and it lists the state vocabulary (pending, rendering, saved, failed) plus what is returned once saved. That is real behavioral 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 sentences, with the return content and the poll timeout front-loaded and no filler. Minor awkwardness ('A render link's files:' fragment) but 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 no output schema, the description usefully covers the return shape (states, file name, size when saved) and the polling behavior. However, it omits render_id semantics and any failure/error or retry guidance, so an agent is not fully equipped for edge cases.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the semantics of the states parameter well ('pass back the states of the last answer'), but render_id is never described beyond the implicit link to a render link, leaving half the parameters undocumented.

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

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

It clearly describes the resource (a render link's files and their per-drawing states) and the long-poll return behavior, so an agent knows what the call yields. It doesn't explicitly frame the verb as 'wait/poll' nor differentiate itself from the sibling wait_drawing, leaving the name to carry that distinction.

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?

'Pass back the states of the last answer' implies an iterative poll loop, which is useful usage guidance. But it never says when to choose this over status, wait_drawing, or render_link, and no exclusions or prerequisites are given.

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