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 the important non-effect that remote items survive cancellation. It does not say what happens to the job record afterward, whether cancelling an already-submitted job errors or is a no-op, or whether the call is idempotent — meaningful gaps for a mutation 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 no filler; the scope limitation ("without deleting remote items") is placed where it is most useful. Nothing could be trimmed without losing meaning.

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 an undocumented parameter mean the description has to do more than one sentence. It omits the return value or resulting job state, error behavior for submitted jobs, and where the job_id originates, leaving real gaps for a mutating tool.

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

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

Schema coverage is 0% for the single parameter, so the description must explain job_id, and it never mentions it. There is no hint whether the id comes from speechify_upload_text, speechify_list_jobs, or speechify_get_job, nor any format guidance.

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

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

States a specific verb ("Cancel") and resource ("unsubmitted upload work"), and implicitly distinguishes itself from the destructive siblings by noting it does not delete remote items. An agent can tell this is not a delete operation, though the term "job" appears only in the tool name and parameters, so the link between "upload work" and a job 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?

"Unsubmitted" implies the precondition (the job must not have started uploading), which is useful implied guidance. However, it names no alternative — with siblings like speechify_get_job, speechify_list_jobs, and speechify_retry_job present, an agent gets no explicit routing such as checking status first or retrying instead of cancelling.

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 supplied, so the description carries the full behavioral burden, yet it discloses nothing about side effects, what 'verified' entails, or how idempotency_key and expected_updated_at affect the outcome. Mutation semantics and the error-vs-use_existing fallback are entirely undisclosed.

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 no wasted clauses, but that brevity comes from under-specification rather than economy; nothing is front-loaded because there is nothing to front-load.

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

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

For a 6-parameter mutation tool with no annotations, no output schema, and a required idempotency_key, the description is wholly inadequate; an agent cannot call this correctly without reverse-engineering the schema.

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

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

Schema description coverage is 0% across 6 parameters, and the description adds no meaning for any of them: name, item_id, parent_id (nullable), if_exists enum, idempotency_key, and expected_updated_at are all left for the agent to guess.

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 'create folder' does name a verb and resource, but the sentence is essentially a restatement of the tool name wrapped in unexplained filler ('Perform verified'). It never clarifies what 'verified' means or how folder creation differs from siblings like speechify_upload_text or speechify_move_item.

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

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

There is no when-to-use guidance, no conditions selecting this over alternatives, and no mention of prerequisites such as needing a parent folder or an existing item. An agent gets nothing to route on.

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; 'atomically' is a genuine behavioral disclosure (no partial files) that the schema cannot express. However, it omits permissions/auth needs, what happens when the target path already exists and overwrite is false, and whether any side effects occur on the remote item.

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

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

A single front-loaded sentence with no filler; the destination constraint, which is the most error-prone part of the call, is stated first.

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 must explain the write side effects and result, but it does not say what is returned or how failure/overwrite conflicts are reported. For a tool that writes to the local filesystem, that is a material gap.

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

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

Schema description coverage is 0%, so the schema only gives types; the description partially compensates by clarifying that output_path is an absolute local path. It says nothing about item_id (what identifier domain it belongs to) or about overwrite semantics, leaving two of three parameters without added meaning.

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

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

States a specific verb ('Download') and resource ('one file') plus the destination constraint ('local absolute output path'), which separates it from metadata-reading siblings like speechify_get_item. It stops short of naming a sibling or explaining what 'one file' means relative to the other item tools.

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

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

There is no statement of when to use this tool versus speechify_get_item or the other item tools, and no prerequisites such as needing the item to be fully processed (e.g., a completed job) before download. The word 'atomically' implies a safe write but does not tell the agent when this is the right call.

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

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

No annotations are supplied, so the description carries the full behavioral burden. "Read" signals a non-mutating operation and "current" hints at live state rather than a snapshot, but nothing is said about errors for unknown ids, permission requirements, or what happens with trashed items. It adds the essential read-only framing but leaves meaningful behavioral gaps.

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 the resource and selector front-loaded and no filler. Nothing could be removed 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?

This is a simple one-parameter read tool with no output schema or annotations, so the bar is modest. Still, an agent is left guessing about id provenance, behavior on missing or trashed items, and what a successful response contains.

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 single item_id parameter is documented nowhere but in the phrase "by id", which at least connects the parameter to being the item's identifier. It does not explain the id's format or where an agent obtains a valid id (presumably speechify_list_items), so the gap is only partly filled.

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 pairs a specific verb ("Read") with a specific resource ("one current Speechify Library item") and a selector ("by id"). This clearly separates it from speechify_list_items and speechify_get_job, though it does not explicitly name those 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?

