WebArm24

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

No annotations are provided, so the description carries the full burden. It does not state that this is a read-only operation, that it requires authentication tied to the caller's identity (the 'me' scoping), or what shape the account object takes.

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

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

A single short sentence with no wasted words, and the core payload (credit balance) is surfaced immediately. It is terse to the point of underspecification, but nothing is redundant.

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, zero-annotation tool with no output schema, the description should at least convey what the returned account object contains and that the read is scoped to the caller. It hints at credit balance but leaves most of the response surface and safety profile unstated.

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 per-rule baseline is 4. No parameter semantics are 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 names the resource (your account) and one key payload (credit balance), so an agent can infer it retrieves the authenticated user's profile. However, the verb is implicit and it does not distinguish itself from credit-focused siblings like credits_history or credit_packs that also surface balance-related 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?

There is no statement of when to call this versus credits_history or credits_checkout_url, and no prerequisites. The agent must infer usage from the name alone.

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

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

With no annotations at all, the description carries the full disclosure burden, and it only hints at the async lifecycle via the status enum. It does not say whether the call blocks, whether repeated polling is expected, whether results are retained after completion, or what happens if job_id is unknown (error vs failed status).

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 but not efficient — a single noun phrase plus an enum, with no verb, no leading clause telling the agent what to do. This is under-specification rather than conciseness; there is room for one or two more sentences that would earn their 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 two-parameter job-status getter with no annotations and no output schema, the description should convey the polling model and the return shape. It conveys neither, leaving the agent unable to know what a completed job returns or what structured_data_only changes.

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 explain both parameters and does neither. job_id is guessable from the name, but structured_data_only is a non-obvious boolean with a default whose effect (filtering the result payload?) is completely undocumented anywhere.

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 fragment "Job status/result" identifies the resource and implies a read of an existing job, and the parenthetical enum (queued|running|completed|failed) narrows what is returned. However it never states a verb explicitly and does not differentiate itself from agent_job_list or agent_job_submit beyond the name itself, so an agent must infer the getter role.

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 call this versus agent_job_list (list all jobs) or agent_job_submit (create a job). There is no mention of the typical submit-then-poll pattern, no backoff or wait advice, and no statement about when the tool should not be used.

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

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

No annotations are provided, so the description carries the full disclosure burden and delivers nothing: 'recent' is undefined (time window? job states? ordering?), and there is no mention of pagination, result caps, or whether terminal/failed jobs are included.

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 words is under-specification, not conciseness. There is no structure to speak of and nothing is front-loaded because nothing substantive is said.

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 with no annotations, no output schema, and an undocumented parameter, the description leaves an agent unable to predict the result set or call it correctly.

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

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

Schema coverage is 0% and the only parameter, limit (default 20), is undocumented in both schema and description. The description should explain what limit counts against and what the default retrieval window is; it says nothing.

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?

"Recent agent jobs." is essentially a fragment that restates the tool name (agent_job_list) without a verb or scope statement. It implies a listing but never says what is listed, in what order, or how it differs from agent_job_get and agent_job_submit.

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

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

No when-to-use guidance at all. Nothing distinguishes it from the closely related agent_job_get (single job) or agent_job_submit (create job), so an agent must infer routing from names alone.

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

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

With no annotations, the description does real work: async execution, credit consumption, and volatile in-memory job state lost on restart. However, it omits the critical follow-up behavior — that a returned job id is needed to poll via agent_job_get — and says nothing about permissions or failure modes.

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 clauses, front-loaded with the verb and immediately followed by the two operational caveats an agent most needs. No wasted words, though the terseness comes at the cost of the missing parameter details.

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?

Five undocumented parameters, no output schema, and no annotations mean the description should carry a heavy load, and it doesn't. An agent cannot tell what variables, target_url, or output_json_schema do, or what comes back to feed agent_job_get.

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 5 parameters, so the description must compensate and largely fails. 'On a task' loosely implies the required text field, but lang, variables, target_url, and output_json_schema get no mention at all.

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: run the browsing agent on a task, and flags it as async. It is distinguishable from siblings like browser_navigate or pipeline_run by the 'agent job' framing, though it never explicitly contrasts with 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?

No guidance on when to use this versus pipeline_run, browser_navigate, or schedule_create. The credit-cost warning is a usage consideration but not a when-to-use rule, and there are no exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full burden; it does usefully disclose a billing cost ('Costs 1 mcp_call'), which is real behavioral context an agent cannot get elsewhere. However, it says nothing about size limits, whether parsing can fail on malformed JSON, or what each mode returns, which leaves meaningful behavioral gaps for a no-annotation tool.

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

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

A single compact sentence with the resource, mode list, path semantics and cost all front-loaded; no filler or 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?

For a 3-parameter tool with no annotations, no output schema, and zero schema description coverage, the description leaves too much unsaid: the required json_text field is never addressed, mode outputs are uncharacterized, and there is no indication of size limits or failure behavior.

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

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

Schema description coverage is 0% — the schema only supplies titles like 'Mode' and 'Path'. The description compensates by enumerating the mode values (summary|schema|value|preview) and clarifying that path is an 'optional dotted path', which is genuinely more informative than the schema. It still says nothing about json_text or how path interacts with each mode.

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 ('Inspect') and resource ('large JSON') and enumerates the four operational modes, so the agent knows it is a JSON analysis tool rather than a fetch tool. It does not differentiate itself from any sibling, though no sibling appears to overlap with JSON inspection.

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

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

The phrase 'large JSON' implies the intended scenario (bulk payloads too big to dump raw), but there is no explicit when-to-use / when-not-to-use guidance and no named alternative for smaller payloads or for retrieving JSON from storage (storage_read, storage_file_get).

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

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

With no annotations, the description carries the full burden, and it does disclose the cost ('Costs 1 mcp_call'), which is genuinely useful behavioral context. However it says nothing about what happens on multiple matches, element-not-found, or whether the click awaits navigation, so the disclosure is partial.

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 waste, with the primary action front-loaded ahead of the cost note. Nothing could 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 an interaction tool with no annotations, no output schema, and fully undocumented parameters, the description is too thin. An agent lacks guidance on session lifecycle, match ambiguity, and failure behavior before committing a paid 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 description coverage is 0% across two parameters, so the description must compensate. It implies the 'description' param accepts text/label/CSS-selector strings, which helps, but the 'session' parameter (default 'default') is never explained and no format examples are given for the selector syntax.

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

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

Clear verb+resource: 'Click an element' with three accepted targeting modes (visible text, label, CSS selector). It doesn't distinguish itself from the sibling browser_click_at, which an agent would need to choose between, but the core action is unambiguous.

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

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

No statement of when to use this versus browser_click_at, browser_fill, or other browser siblings, and no prerequisites such as an existing session. The agent must infer usage entirely from 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?

No annotations exist, so the description carries the full burden. It does disclose a real behavioral trait no schema exposes: the call costs 1 mcp_call, and coordinates are relative to a resized viewport, a state dependency that affects correctness. It omits, however, whether a session must be open, what happens on click failure, or whether the click can trigger navigation.

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 padding, with the coordinate constraint front-loaded before the cost note. Brevity is achieved, though at the cost of the parameter and session explanation the agent actually 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 a 3-parameter tool with 0% schema coverage, no annotations, and no output schema, the description is too thin: coordinate origin, session targeting, and failure behavior are all unaddressed. The only compensating detail is the mcp_call cost.

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

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

Schema description coverage is 0%, so the description must compensate and largely does not. It clarifies that x/y are pixels rather than CSS selectors or offsets, but gives no origin corner or unit convention, and the third parameter "session" (default "default") is never mentioned at all, leaving the agent unaware that a session can be targeted.

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 plus resource ("Click") qualified by an explicit input domain ("pixel coordinates of the (resized) viewport"), which implicitly separates it from the selector-based sibling browser_click. It never names that sibling, 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?

There is no explicit guidance on when to prefer coordinate clicking over browser_click, no prerequisites such as an active session or a prior navigate/screenshot step, and no exclusions. The agent must reconstruct the decision rule from the phrase "pixel coordinates" alone.

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

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

With no annotations, the description carries the full burden. It does add genuinely non-obvious context — the call is free and sessions are auto-reaped after 30 idle minutes — but it omits what is lost by closing (cookies, page state, in-flight navigations) and what happens when the named session does not exist.

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 padding, with the action stated first and the idle-timeout caveat second. 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?

For a one-optional-parameter tool with no output schema and no annotations, the description covers purpose and one behavioral trait but leaves parameter meaning and sibling disambiguation unaddressed; those are the gaps an agent would actually trip over.

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

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

