Allscreenshots

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

Annotations already declare this as a non-read-only, non-idempotent, non-destructive mutation. The description adds useful scope by stating that pending child jobs are also cancelled, but it does not explain permissions, reversibility, or repeated-call behavior.

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

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

The description is a single front-loaded sentence with no filler or repetition. Every clause contributes to the action and scope.

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 low-complexity one-parameter mutation with annotations and no output schema, the description covers the main effect and cascade. It still omits id semantics and outcome details that would help an agent invoke it confidently.

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

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

Schema description coverage is 0%, and the only parameter, id, is not explained in the description. The description does not state that id identifies the bulk capture or clarify its format beyond the schema pattern.

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

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

The description uses a specific verb, "Cancel," and a specific resource, "bulk capture," and adds that pending child jobs are affected. This distinguishes it from cancel_screenshot by resource, though it does not explicitly contrast sibling alternatives.

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

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

The description gives no when-to-use condition, prerequisites, or comparison to cancel_screenshot. An agent must infer the appropriate use case from the name and single sentence.

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 that this is not read-only, not idempotent, not open-world, and not destructive. The description adds useful state context by specifying that it cancels a *pending asynchronous* screenshot, but it does not explain cancellation semantics, failure behavior, or whether the operation can be retried.

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

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

The description is a single front-loaded sentence with no filler. For a simple cancellation tool, the statement is appropriately sized and wastes no words.

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

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

The tool is simple and annotations cover its safety profile, so the description does not need extensive context. Still, it omits any explanation of the required `id` parameter and what cancellation means operationally, which matters given 0% schema description coverage and no output schema.

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

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

Schema description coverage is 0%, so the schema only supplies the parameter name, type, required status, and a pattern for `id`. The description does not explain what the `id` refers to—such as a screenshot request/job identifier—or how it relates to the pending asynchronous screenshot. This leaves an important semantic gap even for a single-parameter tool.

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

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

The description uses a specific verb and resource: 'Cancel a pending asynchronous screenshot.' An agent can distinguish this from capture tools by the verb and from bulk cancellation by the singular 'screenshot,' though the sibling `cancel_bulk_capture` is not explicitly referenced.

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 'pending asynchronous' implies the tool should be used only while a screenshot job is still pending, which gives some usage context. However, it does not state what to do if the screenshot has already completed or failed, nor does it point to alternatives such as `cancel_bulk_capture`.

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

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

Adds context beyond annotations: the call consumes plan credits/limits, long captures return asynchronously and must be polled, and retries must reuse the same key. That retry note sits alongside idempotentHint=false (idempotency is only guaranteed by supplying the key), which is complementary rather than contradictory. Not stated: whether reusing a key returns the original result or errors.

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?

Five short sentences, front-loaded with what it does, then cost, then async, then retry semantics. Efficient, though "Accepts the existing screenshot options" is a low-value sentence that spends space without informing.

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 high-complexity, heavily nested tool with no output schema and no per-parameter documentation, the description covers operational concerns (cost, async, idempotency) but leaves the large options object, output selection, and the shape of the response entirely 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 0% and the options object nests ~30 undescribed fields (actions, outputs, session, blockLevel, fullPageMode, etc.). "Accepts the existing screenshot options" defers to documentation the agent may not have; only async and idempotencyKey get any treatment, leaving the bulk of the surface unexplained.

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?

"Capture a website" gives a verb and resource but is close to restating the tool name, and it never states that this captures a single URL (versus capture_screenshots_bulk) or that the capture can yield screenshot/PDF/HTML/Markdown/JSON outputs. An agent cannot tell from the description alone what the primary artifact is.

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 concrete operational routing: use async=true for long captures, then poll get_screenshot, and reuse idempotencyKey on retries. It does not address when to choose capture_screenshots_bulk or get_screenshot_result instead, so it stops short of full alternative coverage.

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?