Usage is only implied: fetch a single item when you already have its id. There is no explicit guidance on when to prefer speechify_list_items versus this tool, no mention of whether trashed or deleted items are retrievable, and no prerequisites 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 exist, so the description carries the full load, and it does disclose the return composition (counts plus one page of items) and that jobs are 'persistent'. It does not cover read-only safety explicitly, behavior on an invalid or expired job_id, rate limits, how pagination terminates, or what the counts represent.

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 and the three returned components in order, with no filler. It is perhaps too terse given the documentation gaps elsewhere.

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 zero schema-level parameter docs, the description should explain the item list shape, the count aggregates, and pagination behavior, but it only names them. For a three-parameter tool whose parameters are entirely undocumented, this leaves 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%, with three parameters, and the description only vaguely gestures at 'one page of items', hinting at limit and item_cursor without explaining cursor semantics or the 500-item cap. It says nothing about job_id's format or where an agent obtains 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?

The description gives a specific verb and resource ('Read a persistent upload job') and states what it returns ('aggregate result counts, and one page of items'), which distinguishes it from speechify_list_jobs and speechify_get_item. It stops short of explicitly naming those 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?

Nothing says when to call this rather than speechify_list_jobs (find a job id), speechify_list_items (enumerate all items), or speechify_session_status. An agent must infer that this is a single-job status-plus-page-of-results call.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that results come from a 'complete local snapshot' (useful context about data freshness), but it does not explain pagination behavior, cursor semantics, default filtering by state, or whether the snapshot is refreshed—leaving significant behavioral gaps for a 7-parameter listing tool.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately concise, though 'normalized' is slightly jargon-heavy and could be clarified without adding much length.

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

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

For a 7-parameter listing tool with no annotations and no output schema, the description is too thin. It does not explain filtering, pagination, defaults, or return characteristics, leaving an agent without enough context to invoke the tool correctly in varied scenarios.

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 7 parameters, and the description mentions none of them. It adds no meaning for kind, limit, query, state, cursor, folder_id, or recursive, so an agent gets no guidance beyond the raw schema types and enums.

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 ('List') and resource ('Speechify Library items') and adds scope ('from a complete local snapshot'), making the basic operation clear. However, it does not differentiate this tool from siblings such as speechify_get_item or speechify_list_jobs, so an agent must infer the distinction.

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

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

There is no explicit when-to-use guidance, no mention of alternatives like speechify_get_item for single-item retrieval, and no indication of when to prefer this listing tool over other sibling tools. Usage is only implied by the verb 'List'.

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 supplied, so the description carries the full behavioral burden, yet it says nothing about pagination behavior (implied by limit/cursor), result ordering, retention of jobs, or what "persistent" means. The one useful hint is that results are scoped to the bound account, but that is minimal for a read tool with zero 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?

A single front-loaded sentence with no filler, which is structurally sound. It is concise to the point of under-specification rather than verbose, so it loses only slightly 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?

With no annotations, no output schema, and three undocumented parameters, the description leaves too much unknown for an agent to call this correctly. It should at minimum explain the meaning of "state" and the pagination contract implied by limit and cursor.

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 adds no parameter meaning at all. The most consequential gap is "state", an unconstrained string with no enum and no explanation of valid values, and "cursor" is never explained as a pagination token.

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

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

The description uses a specific verb+resource pair ("List ... jobs") and scopes it to the bound Speechify account, which separates it from the single-job sibling speechify_get_job. However, the distinguishing modifier "persistent" is never defined, and the description does not explicitly contrast with speechify_list_items or speechify_get_job.

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

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

There is no guidance on when to list jobs versus fetching one with speechify_get_job, nor any mention of when listing is preferable to speechify_list_items. The agent must infer usage purely from the tool name in the sibling list.

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 entire burden, yet it discloses nothing about side effects, permission requirements, or what happens to the item's prior parent. The presence of idempotency_key and expected_updated_at signals retry/concurrency semantics that the description never explains.

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 wasted words, but it is concise to the point of under-specification; there is no front-loaded statement of effect or scope because there is essentially 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?

A 6-parameter mutation tool with no annotations and no output schema needs a substantive description of preconditions and effects, and this one provides none beyond echoing the name.

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 6 parameters, and the description adds no meaning for item_id, parent_id, if_exists, expected_updated_at, or the required idempotency_key. Nothing compensates for the undocumented schema.

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

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

"Perform verified Speechify move item" restates the tool name plus an unexplained qualifier ("verified"); it names no source/destination semantics and gives no basis for distinguishing this move from siblings such as speechify_rename_item or speechify_trash_item.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the 16 sibling tools; an agent must guess whether moving is the right operation versus renaming or re-parenting.

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 supplied, the description carries the full burden, and it discloses almost nothing. "Permanently" is the only behavioral signal (irreversibility), with no mention of required permissions, whether the idempotency_key is mandatory, or what happens when the item 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 short but only because it conveys no information; it is under-specified rather than concise. Padding like "Perform verified" consumes the limited space without adding meaning.

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 six undocumented parameters, no annotations, and no output schema, the description is wholly inadequate. An agent cannot determine safety constraints, idempotency requirements, or expected behavior 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% across six parameters, so the description must compensate and does not. Critical semantics such as the required idempotency_key, expected_updated_at (apparent optimistic concurrency), the if_exists error/use_existing enum, and name/parent_id are 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?