The single 'session' parameter has 0% schema description coverage and defaults to 'default', yet the description never mentions it, so the agent gets no guidance on what identifier to supply or what the default means.

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: closing the caller's browser session. However, the sibling set contains browser_session_delete, browser_session_get, browser_session_list and browser_session_put, and the description never explains how 'close' differs from 'delete' — an agent cannot disambiguate those two without guessing.

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 prefer this over browser_session_delete, nor any prerequisite (e.g. that a session must be open). The only usage-adjacent information is the idle-timeout fact, which explains why closing is optional rather than required.

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

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

With no annotations, the description carries the full burden; it does add useful context by disclosing a cost of 1 mcp_call, which is genuine behavioral value. However it omits that a live browser session is required, how the 'described area' is resolved (vision/LLM locating), and what happens if the area cannot be found.

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, zero filler, purpose front-loaded followed by the cost constraint. 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?

For a browser tool with no annotations, no output schema, and no documented parameters, the definition leaves critical gaps: session prerequisite, return shape (string vs. structured excerpts), and failure behavior when the described area isn't found.

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

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

Schema description coverage is 0%, so the description must compensate and largely fails. 'Described area' faintly implies area_description is natural-language, but nothing explains the expected phrasing, granularity, or the 'session' parameter's role and 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?

States a concrete verb+resource: 'Extract text from a described area of the page.' An agent can infer it differs from browser_get_html (full HTML) and browser_screenshot (image), but the description never names those alternatives 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?

No guidance on when to prefer this over browser_get_html, browser_screenshot, or browser_click flows. The only usage-adjacent detail is the cost note ('Costs 1 mcp_call'), which hints at a tradeoff but doesn't tell the agent how to weigh it.

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

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

No annotations exist, so the description carries the full burden. It discloses the per-call cost, which is genuinely useful, but says nothing about whether existing field content is cleared or appended, whether change/blur events fire (relevant for autocomplete), or what happens when the field is not found or is disabled.

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

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

Two short sentences with the action front-loaded and no wasted words. The cost note is arguably a separate concern bolted onto the second sentence, but it is compact and useful.

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 no annotations, so the description would need to cover return behavior, session requirements, and overwrite/error semantics to be complete for a mutation-style browser action. It covers the action and the field-lookup strategy but omits the rest.

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 3 params must be explained. The phrase 'identified by label/placeholder/selector' gives real meaning to field_description, but the 'session' parameter is entirely undocumented and 'value' is left 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 and resource ('Type a value into an input') and clarifies the identification strategies (label/placeholder/selector). This distinguishes it from siblings like browser_click or browser_extract_text without needing to open a schema, though it never names those alternatives 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?

There is no guidance on when to use this versus browser_click, browser_click_at, or browser_extract_text, and no prerequisites such as requiring an active session or a loaded page. The only contextual note is a cost statement, which does not help the agent select between siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the cost ('Costs 1 mcp_call') but says nothing about session behavior, whether an active browser session is required, what happens with the default session, or what form the returned HTML takes. The cost detail is useful but insufficient for a tool with no annotation coverage.

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

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

The description is two short sentences with no wasted text, and the core action is front-loaded. The cost note is brief and earns its place by adding decision-relevant 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 annotations, no output schema, and an undocumented session parameter, the description is too thin to fully support correct invocation. It does not explain session targeting, output shape, or error conditions. For a browser-state-dependent tool, more context is needed.

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 optional parameter, 'session', with 0% schema description coverage and a default value. The description does not mention the session parameter at all, so it fails to compensate for the missing schema documentation. The agent must infer what 'session' means and when to override 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 states a specific verb and resource: 'Return the current page HTML.' That is clear enough to distinguish it from text extraction or screenshot siblings, but it does not explicitly name those alternatives. The purpose is clear without being maximally differentiated.

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 browser_extract_text, browser_screenshot, or other browser tools. It mentions cost, but that does not tell the agent when this HTML retrieval is the right choice. Usage context is left entirely 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?

With no annotations, the description carries the full burden, and it does disclose two real behavioral traits: the session is private/server-side and each call costs 1 mcp_call. It omits what happens on navigation failure, whether an existing session's state is preserved, and any timeout/auth behavior beyond the saved-login note.

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 core action, then the one non-obvious parameter behavior and the cost. No wasted words and no repetition of the 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?

No output schema and no annotations mean the description is the only behavioral source, and for a 3-parameter tool with 0% schema coverage it leaves the 'session' parameter and failure/return behavior undocumented. What it does cover — session privacy, saved-login loading, cost — is the right kind of information, just incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains browser_session_label well (loads a saved login on first session creation, with a pointer to browser_session_put), but says nothing about the 'session' parameter (default 'default') or whether url accepts any scheme — partial compensation only.

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 ('Open a URL') plus the scope ('your private server-side browser session'), which clearly separates it from action siblings like browser_click or browser_extract_text. It never explicitly names those siblings as alternatives, so it falls 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 rather than stated: the agent can infer this is the entry point before browser_click/browser_fill, and the description does say when browser_session_label matters (first session creation) and points to browser_session_put. It gives no explicit when-to-use vs. when-not, and no guidance on navigating again within an existing session.

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

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

With no annotations, the description carries the burden, and it does disclose a real behavioral trait: the cost (1 mcp_call) and the output encoding (JPEG). However it omits key operational facts such as whether a live browser session is required, whether the default session is auto-created, and how the image is returned.

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

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

Two short sentences, front-loaded with the resource and format, followed by the cost caveat. No filler whatsoever.

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

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

With no annotations, no output schema, and an undocumented session parameter, the description should explain prerequisites (active session, navigated page) and return mechanics. As written it gives an agent only enough to know what the tool produces, not how to call it successfully.

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 ('session', default 'default') at 0% schema description coverage, and the description says nothing about it — not what it identifies, how to obtain one, or what the default means. 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?

States a specific verb and resource ('Screenshot of the current page') plus the output format (JPEG), which implicitly distinguishes it from browser_extract_text and browser_get_html. It doesn't name those siblings explicitly, but the image-vs-text distinction is clear enough to select correctly.

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

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

No explicit when-to-use, when-not, or alternative guidance. 'Current page' hints that a page must already be loaded via browser_navigate, but the agent is left to infer that, and nothing indicates when to prefer this over text or HTML extraction.

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

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

With no annotations, the description carries the full disclosure burden. It usefully states the cost (1 mcp_call), but says nothing about side effects on the page viewport, whether an active session is required, what happens if scrolling reaches page bounds, or what is returned.

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

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

Two short sentences with the action front-loaded and no filler; the cost note is genuinely useful information. Brevity is achieved, though it comes at the expense of the detail captured in other dimensions.

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

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

This is a simple tool but it has three undocumented optional parameters, no annotations, and no output schema. The description omits the session-scoping model and the meaning of amount, which an agent needs to invoke it predictably in a multi-session browser context.

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

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

Schema description coverage is 0%, so the description must compensate, but it only hints at the direction parameter's 'up'/'down' values. The amount parameter (units/pixels, default 600) and the session parameter (which browser context is scrolled) are entirely undocumented in both schema and description.

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 action (scroll) and its two directions, so the basic operation is clear. However, it never says what is being scrolled (the active browser page in a given session) or how this differs from sibling browser tools, leaving the agent to infer the target from the name alone.

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 scroll versus alternatives like browser_navigate or browser_click, and no stated prerequisite such as an active browser session being required. The only additional context is a cost note, which is not usage guidance.

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

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

No annotations are provided, so the description carries the full burden for what is a destructive, irreversible operation. It does not say whether deletion is permanent, what happens when the label is unknown, whether an active session is required, or whether credentials are recoverable — all material for a delete tool.

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

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

A single front-loaded sentence with zero filler and no hedging — efficient. The brevity is a virtue structurally; the missing content belongs in the other dimensions rather than here.

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, unannotated, single-parameter tool with no output schema and 0% schema coverage, one sentence is not enough. An agent cannot know the label format, the failure mode for a nonexistent session, or whether to confirm with browser_session_list first.

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 'label' parameter is undocumented in both schema and description. The description implies the label identifies a saved login, but never states whether it is a username, an arbitrary user-chosen name, or a case-sensitive key, nor what happens on a miss.

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 saved login), which maps cleanly onto the browser_session_* family and distinguishes it from browser_session_get/list/put. However it never explicitly says 'browser session' so the agent has to infer that 'saved login' equals 'session', and scope (whose login, per-workspace?) is unstated.

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

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

No when-to-use guidance, no prerequisites, and no pointer to the obvious companion tools (browser_session_list to find a label, browser_session_put to modify instead of delete). The agent is left to infer that a label must already exist and how to obtain one.

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

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

No annotations are provided, so the description carries the full disclosure burden. It doesn't say what happens if the label doesn't exist, whether the returned state is a safe read, or what the response contains, all of which matter for an unannotated retrieval tool.

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

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

It's a single front-loaded fragment with no waste, but it is under-specified rather than genuinely concise. There is room to add a clause about usage or return value without bloat.

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

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