Goes beyond annotations by disclosing that execution is asynchronous and that plan limits apply, plus retry/idempotency behavior. It omits where results land (webhook versus polling via get_bulk_capture) despite the schema exposing webhookUrl, which leaves a meaningful behavioral gap.

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

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

Three tightly packed sentences, each contributing a distinct fact (batching limit, async nature, quota caveat, retry key). No filler or restatement of the tool name.

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 an asynchronous batch job with no output schema, an agent needs to know how completion is signaled. The description never connects to get_bulk_capture, list_bulk_captures, or webhook delivery, and the webhook parameters are left unexplained.

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 the burden, and it only names urls, per-URL options, and idempotencyKey. The webhookUrl and webhookSecret parameters are undocumented in both schema and description, and the large nested defaults/actions/outputs structures get no explanatory prose.

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 (submit), resource (screenshots), and distinguishing scope (up to 100, asynchronously, bulk URLs/options). It implicitly separates the tool from capture_screenshot by emphasizing bulk, but never names the sibling or clarifies the boundary 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?

"Submit up to 100 screenshots asynchronously" and "Reuse idempotencyKey on retries" give real operational context, but there is no explicit guidance on when to choose this over capture_screenshot or a schedule, and no mention of how to retrieve results afterward.

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 readOnly=false, idempotent=false, openWorld=true, destructive=false, so the write/non-idempotent profile is covered. The description adds the plan-permission/limit caveat, which is genuinely useful for anticipating quota failures, but omits whether the schedule is enabled on creation, what happens on repeated calls, and any rate limits for a recurring job.

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 verb and resource front-loaded; nothing is padded or repetitive. Its brevity is efficient, though a sentence of essential guidance (cron format, default schedule state) would have earned its place given the tool's complexity.

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

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

With 15 parameters, deeply nested option objects, zero schema descriptions and no output schema, the description is far too thin to let an agent construct a valid call without studying the raw schema. It should at minimum explain the cron string format and the behaviors of the monitoring-related parameters.

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

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

Schema description coverage is 0% across 15 parameters, so the description must carry the full explanatory burden. It names only four concerns (cron expression, timezone, options, destinations) and gives no cron syntax, no explanation of onlyOnChange/diffThreshold, retentionDays, startsAt/endsAt, alertOnFailure, autoPauseAfterFailures, or the legacy webhookUrl/webhookSecret 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?

Specific verb+resource: 'Create a screenshot schedule' plus the key ingredients (cron expression, timezone, options, destinations). An agent can tell it apart from capture_screenshot or trigger_schedule, though it never explicitly contrasts with update_schedule or the sibling schedule tools.

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

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

No statement of when to create a new schedule vs. update_schedule, no prerequisites, no note on whether the schedule starts active immediately or must be resumed via resume_schedule. The only constraint hint is the passing 'Existing plan permissions and limits apply', which is a resource caveat rather than usage guidance.

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

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

The annotations already declare destructiveHint=true and readOnlyHint=false, so the sentence 'This action is destructive' largely repeats structured data. The description adds no context about irreversibility, impact on existing schedules or screenshots, permissions, or expected response.

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 definition is appropriately short and front-loads the core action. The second sentence is redundant with the destructiveHint annotation, so it does not fully earn its place.

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

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

For a simple destructive tool with annotations covering the safety profile, this is minimally adequate. However, it omits practical context such as irreversibility, alternatives to deletion, and whether the schedule id must come from list_schedules or get_schedule.

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 should compensate for the undocumented id parameter. It only implies that the id refers to a screenshot schedule, without explaining the required 10-character alphanumeric format or how to obtain the id.

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

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

The description uses a specific verb and resource: 'Delete a screenshot schedule.' This clearly distinguishes it from sibling tools such as pause_schedule, resume_schedule, update_schedule, and cancel_screenshot.

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 states what the tool does but gives no guidance on when to use it instead of alternatives such as pause_schedule. It also does not mention prerequisites, confirmation, or consequences that would help an agent decide between deletion and pausing.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds partial return context ('status and individual job IDs'), but says nothing about authentication, pagination, error behavior, or the shape of the response.

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 single sentence is front-loaded and contains no wasted words. It is perhaps too terse for the gaps it leaves, but it is efficiently structured.

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

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