"Perform verified Speechify permanently delete item" mostly restates the tool name (speechify_permanently_delete_item) rather than describing the operation. The word "permanently" hints at irreversibility, but "Perform verified" is filler and the description never explains what an "item" is or how this differs from speechify_trash_item.

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

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

No when-to-use guidance is given. The implicit contrast between "permanently delete" and the sibling speechify_trash_item / speechify_restore_item is never stated, and there is no warning about when not to use it despite the destructive, irreversible nature implied by the wording.

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 supplied, so the description carries the full behavioral burden and delivers almost none. It does not say the operation mutates state, whether it is reversible, how idempotency_key or expected_updated_at (optimistic concurrency) affect the outcome, or what happens when the item is missing.

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 brevity here is under-specification rather than conciseness. The single sentence carries no actionable information beyond the name, so no sentence earns its place.

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

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

For a 6-parameter mutation tool with no annotations and no output schema, the description is completely inadequate. An agent cannot determine conflict handling, existing-item behavior, or expected results 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% across 6 parameters, and the description says nothing about any of them. Critical semantics — the if_exists enum, the nullability of parent_id, the role of expected_updated_at for conflict detection — are 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?

"Rename item" names a specific verb and resource, so the core action is inferable. But the framing "Perform verified Speechify rename item" is largely a restatement of the tool name, and "verified" is undefined — verified by what, against what? Nothing distinguishes it from siblings like move_item or trash_item beyond the word rename.

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

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

There is no when-to-use guidance, no mention of when to prefer move_item vs rename, and no prerequisites such as required permissions or item state. 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?

No annotations are supplied, so the description carries the full disclosure burden and discloses nothing. It does not state permission requirements, whether the restored item returns to its original parent, what happens if the parent no longer exists, or how idempotency_key and expected_updated_at affect behavior.

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

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

The single short sentence is not verbose, but brevity here reflects under-specification rather than economy. Nothing is front-loaded beyond the verb, and no sentence earns its place by adding 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?

The tool has six parameters, one required, an enum, and no annotations or output schema, so the description is the only behavioral source. One tautological sentence cannot make an agent confident about invocation or side effects.

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?

Six parameters with 0% schema description coverage and zero explanation in the description: name, item_id, if_exists, parent_id, idempotency_key, expected_updated_at are all undefined. The if_exists enum semantics and the interaction between parent_id and the original location are 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?

"Perform verified Speechify restore item" mostly restates the tool name, with only the unexplained qualifier "verified" added. It never says what is being restored (a trashed item, presumably), what state it returns to, or how it differs from siblings like speechify_trash_item and speechify_permanently_delete_item.

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

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

There is no when-to-use guidance, no preconditions, and no mention of alternatives. An agent must infer that this reverses speechify_trash_item, and receives no guidance on when restore is preferable to re-creating or moving an item.

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 supplied, so the description carries the full burden of behavioral disclosure, and it discloses almost nothing. It doesn't say whether retrying mutates the original job or creates a new one, whether a new job id is returned, whether the operation is idempotent, or what permissions are needed. For a state-changing tool this 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 sentence with no filler and the precondition front-loaded, so nothing is wasted. However, it is undersized for a mutation tool — brevity here comes at the cost of specification rather than from efficient writing.

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

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

No annotations, no output schema, and an entirely undocumented required parameter mean the description should do more work than a single clause. An agent still cannot tell what a successful retry returns or how to recover from an invalid job_id.

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 required parameter job_id is never mentioned in the description. The agent must infer that job_id is the identifier of the failed/cancelled job it wishes to re-run, and nothing explains the expected 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?

"Retry" is a specific verb, but the resource is described as "upload work" rather than the job entity that the tool name and parameter imply. The agent can infer it re-runs a previously failed job, but the description never uses the word "job" and so does not map cleanly onto siblings like speechify_get_job or speechify_cancel_job.

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

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

It supplies a real precondition — only for work that is failed or cancelled — which implies when to call it. It does not say how to discover a failed job (e.g., list_jobs/get_job to obtain a job_id), nor does it state that cancel_job or upload_text are the alternatives for the other states.

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 disclosure burden. It usefully clarifies that no credentials are returned (preventing a call made in search of secrets) and that the tool only reports state rather than mutating anything. It does not say what the verdict looks like, whether it can fail/timeout, or what conditions make the tab unsafe.

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 purpose front-loaded and the non-obvious guarantee (no credentials returned) placed second. 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 probe with no output schema, the description should convey the shape of the verdict — a ready/not-ready signal, possibly with a reason. It only hints at what is absent (credentials). Adequate but leaves the agent guessing what a useful or failed response looks like.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. The description correctly implies no inputs are needed to run the check.

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?