With no annotations, no output schema, and an undocumented parameter, the description is insufficient for an agent to call this confidently. It should at minimum clarify what a storageState is and how labels relate to the put/list siblings.

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

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

The single required parameter "label" has 0% schema description coverage and the description adds no meaning beyond implying it identifies a saved session. With the schema documentation gap at 0%, the description should have clarified the label's format or source (e.g., matching browser_session_put), but does not.

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

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

States a specific verb and resource ("Get a saved storageState"), which tells an agent this is a retrieval of stored browser state by label. However, it never explains what a storageState is (cookies/localStorage snapshot) and doesn't distinguish it from siblings like browser_session_list, which an agent could easily confuse with retrieval.

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 browser_session_list, browser_session_put, or browser_session_delete. There is no mention of prerequisites (e.g., that the label must already exist) and no exclusions, leaving the agent to infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the burden; 'List' and 'saved' imply a non-destructive read, and the Playwright storageState gloss adds useful domain context. However, it says nothing about whether credential/cookie payloads are exposed or how many slots are returned.

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

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

A single compact sentence with zero filler and the identifying noun phrase front-loaded after the verb. Nothing to trim.

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 should signal what a slot looks like (name, id, saved cookies, timestamps) and whether listing exposes sensitive material. For a simple zero-param read tool it is minimally adequate but leaves the return shape entirely unstated.

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; baseline 4 applies. No parameter claims conflict with the empty 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?

Specific verb (List) plus resource (saved logins / Playwright storageState slots), which reads clearly and is distinguishable from browser_session_get/put/delete by the listing verb. It falls short of a 5 because it never names those siblings or delineates 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?

No statement of when to call this versus browser_session_get or browser_session_put, and no prerequisite context (e.g., that a session must have been stored first). Usage is only inferable 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?

No annotations are provided, so the description carries the full behavioral burden. It does add one valuable fact — the state is stored encrypted — but it omits whether an existing label is overwritten, whether this requires an authenticated session, size limits, and what is returned on success.

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. It is efficient, though the brevity is partly the cause of the missing usage and parameter detail rather than a virtue of tight writing on a well-covered tool.

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

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

With no annotations, no output schema, and 0% schema coverage on two required parameters including a nested object, the description does not supply enough for an agent to call this correctly. Critical details such as overwrite semantics and the relationship between 'label' and later retrieval are absent.

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

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

Schema description coverage is 0% for both required parameters. The description says nothing about what 'label' is used for (a key for later retrieval by browser_session_get?) or what shape 'storage_state' expects, despite it being a free-form nested object with additionalProperties true. The schema alone leaves an agent guessing.

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 concrete verb ('Save') and a specific resource ('Playwright storageState'), which clearly separates it from the read-side siblings browser_session_get/list and from browser_session_delete. It doesn't explicitly name those siblings, but the resource noun is distinctive enough that an agent can place it in the session family.

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 save a storage state versus calling browser_navigate or letting a session persist naturally, and no mention of prerequisites such as having an active browser session to capture. Usage is only inferrable from the name.

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

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

With no annotations, the description carries the full burden and discloses nothing: not whether it is a read-only list, whether it requires auth, or what it returns (a catalog of packs with prices and sizes?). The fragment is behaviorally empty.

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, but shortness here reflects under-specification rather than economy. The single fragment is not front-loaded with actionable information and contains no sentence that tells the agent anything useful.

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 catalog tool with no output schema and no annotations, the description must at least imply the shape of the result and the calling context. It does neither, leaving the agent to guess whether this is a list endpoint, a purchase flow, or metadata.

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 explain; baseline 4 applies. No parameter semantics are 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?

"Purchasable credit packs" restates the tool name as a noun phrase without a verb or any indication of what the tool does with them (list? fetch? create?). An agent cannot distinguish it from siblings credits_checkout_url or credits_history on the basis of this text.

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 alternative named. Nothing tells the agent whether this should be called before credits_checkout_url or credits_history, or under what circumstances.

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

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

With no annotations, the description does disclose meaningful behavior: it creates an external Stripe-hosted checkout and requires human action to complete payment. It omits whether the URL expires, whether repeated calls create duplicate sessions, and what permissions or account state are needed.

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 sentence, front-loaded with the action and ending with the critical human-in-the-loop constraint. 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 one-parameter tool with no annotations and no output schema, the description covers the core purpose and the human payment step but leaves the parameter meaning, URL lifetime, and result shape unexplained. 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?

Schema coverage is 0% for the single required parameter credits_amount, which is an undescribed integer. The description only hints that it corresponds to a 'pack', giving no units, allowed values, or relation to the packs listed by credit_packs, so it fails to compensate for the schema 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: creating a Stripe Checkout URL for a credit pack. This distinguishes it from sibling read tools such as credit_packs and credits_history. It does not explicitly name those siblings, so it falls 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?

The clause 'a human must open it to pay' implies the tool only prepares a payment link and that the agent cannot complete the purchase itself, which is useful usage context. However, it never says when to call this versus credit_packs (to discover pack sizes) or what to do after the URL is returned.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the 100-entry cap, which is a behavioral constraint beyond the empty schema, but it does not state that the operation is read-only or mention any permission or rate-limit considerations.

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 seven-word fragment with no wasted words, and the most important information (balance and recent ledger entries) is 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 should explain return values more fully. It states that balance and the last 100 ledger entries are returned, but it omits details like entry fields, ordering, or whether the balance is current at call time.

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

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

The tool has zero parameters, which matches the baseline expectation of 4. The description does not need to explain parameter semantics and appropriately focuses on output content.

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

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

The description clearly states the tool returns the credit balance and the last 100 ledger entries. This is specific about the resource and output, though it lacks an explicit verb and does not differentiate itself from siblings like credit_packs or credits_checkout_url.

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 instead of alternatives such as credit_packs or credits_checkout_url. The intended use (viewing balance/history) is implied only by the description of returned data.

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

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

With no annotations present, the description carries the burden and does disclose key behavior: it costs builder_call credits, it does not persist the draft, and it returns {text, pipeline}. That is meaningful beyond what the empty annotation block provides. Gaps remain on whether conversation state outside `messages` is retained, auth requirements, and rate limits.

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

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

Three compact clauses with zero filler, backticked identifiers tying each statement to its schema field, and the cost note front-loaded. Every sentence carries distinct information.

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

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

With no output schema, the description usefully supplies the return shape {text, pipeline}, and it handles the nested-object risk by spelling out the messages element shape. The unmentioned `builder_context` and the absent guidance on fetching the current draft (presumably via pipeline_get) are the remaining 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?

Schema description coverage is 0%, so the description must compensate. It does explain two of three parameters usefully: `messages` is a [{role,content}] array and `pipeline` is the current draft. However, the optional `builder_context` parameter is never mentioned anywhere, leaving one parameter entirely 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?

The description names a specific verb+resource: chatting with the built-in AI pipeline builder, and clarifies that it produces a draft rather than persisting one. It routes the output to pipeline_create/pipeline_update, which separates it from the sibling write tools. It does not distinguish itself from pipeline_debug_chat, the closest analogous chat sibling, so 5 is not warranted.

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 clear operational rule: the returned draft is NOT saved, so pass it to pipeline_create/update. It also flags the credit cost (builder_call), which is decision-relevant before calling. It does not state when to prefer this over pipeline_debug_chat, leaving one real alternative ambiguous.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says this creates a pipeline and mentions extra webhook keys, but omits permissions/auth, side effects or defaults for enabled/cron_expr/run_at, and what the operation returns.

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 with no filler. The docs pointer and extra-field note each add practical value.

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

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

This is a moderate-complexity create tool with 7 parameters, nested steps, and no annotations or output schema. The description gives a docs pointer but leaves most parameters and mutation behavior unexplained, so it is not complete enough for reliable 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?

There are 7 parameters with 0% schema description coverage. The description explains only `extra` keys and defers `steps` to an external resource; name, run_at, enabled, cron_expr, and task_variables remain 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?

States a specific verb and resource ('Create a pipeline'), so the core operation is unambiguous. It does not explicitly differentiate from sibling pipeline_update/pipeline_delete beyond the verb, so 4 rather than 5.

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

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

No explicit when-to-use, when-not, or alternative guidance is given, such as create vs update or when to use schedule_create instead. The docs pointer helps with step schema but not tool selection.

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

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

With no annotations, the description carries the burden but does disclose one important behavioral trait the schema cannot: this call consumes builder_call credits. It says nothing about whether it is read-only, latency, or whether the conversation is stateful across 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?