For a simple read-only getter with rich annotations and no output schema, the description is minimally adequate. However, it leaves important gaps around the meaning of the required id parameter and what the returned status/job ID structure looks like.

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

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

The schema has 0% description coverage for the single required 'id' parameter. The description does not clarify whether 'id' refers to the bulk capture ID, a job ID, or something else, and it does not explain the schema's 10-character alphanumeric pattern.

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 ('Get') and resource ('bulk capture status and individual job IDs'), making the basic purpose clear. It does not explicitly distinguish itself from the sibling list_bulk_captures or cancel_bulk_capture, so it falls short of full sibling differentiation.

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

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

The description provides no explicit guidance on when to use this tool versus list_bulk_captures, cancel_bulk_capture, or other capture tools. Usage is only implied by the word 'Get' and the requirement of an id parameter.

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 establish that this is a read-only, idempotent, non-destructive, closed-world operation. The description adds no behavioral context beyond that, such as what happens when the id is unknown, whether it returns configuration details, or any access requirements.

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

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

The single sentence is concise and front-loaded. However, its brevity reflects under-specification rather than efficient completeness for a tool with a required identifier and several similarly named siblings.

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

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

There is no output schema, so the description should clarify what is returned when retrieving a schedule. It does not explain the return shape or how this tool differs from history and list operations, leaving an agent with important 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?

There is one required parameter and schema description coverage is 0%. The description does not explain that the parameter is a schedule identifier, nor does it mention the 10-character alphanumeric format enforced by the schema pattern.

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 states a clear verb and resource: retrieving a screenshot schedule. However, it does not differentiate from sibling tools such as list_schedules or get_schedule_history, leaving ambiguity about whether it retrieves one schedule by identifier or something else.

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

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

The description gives no guidance on when to use this tool versus alternatives like list_schedules or get_schedule_history. It does not mention preconditions, error cases, or how the required identifier should be obtained.

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, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered structurally. The description adds only that results are 'recent' and capped by limit — useful but thin; it says nothing about ordering (newest first?) or whether the cap truncates silently.

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 short, front-loaded sentence with no filler. It could be slightly richer at nearly no cost, 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?

There is no output schema, and the description never says what an 'execution' record contains (status, timestamps, image references) or the ordering. For a history-retrieval tool with no return-value documentation elsewhere, this leaves the agent unable to anticipate the response shape.

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 the load. 'of a screenshot schedule' implies id is a schedule identifier, and 'up to limit' explains limit as a count cap, which is reasonable compensation for two parameters, but the id's 10-character alphanumeric format and the truncation semantics are left unstated.

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 ('Get') and resource ('recent executions of a screenshot schedule'), which clearly separates it from get_schedule (configuration) and get_screenshot (single result). It never names those siblings, so the differentiation is inferable rather than stated.

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: an agent can guess this is for inspecting past runs of a schedule, but there is no explicit when-to-use, no mention of alternatives such as get_schedule or list_schedules, and no preconditions (e.g., whether the schedule must be active).

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, idempotentHint=true and destructiveHint=false, so the safety profile is fully covered. The description adds only that the response is status/metadata (hinting at a non-content payload), with no detail on status values, polling behavior, or error cases for an unknown ID.

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 sentence, front-loaded with the verb and resource, no filler. Nothing could be trimmed without losing 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?