Uses a specific verb ("Report") tied to a concrete resource — whether the bound Speechify Library Chromium tab is safe to use by the local worker. That clearly distinguishes it from the item/job CRUD siblings. The only softness is what "safely use" concretely means (session validity, login state, tab liveness).

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 phrasing implies a pre-flight check before other Speechify operations, but the description never states that explicitly, nor does it name an alternative or say when a failure should block subsequent calls. Usage is inferable rather than instructed.

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

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

No annotations are supplied, so the description carries the full burden and delivers nothing: no mention of reversibility, permission requirements, idempotency behavior, or what 'verified' means. For a destructive-named operation this is a critical 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?

It is brief, but brevity here is under-specification rather than economy; the single sentence is grammatically awkward and conveys no actionable content. Nothing is front-loaded because there is nothing to front-load.

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

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

A six-parameter mutation tool with no annotations, no output schema, and zero schema descriptions requires the description to do substantial work, and it does none. An agent could not confidently invoke this tool from the definition 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 six parameters, including a required idempotency_key, an if_exists enum, and expected_updated_at, and the description explains none of them. The agent cannot infer whether item_id or name identifies the target, or how concurrency checks work.

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

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

The phrase 'Perform verified Speechify trash item' essentially restates the tool name with an unexplained qualifier ('verified'). It never states what trashing actually does to an item or how it differs from siblings like speechify_permanently_delete_item or speechify_restore_item.

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

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

There is no when-to-use guidance, no exclusion conditions, and no mention of alternatives, despite a crowded sibling set that includes permanent delete, restore, and move. The agent is left to guess whether trashing is the reversible option.

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 one important trait: completion is asynchronous via a serial uploader, so the call returns before processing finishes. However, it says nothing about idempotency/retry semantics, what on_conflict does on duplicates, what errors surface (e.g. size limit), or what the caller receives back.

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 async completion fact front-loaded in the second sentence; nothing is padded. The only fault is that the terse phrasing ('Persist ... job') borders on jargon rather than plain description.

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 5-parameter mutation tool with no annotations and no output schema, the description omits too much: return value, whether polling is required, duplicate handling, and folder placement. An agent could call it, but it would be guessing about the response and retry 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% across five parameters, so the description must compensate and largely does not. Only 'UTF-8 text' loosely maps to the text field; idempotency_key, folder_id (nullable), and the on_conflict enum (error/skip_identical/rename) are never explained in prose.

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

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

The description says it will 'persist a UTF-8 text upload job,' which identifies the resource as an upload job but uses the vague verb 'persist' rather than stating plainly that it enqueues a text-to-speech upload. It does not distinguish itself from the close sibling speechify_upload_text_files, so an agent must infer which one handles single text versus files.

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

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

There is no explicit when-to-use guidance and no mention of alternatives such as speechify_upload_text_files or the job-status tools. The async note implies the agent should later poll, but it never names speechify_get_job or speechify_session_status, leaving routing 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?

No annotations exist, so the description carries the entire behavioral burden, yet it omits critical traits: whether paths are resolved on the client or server, whether processing is asynchronous and how to poll, what happens on partial failure, and how idempotency_key affects re-submission. 'Persistent serial upload job' hints at queued sequencing but does not explain it.

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 front-loaded sentence with no filler, so it is not bloated. But the brevity comes at the cost of under-specification rather than economy, so it does not earn a high score.

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 batch job-creating tool with four parameters, no annotations, and no output schema, the definition leaves too much unsaid: the return value (presumably a job id) and the follow-up call to check status are never referenced, and conflict/idempotency behavior is undocumented.

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

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

With 0% schema description coverage, the description must compensate, and it only partially does: 'absolute UTF-8 TXT paths' usefully constrains files[].path to absolute UTF-8 text files. Nothing is said about folder_id, the on_conflict enum (error / skip_identical / rename), or the required idempotency_key, all of which remain opaque.

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 concrete resource (UTF-8 TXT files identified by absolute paths) and the outcome (they are staged into an upload job), which separates it reasonably from the singular speechify_upload_text. However, 'prepare ... into a persistent serial upload job' is ambiguous about whether anything is actually transmitted or merely queued, and the word 'prepare' is a weak verb for what is likely a job-creation/upload trigger.

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 choose this over speechify_upload_text (single file) or how it relates to speechify_get_job / speechify_session_status for tracking the resulting job. An agent must infer the batch-vs-single distinction purely from the plural name.

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