One short sentence, front-loaded with the action, with the cost caveat in parentheses. Nothing wasted, though the brevity is partly under-specification rather than efficiency.

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 annotations, no output schema, and three undocumented required parameters. For a credit-consuming AI call, the description should indicate what the response looks like (analysis text? chat continuation?) and whether follow-up questions are permitted.

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 all three required parameters (pipeline_id, run_id, question). The description never explains the relationship between pipeline_id and run_id, nor what kind of question text is expected, so nothing compensates for the schema 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: ask the AI to analyse a finished run. The word 'debug' in the name and 'analyse a finished run' in the description separate it from pipeline_builder_chat, though the sibling alternative is never 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?

The phrase 'finished run' implies the precondition that the run must be complete before asking, but there is no explicit when-to-use/when-not guidance and no routing toward pipeline_builder_chat or pipeline_run_get for other diagnostics.

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

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

With no annotations, the description carries the full burden, and it does disclose two meaningful traits: the delete cascades to the schedule, and the removal is soft/reversible via pipeline_deleted_restore. That is real value beyond structured fields. Still missing are permission requirements, whether run history is preserved, and whether any confirmation or blocking behavior applies to a destructive operation.

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

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

One sentence, front-loaded with the action and scope, with the recovery hint in a compact parenthetical. 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 destructive single-param tool with no annotations and no output schema, the description covers scope and reversibility but omits operational prerequisites and side effects on runs/history. Adequate to call safely, not complete.

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

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

Schema coverage is 0% and the single parameter pipeline_id has no description in the schema, so the description would need to compensate. It does not mention the parameter at all, though 'pipeline_id' is unambiguous and required. Baseline 3 for a trivially inferable single identifier.

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 pipeline and its schedule'), and the cascade detail distinguishes it from schedule_delete, which only removes a schedule. The named sibling pipeline_deleted_restore further clarifies its place in the lifecycle. It does not explicitly contrast with pipeline_update or explain what a pipeline is, but the operation is unmistakable.

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 parenthetical names pipeline_deleted_restore as the recovery path, which implies 'use this when you intend a recoverable removal.' However, there are no preconditions stated (e.g. whether the pipeline must be stopped first, whether active runs are cancelled) and no explicit 'do not use when...' 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?

With no annotations, the description carries the full behavioral burden. It discloses that returned pipelines are restorable and enumerates return fields, but it does not mention read-only status, permissions, pagination, or whether all deleted pipelines are included.

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

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

The description is a single compact sentence with no wasted words. The key qualifier 'that can be restored' is front-loaded before the return-field list.

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 zero-parameter list tool with no output schema, the description provides the essential return-shape information. It could add pagination or permission context, but the low complexity keeps it reasonably complete.

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

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

The tool has zero input parameters, so there are no parameter semantics to document. The listed fields describe return data rather than input options, which is appropriate 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 identifies the resource as deleted pipelines that can be restored and lists the returned fields, making the tool's scope clear. It does not explicitly use a verb like 'list' or name the sibling restore tool, but the noun phrase is specific enough to distinguish it from pipeline_list.

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

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

Usage is implied: it is for finding deleted pipelines that are eligible for restoration. However, it does not explicitly say when to use it instead of pipeline_deleted_restore or pipeline_list, nor does it state any prerequisites.

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

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

With no annotations, the description carries the burden and does disclose key side effects: the id is preserved, the pipeline comes back disabled, and the inbound trigger URL changes. It still omits error conditions (e.g., no snapshot available), permission requirements, and whether the original trigger URL is permanently invalidated.

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 dense sentence, front-loaded with the action and immediately followed by the concrete outcomes. No filler or redundant 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 a single-parameter tool with no annotations or output schema, the description covers the important behavioral facts (id reuse, disabled state, new URL). Only edge cases and failure modes 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 coverage is 0% for the single param, so the description must compensate. 'Same id' hints that pipeline_id refers to the deleted pipeline's identifier, but it never explicitly says which pipeline_id to supply, leaving a small ambiguity about whether the caller passes the deleted pipeline's 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?

States a specific verb ('Re-create'), resource ('deleted pipeline') and source ('from its last snapshot'), which cleanly distinguishes it from pipeline_create and pipeline_history_restore. The parenthetical adds concrete outcomes (same id, disabled, new URL) so the agent knows exactly what it gets.

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 word 'deleted' implies the precondition (only for pipelines that were deleted), but there is no explicit when-to-use statement and no mention of alternatives such as pipeline_create or pipeline_history_restore. Usage must be inferred from the resource 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?

No annotations exist, so the description carries the full load. It does useful work by disclosing the shape of the return payload (steps, schedule, inbound trigger URL), which tells the agent this is a rich read rather than a bare record; but it says nothing about permissions, behavior for a missing/deleted pipeline, or scope of the trigger URL.

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 wasted words. The key content (what comes back) is stated 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, the description supplies the important return-value context and the tool is a simple single-parameter getter, so little else is strictly required. A brief note on missing-ID behavior or the deleted-pipeline case would close the 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?

One required parameter with 0% schema description coverage, so the description would need to compensate and does not — it never explains what pipeline_id is, its format, or where to obtain it. The parameter is self-evident from its name, so this is a modest gap rather than a blocking one.

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 ('Get') plus a precisely scoped resource ('one pipeline') with an enumeration of what the payload contains: steps, schedule, inbound trigger URL. The word 'one' implicitly contrasts with pipeline_list, but no sibling is named, so differentiation is inferred 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?

Retrieving a single pipeline by ID is implied by the 'one pipeline' framing, and the enumerated contents hint at when this is the right call over pipeline_list. However, there is no explicit when-to-use/when-not statement and no alternative pointed to.

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

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

No annotations exist, so the description carries the full burden. It does disclose the most important non-obvious behavior: because group_id defaults to null, calling with only pipeline_id silently unassigns the pipeline. It says nothing about error behavior for unknown pipeline/group ids, permissions, or whether re-assigning an already-grouped pipeline overwrites.

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 primary action, with the edge case following in a parenthetical. No 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 simple two-parameter mutation with no annotations and no output schema, the description covers the action and the removal trap but omits what is returned and how failures are surfaced. An agent can call it, but cannot predict the response or the 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 coverage is 0%, so the description must compensate, and it does for the non-obvious parameter: group_id's null/omitted case is spelled out explicitly rather than left to the schema default. pipeline_id is conveyed only by implication ('move a pipeline'), with no note on 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?

States a specific verb and effect: 'Move a pipeline into a group', which is precise about what changes. It does not explicitly contrast with siblings like pipeline_update or pipeline_group_update, which could plausibly also alter grouping, so the agent must infer the split from the name alone.

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 useful condition for one branch of use ('omit group_id (or pass null) to remove it from its group'), which is effectively a when-to-use hint. It gives no guidance on when to prefer this over pipeline_update for group changes, nor any prerequisite such as the group existing or ownership.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the side effect of moving pipelines, which is useful, but says nothing about permissions, name uniqueness, workspace scoping, error behavior for invalid pipeline IDs, or what the call returns.

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 wasted words; the core action and optional behavior both land 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?

For a mutation tool with no annotations, no output schema, and 0% parameter documentation, the description is thin. An agent can infer how to call it, but lacks enough context about scope, failure modes, and results to invoke it confidently.

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

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

Schema description coverage is 0%, so the description must compensate. It does clarify that pipeline_ids are the pipelines to move into the new group, and name is the group name, but it omits format details, the null default, and whether pipeline_ids is a list of IDs.

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

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

States a specific verb (create) and resource (sidebar group), plus the optional effect of moving pipelines into it. It does not explicitly distinguish itself from the sibling pipeline_group_assign, which also moves pipelines, but the core purpose is unmistakable.

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: create a group and optionally seed it with pipelines. There is no explicit guidance on when to choose this over pipeline_group_assign or pipeline_group_update, and no prerequisites or exclusions are stated.

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

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

With no annotations, the description carries the burden and does disclose the most important side effect: pipelines are preserved and merely ungrouped. It does not say whether the group deletion is reversible, what permissions are required, or whether child pipelines are modified atomically.

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 padding, with the key side-effect stated up front immediately after the action. Nothing to trim.

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 mutation with no annotations and no output schema, the definition covers the main consequence but omits error behavior, idempotency, and permission requirements. Adequate minimum, with clear remaining 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?

Only one parameter, group_id, and schema description coverage is 0%. The description never mentions it, but the name is self-explanatory and the tool has a single required input, so the gap is modest rather than critical.

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

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

States a specific verb and resource ('Delete a group'), clearly distinct from pipeline_group_create/update/list and from pipeline_delete. The scope of 'group' vs 'pipeline' is implied by the second sentence rather than defined, so it falls just short of full clarity.

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 statement or named alternative, but 'Its pipelines are kept, just ungrouped' implicitly routes the agent away from pipeline_delete when the intent is to remove a grouping rather than the pipelines themselves. Usage is inferable, not 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?