With no output schema, the description leaves the return shape and 'status' vocabulary unspecified, and it does not clarify the boundary with get_screenshot_result, which is the main ambiguity an agent faces among these siblings. Annotations cover safety, so the gap is scoped but real.

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 'id' parameter is documented only by a regex pattern. The description does add real meaning by saying the ID may be a capture ID or a job ID, which the schema does not convey, but it stops short of format or example guidance.

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 ('Get screenshot status and metadata') with the lookup key ('by capture or job ID'). The phrase 'status and metadata' implicitly separates it from get_screenshot_result, but it never names that sibling, so the distinction still requires 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?

Usage is implied by 'status and metadata' rather than stated: an agent can guess this is the polling/metadata call and get_screenshot_result is the content call, but there is no explicit when-to-use or when-not guidance, and the closest sibling is never mentioned.

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

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

Annotations already declare read-only, idempotent, closed-world and non-destructive, so the safety profile is covered. The description adds real behavioral value beyond that: it discloses the return payload (bounded preview, original download URL, metadata, expiration), notes that PDFs and extracted content return links instead of images, and explains multi-output selection.

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 dense sentences with the primary resource and return shape front-loaded, followed by the two exceptional cases (PDFs, multi-output). No filler; every clause 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?

With no output schema, the description does a fair job of describing the return payload, but it omits what happens when the result is incomplete or expired (error vs. pending), leaves 'id' undefined, and gives no guidance on the relationship to get_screenshot.

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 carries the burden. It does explain outputId ('selects a multi-output result'), but the required 'id' parameter is never described — the agent must infer it identifies the screenshot, and the 10-character pattern is only 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 specific verb and resource ('Retrieve a completed screenshot') and enumerates what comes back: bounded image preview, download URL, metadata, expiration. It does not, however, explicitly distinguish itself from the sibling get_screenshot, whose role overlaps closely enough that the agent must infer the difference.

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: the word 'completed' hints this is the post-capture retrieval step, but there is no statement of when to use this versus get_screenshot, or what to do if the result is not yet ready. No alternatives or exclusions are 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 already declare readOnlyHint, idempotentHint, destructiveHint=false and closed-world, so the safety profile is covered. The description adds a useful, explicit reassurance that the call cannot touch billing, which is meaningful context beyond the annotations for a tool that exposes financial data, though it omits auth requirements or any rate-limiting behaviour.

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

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

Two short sentences with zero filler, and the core purpose is front-loaded before the clarifying constraint. Nothing repeats the tool 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?

For a parameterless read tool with no output schema, the description names the three data categories returned (credits, quota, usage history) and rules out side effects, which is nearly everything needed. It stops short of indicating the format or time granularity of 'usage history', a minor gap given there is no output schema to fall back on.

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 no parameters (schema has an empty properties object), so there is nothing for the description to disambiguate; the baseline for a zero-parameter tool 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 (Get) and specific resources (credits, quota, usage history) scoped to the organisation. No sibling tool touches billing or usage data, so an agent can immediately tell this is the only relevant choice.

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 rather than stated — there is no explicit 'use this when...' or exclusion of alternatives. However, with zero parameters and no competing sibling, the practical ambiguity is low, and the 'Does not modify billing' line does head off a misread of intent.

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 readOnly, idempotent, non-destructive behavior, so safety needs no restating. Beyond that the description adds only 'recent', with no ordering guarantee, no indication of whether results are paginated or cursor-addressable, and no sense of how far back 'recent' reaches.

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

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

A single short sentence with the scope ('recent') front-loaded and no redundant restating of the tool name. Brevity here is efficient rather than padded.

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 list tool capped at 100 items with no output schema, an agent cannot tell what a returned capture looks like, in what order they arrive, or how to get older ones. The annotations cover safety, but the listing semantics an agent needs to call this correctly are 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 has numeric bounds and a default for limit but no description text (0% coverage). The description clarifies that limit caps the number of returned captures rather than, say, a time window, which is modest added meaning.

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

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

States a clear verb and resource ('List ... bulk captures') with a recency scope, which is enough to know it returns a collection rather than a single item. However, it never differentiates from siblings such as get_bulk_capture or list_screenshots, so the boundary is left to inference from the tool name.

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

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

No guidance on when to use this versus get_bulk_capture (fetch one by ID) or how to page beyond the cap. The phrase 'up to limit' hints at truncation but doesn't tell the agent what to do about it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only that results are bounded by 'limit' (i.e., the list may be truncated), but says nothing about ordering, pagination, or what a schedule record contains. A modest addition over the annotations, hence 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?

One short, front-loaded sentence with no filler. It is efficient, though the brevity borders on under-specification rather than tight writing.

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 rich annotations and no output schema, the description covers the minimum. It leaves open whether 'limit' paginates or simply caps results and gives no hint of what fields a schedule exposes, which an agent would want before deciding between this and get_schedule.

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 a single parameter with 0% schema description coverage, though the schema itself supplies type, default (50), and 1–100 bounds. 'Up to limit' clarifies that limit is a result cap rather than a filter, but the description adds no format or paging semantics beyond that.

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

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

States a specific verb and resource ('List screenshot schedules'), which is enough to separate it from capture_screenshot or list_screenshots at a glance. It does not, however, explicitly differentiate itself from get_schedule or list_screenshots, leaving that inference to the agent.

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

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

The description gives no when-to-use guidance and never names an alternative such as get_schedule for a single schedule or list_screenshots for actual captures. Usage is only implied by the tool name.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so safety is covered. The description adds two genuinely non-obvious behaviors — that timestamps are UTC and that the `to` boundary is exclusive — but says nothing about result ordering, default sort, or how `query` matches, which are the remaining operational unknowns.

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, zero filler, with the core purpose front-loaded and the subtle caveat trailing it. Nothing can be cut without losing information.

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

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

For a 7-parameter, no-required-argument listing tool with no output schema, the description is minimally adequate: it covers filtering and pagination but leaves the search semantics of `query` and the shape/ordering of results unexplained. An agent could call it, but not confidently predict what it gets back.

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

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

With 0% schema description coverage the description must carry parameter meaning, and it partly does: it names pagination, status, source and UTC date filters, and clarifies boundary inclusivity. However, `query` (the free-text search parameter) is never mentioned or explained, and `page`/`size` get no semantics beyond the word 'pagination'.

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 gives a specific verb and resource ('Search screenshot history') plus the filter dimensions it supports, which clearly separates it from single-item siblings like get_screenshot. It doesn't name a sibling explicitly, 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?

There is no statement of when to use this versus get_screenshot, get_screenshot_result, or list_bulk_captures — the agent must infer the routing. Filter categories are mentioned but are not framed as usage conditions or exclusions.

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

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

Annotations already declare the key behavioral traits: not read-only, idempotent, non-destructive, and closed-world. The description confirms the mutation is a pause of a screenshot schedule, but it does not explain the effect on an in-progress run, required permissions, or whether the schedule can be resumed afterward. With annotations covering the safety profile, this is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately terse for a simple tool, though its brevity contributes to gaps in usage and parameter guidance.

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

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

For a simple one-parameter mutation, annotations and schema structure provide much of the needed context. However, the description omits how to identify the schedule and what pause actually changes operationally, so it is 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?

The input schema documents a single required 'id' parameter with a string pattern, but schema description coverage is 0%. The tool description never mentions the identifier or its format, so it does not compensate for the missing schema description. The parameter name is somewhat self-explanatory, but the description adds no semantic detail.

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: 'Pause a screenshot schedule.' This clearly identifies the operation and distinguishes it from siblings like resume_schedule, delete_schedule, and cancel_screenshot. It does not explicitly name alternatives, but the verb-resource pairing is clear.

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

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

There is no guidance on when to use this tool versus alternatives such as resume_schedule or delete_schedule, nor any stated prerequisites. The agent must infer that pausing is the correct action whenever a schedule should be temporarily halted.

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 state that this is a non-read-only, idempotent, open-world, non-destructive mutation, and the description is consistent with that. However, the description adds no behavioral detail beyond the verb: no state prerequisite, side effects, permissions, or error conditions.

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

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