No annotations are provided, so the description carries the burden. It discloses that the result includes pipeline_ids and that ungrouped pipelines are in no group, and the verb 'List' implies a read-only operation. However, it does not mention permissions, ordering, or rate limits, leaving some behavioral context 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?

Two short sentences, front-loaded with the core action and then the ungrouped edge case. No filler or redundancy.

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

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

For a zero-parameter list tool with no output schema, the description is nearly complete: it explains what is returned (groups with pipeline_ids) and how ungrouped pipelines are represented. Additional information about ordering or result size would make it fully complete, but the essentials are present.

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 parameters, so the parameter semantics baseline is 4. The description appropriately does not try to explain non-existent parameters and instead clarifies the returned grouping structure.

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: it lists sidebar pipeline groups and notes they include pipeline_ids. This clearly distinguishes it from pipeline_list, which lists pipelines rather than groups, but it does not explicitly name or differentiate against sibling group operations like pipeline_group_create or pipeline_group_update.

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

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

The description implies usage by saying it lists 'your sidebar pipeline groups' and explains the ungrouped case, but it gives no explicit when-to-use guidance, prerequisites, or alternatives. An agent can infer this is the read operation for groups, but nothing is spelled out.

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

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

No annotations are provided, so the description carries the full burden. It does not state the required permissions, what happens if group_id is invalid, whether unspecified fields remain unchanged (though 'and/or' hints at a partial update), or what the response looks like. For an unannotated mutation tool, this is a significant gap.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately brief, though it lacks structure for an agent needing to understand partial-update semantics.

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

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

This is a mutation tool with no annotations, no output schema, and 0% schema description coverage. The description names the two mutable fields but omits error behavior, permission requirements, partial-update semantics, and return information, leaving the agent under-equipped for a three-parameter update operation.

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. It does explain that `name` performs a rename and that `collapsed` controls the group's sidebar collapse state, which adds semantic meaning beyond the bare 'Collapsed' title. However, it does not document the group_id parameter's format or constraints beyond the schema title 'Group 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 names specific operations (rename, set collapsed) and a specific resource (a group), which separates it from pipeline_group_create, pipeline_group_delete, pipeline_group_assign, and pipeline_group_list. It does not explicitly contrast against those siblings, but the verb+resource combination 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 explicit guidance on when to use this tool versus pipeline_group_create (for new groups) or pipeline_group_list. The only hint is that it acts on an existing group via group_id, which the agent must infer from 'Rename a group'.

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

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

With no annotations and no output schema, the description carries the burden and does disclose useful return behavior: it explains that snapshot is the full pipeline state after the change and diff is versus the previous revision. However, it does not state that the operation is read-only, whether permissions are required, or what happens on invalid 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?

It is a single compact sentence that front-loads the key fact ('One revision') and avoids waste. The fragmentary notation makes it slightly less clear than it could be, but it is not bloated.

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 two required, undescribed parameters and no annotations or output schema, the definition is under-specified. It gives useful return-field context but leaves the input semantics and basic operational behavior to inference.

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

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

The description does not mention pipeline_id or revision_id at all. With 0% schema description coverage on two required parameters, it fails to compensate for the missing documentation.

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 says 'One revision' and lists the returned fields, implying retrieval of a single pipeline revision, but it never states the action or resource explicitly. The sibling pipeline_history_list exists, and the contrast between 'One revision' and a list is implied rather than spelled out.

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, including the obvious sibling pipeline_history_list. The description also omits any prerequisites such as needing a valid pipeline_id or revision_id.

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

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

With no annotations, the description carries the full burden, and it does well: it discloses ordering (newest first), the non-obvious merge behavior of consecutive manual UI edits into one revision, and the pagination mechanism. It stops short of stating read-only/scope guarantees or the effective limit ceiling, but the genuinely surprising behavior is surfaced.

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 units, front-loaded with purpose followed by the return shape, merge semantics, and pagination hint. The inline field enumeration is long but earns its place as the only return-shape documentation available.

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 read tool with no output schema and no annotations, the description supplies the return structure, ordering, revision-merging rule, and cursor pagination — enough to call it correctly. The gap is the `limit` parameter's bounds and whether history is complete or truncated.

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

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

Schema description coverage is 0%, so the description must compensate. It explains `before_seq` as the pagination cursor and ties `seq` to the returned fields, but leaves `limit` (default 30, maximum?) and `pipeline_id` format entirely undocumented in both schema and description.

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?

Opens with a specific verb-resource pair ('Change history of a pipeline, newest first'), so an agent immediately knows this is the revision-list read. It never names or distinguishes itself from the sibling pipeline_history_get, which presumably fetches a single revision, so the boundary 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?

There is no explicit when-to-use or when-not guidance, and no mention of pipeline_history_get or pipeline_history_restore as alternatives. The only usage-adjacent text is 'Page with `before_seq`', which covers iteration but not tool selection.

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

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

With no annotations, the description carries the full burden, and it does add real value by disclosing that the restore is non-destructive — the prior state is recorded as a new `restore` revision — and that the pipeline is returned. It omits permissions/auth requirements, whether live runs are affected, and what happens to revisions created after the target one.

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 and the mechanism front-loaded and the return value last. 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 two-parameter mutation with no annotations and no output schema, the description covers the core semantics (what gets recorded, what is returned). It leaves gaps on sourcing revision_id and on the operational side effects of restoring, which an agent needs before calling it.

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 both parameters rely entirely on the description, which says nothing about them. It never explains how to obtain a revision_id (presumably from pipeline_history_list) or whether pipeline_id accepts a slug versus internal 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?

States a specific verb and resource ('Restore a pipeline') plus the mechanism (target revision state, recorded as a new `restore` revision) and the return value. It does not differentiate itself from the superficially similar sibling pipeline_deleted_restore, 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?

The purpose implies when to use it (rolling a pipeline back to a prior revision), but there is no explicit guidance on when not to use it and no pointer to alternatives such as pipeline_history_list to obtain a revision_id or pipeline_deleted_restore for undeleting a pipeline. Usage must be inferred.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only list operation, but it does not say what is returned, whether deleted or grouped pipelines are included, or how pagination or ordering works.

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 one short, front-loaded sentence with no filler. The brevity is appropriate for a zero-parameter list tool.

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

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

The tool is simple and parameterless, but with no output schema or annotations the description still leaves important context missing: which pipelines are listed (active, deleted, or all) and whether results are paginated or ordered. The presence of sibling list tools makes that scope distinction especially important.

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

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

The tool has zero parameters, so there are no parameter semantics to document. The baseline of 4 is appropriate because there is no parameter ambiguity to resolve.

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

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

States a specific verb (List) and resource (pipelines), scoped to the caller's account, so the core operation is clear. It does not distinguish from sibling list tools such as pipeline_deleted_list, pipeline_group_list, or pipeline_runs_list, so it is clear but not fully differentiated.

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

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

No guidance is given on when to use this tool versus pipeline_deleted_list, pipeline_group_list, or pipeline_runs_list, and there are no prerequisites or exclusions. An agent can infer a default list operation, but the description provides no explicit routing.

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

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

With no annotations, the description does real work: it discloses that execution is asynchronous, that a run_id comes back, and that the call consumes pipeline_run credits — the latter being a cost trait an agent must know before invoking. It does not cover failure behavior, whether the run can be cancelled mid-flight, or permission prerequisites, which leaves some burden unaddressed.

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, action and return value front-loaded before the follow-up routing. Nothing repeats the schema or restates the 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?

The invocation lifecycle (start → wait/get) and cost are adequately covered, which is the core need for a fire-and-forget execution tool. But with no annotations, no output schema, and 0% parameter coverage, the definition should still explain what the three optional inputs do; an agent cannot compose a correct non-trivial call from this description alone.

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 four parameters, so the description must carry the meaning — yet it never mentions pipeline_id, variables, skip_steps, or initial_step_outputs. The format of variables or what a 'skip step' reference looks like is left entirely to guesswork.

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

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

States a specific verb and resource ('Start a run') plus the async contract and the return value (run_id). It also names the two sibling tools that continue the workflow, so it is distinguishable from pipeline_run_get, pipeline_run_wait, and pipeline_run_cancel 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?

Explicitly says to follow this call with pipeline_run_wait or pipeline_run_get, which gives the agent a clear ordering rule and names the alternatives. It stops short of saying when NOT to use it (e.g. testing a single step via pipeline_test_step, or scheduling recurring execution via schedule_create).

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

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

With no annotations, the description carries the full burden. It does disclose a genuinely useful trait: cancellation is a request that is applied between steps, so it is asynchronous and best-effort. It omits permissions required, idempotency, whether cancellation can be undone, and what happens if the run completes first.

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 names the action, the target, and the timing caveat, with zero 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 simple two-parameter mutation with no annotations and no output schema, the description covers the core action and its latency semantics. Missing are the success response behavior (immediate acknowledgement vs. confirmation of stop) and the handling of already-terminated runs.

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%, both parameters are required strings, and the description never mentions pipeline_id or run_id. The names are suggestive, but an agent gets no confirmation of whether pipeline_id is needed for scoping/auth or how the pair must relate.

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: cancelling an active pipeline run, which is distinct from pipeline_run, pipeline_run_wait, and pipeline_run_get in the sibling list. It never explicitly contrasts with those siblings, though, 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?

The phrase 'of an active run' implies the precondition that only in-flight runs qualify, and the name signals the context. There is no explicit when-not guidance (e.g. what to do for a queued or already-finished run) and no named 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?

With no annotations and no output schema, the description carries the full burden, and it does disclose the return shape — the five status values and the presence of per-step results and an answer_preview. It omits the read-only nature, auth/permission requirements, error behavior for missing runs, and whether per-step payloads are truncated.

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 compact fragment with no wasted words, but it is a field inventory rather than a description and is not front-loaded with purpose. The terse parenthetical enum is efficient, yet the overall structure is under-specified rather than concise.

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 return-field enumeration partially compensates for the absent output schema, which is the description's main contribution. However, a get-by-id tool with two undocumented parameters and no annotations still lacks purpose framing, error handling notes, and sibling routing, leaving real 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?

Schema description coverage is 0% for the two required parameters, and the description says nothing about them. The parameter names are fairly self-evident, but there is no compensation for the complete lack of documented semantics, such as the relationship between pipeline_id and run_id or their expected format.

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 enumerates what comes back (status values, current_step_index, per-step results, answer_preview) but never states the action explicitly — the verb and resource are only inferable from the tool name. It gives no differentiation from siblings like pipeline_run_wait, pipeline_runs_list, or pipeline_history_get, which retrieve overlapping run information.

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

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

There is no guidance on when to use this versus pipeline_run_wait (which presumably polls for completion) or pipeline_runs_list. No preconditions, no mention that both pipeline_id and run_id are required, and no note on what happens for unknown runs.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses a maximum of 50 results, which is useful, but it does not state that the operation is read-only, whether results are ordered by recency, how pagination works, or what happens when a pipeline has more than 50 runs.

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 short sentence with zero wasted words, and the key resource and result cap are front-loaded. It is appropriately sized for a simple two-parameter listing tool.

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

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

With no annotations, no output schema, and zero schema description coverage, the description is too thin to fully specify the tool. An agent does not learn ordering, pagination, whether the limit default of 10 is respected, or any behavioral guarantees, which matters even for a simple list operation.

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

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

Schema description coverage is 0%, and the description does not explain pipeline_id's role or the limit parameter's default of 10. The 'max 50' phrase adds some meaning, but it is ambiguous whether that cap applies to the limit value or the total number of runs returned.

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 resource and action: fetching recent runs for a pipeline, with a cap of 50. It is distinguishable from pipeline_run_get, which presumably fetches a single run, but it does not explicitly name that sibling or clarify that this is a list operation.

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 pipeline_run_get, pipeline_run_wait, pipeline_history_list, or pipeline_list. The phrase 'Recent runs' implies a listing use case, but selection criteria and exclusions are left entirely 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?