The description is a single front-loaded sentence with no filler, which is appropriately brief for a one-parameter mutation. Its brevity reflects missing content elsewhere, but the sentence itself is concise and structured.

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

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

With no output schema and annotations covering only the safety profile, the description omits the operational context needed for a schedule state transition: when resuming is valid, what changes, and what the agent should expect. For a resume mutation, this is not complete enough.

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 only parameter is a required id, but schema description coverage is 0% and the description never explains that it is a schedule identifier, its 10-character format, or where to obtain it. The property name gives minimal meaning, but the description does not compensate for the coverage gap.

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

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

The description states a specific verb ('Resume') and resource ('screenshot schedule'), so the core action is clear. It does not explicitly contrast with pause_schedule or explain that it reverses a paused schedule, so it is clear but not fully differentiated from siblings.

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

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

There is no indication of when to use this tool instead of trigger_schedule or update_schedule, nor that the schedule must already be paused. The agent must infer usage entirely from the verb.

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

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

Annotations already declare readOnly=false, openWorld=true, idempotent=false, destructive=false. The description adds genuine context that parameters come from the stored plan rather than the call. But with idempotentHint=false, the consequence of repeat triggers (duplicate runs, usage consumption) is not disclosed, which is a real gap for a non-idempotent mutation.

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 sentence with the action and the governing rule front-loaded; there is no filler. Every clause carries information an agent needs.

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 an open-world, non-idempotent mutation with no output schema, the description leaves meaningful questions open: what is returned (a job id, a capture reference?), and whether the resulting capture is retrieved via get_screenshot_result. An agent can invoke it, but cannot confidently chain the 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 0% for the single `id` parameter, so the description must carry the burden. The pronoun 'its' and 'Trigger a screenshot schedule' strongly imply id is the schedule identifier, but the description never says so explicitly nor mentions the 10-character alphanumeric constraint.

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 (trigger) and resource (screenshot schedule), and clarifies the key mechanic: the run uses the schedule's existing plan rules rather than ad-hoc parameters. This distinguishes it from capture_screenshot (immediate ad-hoc capture) and create_schedule (defining a plan), though it doesn't name those siblings 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?

'now' implies immediate execution versus the scheduled cadence, which is useful implied guidance. However, it never says when to prefer this over capture_screenshot or capture_screenshots_bulk, nor what prerequisites (e.g., a paused vs active schedule) matter.

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 readOnly=false, destructive=false, and idempotent=false, so the write semantics are partially covered. The description adds genuinely useful partial-update behavior ('supply only fields to change'), but leaves the critical ambiguity unresolved: whether omitted nested objects/arrays (options, destinations) are preserved, merged, or replaced, and 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 compact sentence, front-loaded with the verb/resource and followed by the one operational instruction that matters. Nothing is padded, but the brevity crosses into under-specification rather than deliberate economy.

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 16-parameter mutation over deeply nested structures with no output schema and no field-level docs, an agent cannot determine merge-vs-replace behavior, valid schedule/timezone formats, or what a successful update returns. The description is well short of what this schema's complexity demands.

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

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

Schema description coverage is 0% across 16 parameters, including a nested options object with roughly 30 fields and polymorphic destinations/outputs. The description only says which parameters to include, not what any of them mean, so it does not compensate for the documentation gap.

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

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

States a specific verb and resource: 'Update a screenshot schedule'. That is clear against create_schedule/delete_schedule, though it does not explicitly differentiate from pause_schedule, resume_schedule, or trigger_schedule, which are the siblings most likely to be confused with a modification tool.

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?

'Supply only fields to change' implies the PATCH-style usage context and is the only routing signal given. There is no statement of prerequisites (does it need an existing schedule id?), no exclusions, and no pointer to pause_schedule/resume_schedule for state changes.

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