With no annotations, the description carries the full burden and does well: it discloses the blocking long-poll behavior, a hard cap of 600 seconds (beyond the schema's 120 default) and how to interpret the returned status. It omits what happens if the run is cancelled, missing, or if the wait errors out.

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 tight sentence with the blocking behavior front-loaded and the timeout/status caveat parenthetical. 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?

For a wait tool with no annotations and no output schema, the description supplies the essential behavior plus return-value interpretation (check `status`). Remaining gaps are edge cases such as run-not-found or cancelled runs and which ID takes precedence.

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 explain all three parameters. It only enriches timeout_sec (blocking purpose, max 600, default behavior implied); pipeline_id and run_id are left entirely undocumented beyond self-evident names, and the relationship between the two is 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?

The description states a precise behavior: block until the run finishes or the timeout elapses, then return the latest run state. This clearly distinguishes it from non-blocking siblings like pipeline_run_get in practice, though it never names that sibling or restate that it operates on an existing pipeline run.

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 blocking semantics imply it should be used instead of polling pipeline_run_get, and the 'status still running means timed out' note gives the caller a completion check. However, there is no explicit guidance on when to prefer it over polling, no prerequisites, and no mention of what to do on timeout.

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

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

With no annotations, the description carries the full burden. It does not disclose whether running a step performs real side effects (e.g. sending emails, writing storage), what authentication or pipeline state is required, or whether the run is recorded in history. Only the template interpolation note is offered, which is not a behavioral trait.

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

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

Two short sentences, front-loaded with the core action and no filler. It is efficient, though the terseness edges into under-specification rather than genuine conciseness.

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 a required nested object parameter, no annotations, no output schema, and 0% schema coverage, the description is far too thin. An agent cannot know the shape of `step`, what this returns, or what a successful isolated run implies.

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 3 parameters, so the description must compensate and largely fails. It explains only that `previous_outputs[i]` maps to `{{step_{i+1}_output}}`, a cryptic note that leaves the required nested `step` object and `pipeline_variables` entirely 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?

The verb+resource ("Run a single step in isolation") is stated and "in isolation" hints at differentiation from pipeline_run, but the description never says what a "step" is, what pipeline it belongs to, or what testing a step entails. An agent can guess the general idea but cannot confidently distinguish this from pipeline_run or pipeline_debug_chat 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?

No explicit when-to-use guidance and no named alternatives among the many pipeline_* siblings. "In isolation" implies debugging/iteration but the description never says to prefer this over pipeline_run for validation, nor when not to use it (e.g. it does not state whether side effects occur).

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose the most consequential trait: this is a partial patch, but `steps` wholesale replaces the step list and `run_at: null` clears the value, so silent data loss is possible. It omits other traits an agent needs for a mutation with no safety hints — permission/auth requirements, whether changes are reversible, error behavior on unknown field keys, and the response 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?

Three sentences, front-loaded with the verb, then the allowed-key enumeration, then the one destructive caveat. No filler; every clause carries information an agent would otherwise have to guess.

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 mutation tool with zero annotations, no output schema, and a nested free-form object parameter, the description covers the field vocabulary but leaves gaps: return value, error modes, permission requirements, and per-field types. Adequate to invoke correctly in the happy path, not complete.

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

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

Schema coverage is 0% and `fields` is an untyped free-form object with additionalProperties: true, so the description is the only source of truth — and it enumerates all eleven accepted keys plus the two special semantics (null clears run_at, steps replaces the list). It does not give per-key types or formats (cron_expr syntax, task_variables shape, which flags are booleans) and says nothing about pipeline_id, so it is strong but not complete compensation.

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?

"Patch a pipeline" gives a specific verb (patch/partial update) and resource, and the sibling set (pipeline_create, pipeline_delete, pipeline_run) makes the CRUD role obvious from the name plus verb. It stops short of naming a sibling it might be confused with (e.g. pipeline_group_update, schedule_update) in prose, 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?

Usage is only implied: "Patch" signals a partial update of an existing pipeline rather than a create/delete, and the field-level notes (run_at null clears, steps replaces the whole list) hint at how to use it correctly. There is no explicit when-to-use/when-not statement, no mention of prerequisites such as ownership or permissions, and no pointer to alternatives like pipeline_create.

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

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

With no annotations, the description bears the full behavioral burden and mostly fails: it never says whether creation triggers an immediate run, what permissions or credits are needed, how cron_expr and run_at interact, or what is returned. The field-name hints (mode agent|replay, webhook_url) are the only behavioral signal.

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-load the purpose, which is good, but the trailing "..." makes the definition feel truncated rather than concise. For a nested-object creation tool the payload is under-specified rather than efficiently 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?

A create tool with a free-form nested schema, zero schema descriptions, no annotations, and no output schema needs substantially more: required vs optional fields, valid combinations of cron_expr vs run_at, and what a successful creation yields. The description gives only a partial field enumeration.

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

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

Schema coverage is 0% and the single parameter is an open nested object, so the description must compensate. It does list the ScheduleCreate field names and even the mode enum values, which meaningfully exceeds the schema, but the list trails off with "..." and explains no field's 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?

"Create an automation" gives a specific verb and resource, and the tool name schedule_create makes the object unambiguous next to schedule_update/delete/list. It stops short of explicitly differentiating itself from pipeline_create or explaining how a schedule relates to a pipeline, but the core action 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 statement of when to use this versus schedule_update, pipeline_create, or agent_job_submit, and no prerequisites or exclusions. The only implied guidance is that a `schedule` object must be supplied, which the schema already requires.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states the mutation but omits the critical traits of a delete operation: whether deletion is permanent or reversible, what happens to existing runs/history, and whether any permissions or confirmations are required.

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 free of padding, but the brevity reflects under-specification rather than efficiency. There is no structure to convey scope, side effects, or prerequisites.

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 single-parameter tool with no annotations and no output schema, the definition is substantially incomplete. An agent cannot confirm irreversibility, side effects, or parameter meaning from the description alone.

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

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

Schema description coverage is 0%, and the description never mentions schedule_id — it does not say what identifier is expected, where to obtain it, or what happens if it is invalid. With one undocumented parameter, the description should have compensated but does not.

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

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

The description gives a specific verb ('Delete') and resource ('an automation'), so the operation is clear at a glance. It offers no differentiation from sibling operations such as schedule_update, schedule_get, or the pipeline/storage delete tools, and the term 'automation' does not exactly match the tool name 'schedule'.

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 schedule_update, schedule_export, or pipeline_delete, and no prerequisites or confirmation requirements are mentioned. The agent must infer usage entirely from the name and the single required 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?

No annotations are provided, so the description carries the full burden. It doesn't say whether this is a read-only operation, whether it returns the JSON inline or writes a file/download URL, or whether it includes referenced sub-resources. For a no-annotation tool, that is a substantial 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?

One short, front-loaded sentence with no padding, but it is under-specified rather than efficient — the length saved comes at the cost of missing behavioral detail.

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 should explain what comes back (raw JSON string, file reference, download link) and whether the payload is self-contained for re-import. None of that is present, leaving the agent unable to predict the result 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 coverage is 0% and the only parameter, schedule_id, is undocumented in both schema and description. The phrase 'an automation' implies the ID selects the schedule to export, which is sufficient to invoke correctly, but no format or constraints are added.

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: exporting an automation (schedule) as portable JSON. The output format is named, which distinguishes it from schedule_get and schedule_list. It stops short of naming its natural inverse, schedule_import, but the operation is unambiguous.

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

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

No guidance on when to export vs. reading the schedule with schedule_get, or how this pairs with schedule_import. The agent must infer that export is for portability/backup and get is for inspection.

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

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

With no annotations and no output schema, the description carries the full burden. It does disclose the return payload ('details plus recent runs'), which is genuinely useful, but says nothing about what 'recent' means, whether runs are paginated or truncated, or what happens with an invalid schedule_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?

Five words is efficient and front-loaded, but it is terse to the point of under-specification for a tool with no annotations and an undocumented parameter. Conciseness here costs clarity rather than serving it.

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?

Low complexity (one required param), but with no annotations and no output schema the description should at minimum state that it takes a schedule id and returns that schedule's configuration and run history. It covers the return shape only partially and omits the input entirely.

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 required parameter schedule_id, so the description must compensate and it does not — it never mentions that the call is keyed by a schedule identifier or where that id comes from. The name is self-explanatory but the description adds nothing.

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 phrase 'Automation details plus recent runs' does identify the resource (a schedule/automation) and hints at a read operation returning detail plus run history, which distinguishes it loosely from schedule_list. But there is no verb, and the tool name's 'get' behavior is only implied 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?

No guidance on when to use this versus schedule_list, schedule_run, or agent_job_get. The agent must infer from the name alone that this fetches a single schedule by id while schedule_list enumerates them.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses almost nothing: no permissions, no conflict/overwrite semantics, no duplicate handling, no notion of what is created or returned. Only the implicit source of the payload (an export) is conveyed.

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 sentence with no filler, so it is not bloated. But brevity here reflects under-specification rather than economy – nothing is front-loaded because nothing is said.

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 import tool taking an arbitrary nested document, with no annotations and no output schema, an agent needs to know what the document must contain and what the call produces. Neither is covered, leaving the definition incomplete 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?

The single required parameter 'document' has 0% schema description coverage and is a free-form nested object with additionalProperties=true, so its shape is entirely opaque. The description's phrase 'an exported automation' weakly signals the payload's origin but gives no structure, format, or example to compensate.

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 verb (Import) and an object (an exported automation), which is enough to guess this is the counterpart to schedule_export. However, it never says that the result is a schedule/automation record, nor whether an existing one is replaced, so the resource is only loosely identified relative to siblings like schedule_create.

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

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

There is no guidance on when to use this versus schedule_create or schedule_update, and no mention that the input must come from schedule_export. The agent must infer the pairing from the name alone.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about read-only nature, pagination, result limits, or whose schedules are returned. For a list tool that can return unbounded results, these omissions matter.

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

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

A single short sentence with no filler and the resource front-loaded. It is efficient, though the brevity edges toward under-specification rather than optimal conciseness.

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

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

With no annotations and no output schema, the description should at least indicate the return shape (list of schedules with names/IDs) and whether pagination or filtering exists. None of that is present, leaving the agent guessing about the output.

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

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

The tool has zero parameters and the schema is empty at 100% coverage, so there is nothing for the description to clarify. Per the rubric, a no-parameter tool starts at a baseline of 4.

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 automations"), and the parenthetical "(single-task schedules)" clarifies terminology. However, it does not distinguish this from sibling list tools such as pipeline_list or agent_job_list, nor does it say whether it returns all schedules or a scoped subset.

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

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

There is no guidance on when to use this versus schedule_get or pipeline_list, and no mention of prerequisites, scope, or exclusions. The agent must infer usage purely from the name.

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

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

With no annotations, the description does useful work by disclosing two behavioral traits: the call is synchronous and it consumes schedule_run credits. It stops short of stating whether the call blocks until completion, what happens on failure or timeout, or whether any permission/plan gating applies.

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

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

A single short sentence with no filler, and the action is front-loaded ahead of the parenthetical caveats. It is efficient but borders on terse given the unaddressed gaps.

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 no annotations, yet the description says nothing about what is returned (run id, status, results) or how `variables` feeds the automation. For an execution-triggering tool with an undocumented free-form parameter, this leaves an agent under-informed.

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 burden and adds nothing about either parameter. schedule_id's purpose is guessable from the name, but `variables` (a free-form object passed to the automation) is completely unexplained in both schema and description.

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 object ("Run an automation now") and ties implicitly to the schedule_id parameter, so an agent can tell this triggers a schedule. It does not explicitly distinguish the tool from siblings like pipeline_run or schedule_get, leaving the schedule-vs-pipeline boundary to be inferred from the parameter 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?

"now" and "synchronous" imply this is for immediate execution rather than creating or editing a schedule, which gives usable context. However, there is no explicit when-to-use/when-not guidance and no named alternative for asynchronous execution (e.g. pipeline_run or agent_job_submit).

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

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

With no annotations, the description carries the full behavioral burden. 'Patch' implies a partial mutation, but the description does not say whether unspecified fields are preserved, whether the whole automation is replaced, what permissions are required, or what the response contains.

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

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

It is a single short sentence with the verb front-loaded and no padding. However, the parenthetical adds little informational value, so brevity comes at the cost of under-specification rather than true efficiency.

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 mutation tool with no annotations, no output schema, and a nested free-form `fields` object with additionalProperties, the description is far too thin. An agent cannot confidently construct a call or predict effects from this text.

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 explain both parameters. It only offers the opaque phrase 'ScheduleUpdate fields', which hints that `fields` is a ScheduleUpdate payload but gives no field list, format, or meaning for `schedule_id`, and says nothing about the free-form nested object.

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 ('Patch') and a resource ('an automation'), but 'automation' is a loose synonym for the tool's actual schedule resource and the parenthetical 'ScheduleUpdate fields' merely echoes a data type name. It does not distinguish the tool from siblings like schedule_create, schedule_delete, or schedule_import.

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 schedule_create, schedule_import, or schedule_delete, and no mention of prerequisites such as ownership or permissions. The agent is left to infer usage entirely from the name.

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

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

With no annotations, the description carries the full burden. It does disclose two genuinely useful behavioral facts beyond the schema: sends go through the server SMTP subject to allowlists/limits, and each call costs 1 mcp_call. It omits whether sending requires a verified sender/account, whether delivery is synchronous, and what errors (blocked recipient, quota) look like.

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 core action front-loaded and no padding; the cost and constraint caveat are tucked into a parenthetical rather than buried. It is efficiently sized, though its brevity comes at the expense of the content covered in other dimensions.

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 four-parameter, no-output-schema mutation tool this is minimum viable: the agent knows what it does, roughly what it costs, and that allowlists apply. It is not complete enough to call confidently — the is_html flag and any required sender identity are undocumented anywhere.

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

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

Schema description coverage is 0%, so the description must compensate and it does not — it never mentions to, subject, body, or is_html. The names to/subject/body are self-explanatory, but is_html (the only parameter with non-obvious semantics, controlling HTML vs plain-text rendering) is completely 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?

States a specific verb and resource ("Send an email") plus the transport ("through the server SMTP"), so an agent knows exactly what the tool does. No sibling tool in the list covers email, so no differentiation is needed, though the description stops short of noting anything about delivery semantics.

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 parenthetical mentions allowlists/limits, which is a constraint rather than guidance on when to use the tool. There is no statement of prerequisites (e.g. an authenticated account or a validated sender), no when-not-to-use condition, and no alternative 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?

No annotations are provided, so the description carries the full burden and fails it. It does not say whether deletion is irreversible, whether contained files are removed, what permissions are required, or what happens when the named store does not exist.

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 with the verb and free of filler, so nothing is wasteful. However, brevity here reflects under-specification rather than economy, leaving the definition too thin to act on.

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 mutation with no annotations, no output schema, and an undocumented parameter, the description omits everything an agent needs: irreversibility, side effects on contained data, and error semantics. It is inadequate for the tool's risk 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 0%, so the single required parameter "name" is entirely undocumented in structured data. The description only implies name refers to a store identifier; it gives no format, case sensitivity, or whether it must already exist.

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 ("Delete a store"), but "store" is never defined and no distinction is drawn from the closely-named sibling storage_file_delete. An agent can guess the gist but cannot tell whether a store is a namespace, a bucket, or a file collection.

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

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

There is no when-to-use, when-not-to-use, or alternative routing guidance. The presence of storage_file_delete and storage_list in the sibling list makes the missing distinction (deleting an entire store vs. one file) a real ambiguity the description does nothing to resolve.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says 'delete' but does not disclose whether deletion is permanent, whether a confirmation or special permission is required, what happens if the file does not exist, or whether the operation is reversible.

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

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

The description is a single front-loaded sentence with no filler, but its brevity reflects under-specification rather than efficiency, since nothing beyond the bare action is conveyed.

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 mutation tool with no annotations, no output schema, and an undocumented required parameter, this description leaves too much unspecified. An agent cannot confidently determine the identifier format or the consequences of the 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?

The single required parameter 'name' has 0% schema description coverage, and the description does not clarify whether it is a filename, path, ID, or key. With no compensating explanation, the agent is left guessing the expected identifier format.

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 verb and resource ('Delete a stored file'), so the basic action is legible. However, it does not differentiate this tool from storage_delete, storage_file_get, storage_file_put, or storage_files_list, and 'stored file' is too generic to tell an agent which storage namespace or object type is affected.

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 storage_delete or the other storage_* siblings, and no prerequisites or exclusions are mentioned. The agent must infer the correct tool purely from the name.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one meaningful behavioral trait the schema can't: the 8 MiB base64 truncation/limit. However, it says nothing about auth requirements, whether exceeding the limit errors or truncates, or how the base64 payload is shaped in 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?

A single tight sentence with the critical constraint in parentheses, front-loaded and waste-free. Slight under-specification rather than verbosity is the issue.

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 read tool with no output schema, the essentials (what it returns, size limit) are covered, but the opaque 'name' parameter and the absence of any error/limit behavior leave real gaps an agent must guess at.

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 is just 'name' with no title beyond that. The description says 'a file' but never clarifies whether 'name' is a path, a bare filename, or an identifier, nor which directory scope it resolves against — so the ambiguity is unmitigated.

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 ('Download a file') plus the return encoding (base64) and a hard size cap. An agent knows exactly what it gets back. It doesn't explicitly contrast with storage_read or storage_write, which are the nearest ambiguous 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?

No statement of when to use this versus storage_read, storage_files_list, or storage_file_put. The 8 MiB note implies a fallback path exists for large files but never says what to do instead, leaving the agent to infer routing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses size caps, but it does not state overwrite behavior, required permissions, error conditions, or what happens when a file with the same name already exists.

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

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

The description is short and front-loaded, with no wasted prose. The size-cap sentence is terse and somewhat cryptic due to environment-variable names, but the overall structure is efficient.

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 mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It identifies the action and size caps but omits key operational details needed to invoke it confidently.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It clarifies that content_base64 is base64-encoded file content, but it does not explain the semantics of name, such as whether it is a filename, path, or unique key.

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: 'Upload a file.' It clarifies that content is supplied as base64, which helps distinguish the operation. However, it does not differentiate this tool from nearby storage siblings such as storage_write or storage_file_get/delete.

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 storage_write, storage_file_get, or other storage siblings. The only contextual information is a size-cap note, which does not help an agent choose between alternatives.

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

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

No annotations are provided, so the description carries the full burden, and it discloses nothing: no result format, ordering, pagination/limit behavior, recursive vs flat semantics, or permissions. A read tool for a storage namespace has many behaviors an agent needs to predict results, and none are present.

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 sentence is terse with no filler, but it is under-specified rather than concise: three words convey no information beyond the tool name. There is no structure to front-load because there is no content.

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

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

With no output schema, no annotations, and an undocumented parameter, the description leaves an agent unable to call the tool correctly or predict what comes back. At minimum it should explain prefix semantics and whether results are recursive across the storage namespace.

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

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

Schema description coverage is 0% and the description never mentions the sole "prefix" parameter. Whether prefix is a path prefix, a name filter, or a delimited pseudo-directory selector is entirely left to guesswork, so the description fails to compensate for the schema 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?

"List stored files" names a specific verb and resource, which is enough to know it enumerates files. However, it does nothing to separate itself from the many sibling list/read tools (storage_list, storage_file_get, storage_read), so an agent cannot tell which listing tool is the right one from the description alone.

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

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

There is no guidance on when to use this versus storage_list, storage_file_get, or storage_read, and no stated preconditions. The single optional parameter hints at prefix-scoped listing, but the description never says so or explains when to supply it.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the bare operation: no scoping (account-wide vs. workspace), no indication of result shape or size, and no auth or pagination notes. 'List' implies read-only, but that is inference, not disclosure.

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

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

A single front-loaded sentence with no filler, appropriate in size for a zero-argument list operation. It is efficient but arguably too terse to be called exemplary 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?

With no annotations, no output schema, and an undefined notion of a 'store', the description leaves the agent unable to predict what comes back (names? ids? metadata?) or what the returned handles are used for in storage_read/storage_write. For a discovery-style listing tool this is a meaningful 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?

The tool takes zero parameters and the schema is fully described, so there is no parameter semantics to explain. The description does not need to compensate for anything 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 ('List') and resource ('JSON/text stores'), so the basic operation is unambiguous. However, 'stores' is never defined (it is distinguished only implicitly from the many storage_file* siblings), and there is no differentiation from storage_files_list or storage_read.

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 alternative guidance is given, despite six sibling storage tools where an agent must choose between listing stores, listing files, and reading content. The agent has to infer the relationship from the names alone.

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

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

No annotations exist, so the description carries the full behavioral burden, yet it says nothing about permissions, error behavior for a missing store, whether the read is by name only, or what is returned. Only the verb "read" weakly implies a non-destructive operation.

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

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

One short sentence with no filler, so nothing is wasted, but its brevity reflects under-specification rather than disciplined front-loading. There is no structure beyond the bare verb-noun phrase.

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 no annotations, the description had to explain the store concept, the read semantics, and the return shape. It does none of these, leaving an agent with no basis 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?

The single parameter "name" has 0% schema description coverage, and the description never clarifies whether it is a store name, an ID, or a path. With only one required parameter the field's meaning is partly inferable, but the description adds nothing to disambiguate 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?

"Read a store" restates the tool name with a verb and a resource, but never defines what a "store" is here or how it differs from storage_file_get, storage_file_put, or storage_list. An agent cannot determine the scope of the read without guessing.

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 alternative guidance is given. The presence of storage_list, storage_file_get, storage_write, and storage_delete as siblings makes a routing hint essential, and none is provided beyond the implicit verb.

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

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

With no annotations, the description carries the full disclosure burden. It hints at serialization behavior via the mode clause, but never states the most important trait of a write tool: whether writing to an existing name overwrites, appends, or errors, nor what permissions or return value are involved.

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 behavioral note attached inline — no padding. The only flaw is that the parenthetical is terse to the point of ambiguity rather than being genuinely inefficient.

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

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

This is an unannotated mutation tool with three undocumented parameters and no output schema. The description should at minimum cover overwrite semantics and key scoping to be sufficient, and it covers neither.

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 all three parameters, so the description must compensate. It only partially explains 'mode' (auto vs text) and says nothing about 'name' (is it a key? a path? a namespace?) or what shapes 'value' may take — the parenthetical 'keeps JSON' is itself unclear about what is being kept.

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 verb 'Write' plus resource 'store' gives a rough idea of a key-value write, but 'store' is an ambiguous resource noun. Critically, the description does nothing to separate it from sibling storage_file_put, which is also a write operation in the same family, so the agent cannot confidently choose between them from the text alone.

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 storage_file_put, storage_read, or storage_list. No preconditions, no exclusions, no named alternatives — the agent must infer routing entirely from the tool name.

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