transcription

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is known. The description adds valuable behavioral context by explaining the queued dispatch scenario, the fact that a queued dispatch has no transcription, and that an OAuth 2.1 user access token is required. No contradiction with annotations.

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

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

The description is three sentences with no redundancy. The core purpose is front-loaded, followed by parameter selection guidance and a pointer to the list endpoint, then the auth requirement. Every 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?

The description covers the action, parameter selection, how to find valid IDs, and auth requirements. It does not explicitly state that exactly one of the two parameters should be provided (schema shows 0 required), which could lead an agent to call with no arguments, but the overall guidance is sufficient for correct usage in most cases.

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

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

Although the schema already provides short descriptions for both parameters (100% coverage), the description enhances their meaning by explaining why the distinction matters: a queued dispatch has no transcription and is only reachable via dispatch_id. This operational context helps an agent choose the correct parameter in real-world scenarios.

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

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

The description opens with a specific verb and resource: 'Cancel a meeting bot that has not joined yet, so it never joins.' This clearly states what the tool does and the intended outcome. It also distinguishes itself from related tools like stop_meeting_bot by focusing on bots that have not joined, rather than active bots.

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 explicitly explains when to use each parameter: 'Use transcription_id for a scheduled bot that already exists, or dispatch_id for one still queued because every bot was busy.' It also points to list_scheduled_meetings as the source for both identifiers, giving an agent clear guidance on how to invoke the tool.

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

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

The description discloses a critical side effect absent from annotations: 'SPENDS THE ACCOUNT'S LLM CREDITS — every message is billed against them.' It also reveals stateful behavior (conversation_id for continuation) and auth requirements, adding substantial context beyond the annotation flags.

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 concise sentences, front-loaded with purpose and the billing warning. Every sentence carries a distinct operational fact: purpose, cost, when to use, continuation, and auth. 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?

The description covers purpose, cost, usage guidance, continuation, and auth, which is strong for a tool without an output schema. It could mention behavior for invalid or incomplete transcription IDs, but the schema's 'completed transcription id' plus 'get an answer' gives an agent enough to invoke 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 description coverage is 100%, so the schema already documents all three parameters clearly. The description reinforces conversation_id's role ('Pass back the returned conversation_id') but adds no meaningful parameter-level detail beyond what the schema provides.

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

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

States a specific verb and resource: 'Ask a question about an existing transcript and get an answer from the model, with the transcript as context.' This clearly distinguishes it from sibling tools like transcribe_upload, search_transcripts, or export_transcript. The title 'Chat with a transcript' reinforces the function.

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 gives a when-not-to-use condition: 'If you already hold the transcript text, answering directly is cheaper and usually just as good; this is for when you do not.' It also explains how to continue a thread by passing back conversation_id, and notes the OAuth 2.1 token requirement.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description need not repeat those. It adds the API key requirement and specifies the output contents (credit balance, available hours, pricing), which provides useful behavioral context beyond the annotations. It does not describe error handling or response format, but the added info is meaningful.

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

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

The description is a single, efficient sentence. The core action and data ('balance, available hours, and pricing') are front-loaded, followed by the prerequisite. There is no redundant wording or unnecessary explanation.

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 adequately conveys what the tool returns (credit balance, available hours, pricing) and the required authentication key. It does not mention units, error conditions, or usage limits, but for a simple read-only tool with no inputs, this is sufficiently complete for an agent to 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?

The tool has zero parameters, and the input schema is empty. Per the baseline for 0 parameters, a score of 4 is appropriate since the description doesn't need to explain any parameters. It correctly omits parameter details and still informs the agent of the data 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 clearly states the action 'check' and the exact resources: credit balance, available hours, and pricing. This distinguishes it from siblings like get_pricing (which may only cover pricing) and get_billing_history (history of transactions), so an agent can identify the specific purpose without ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_pricing or get_account. The only mention is 'Requires a configured API key', which is a prerequisite, not a usage guideline. There are no exclusions or references to alternative tools, leaving the agent to infer the appropriate context.

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

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

Annotations only convey that this is not read-only, not idempotent, and not destructive. The description adds substantial behavioral detail: a confirmation email is sent, the account is unusable until activation, only the address owner can activate it, and the reply is identical for already-registered addresses. This goes well beyond the structured annotations.

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

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

The description is compact, action-first, and every sentence earns its place. It front-loads the core action and then states the most important behavioral caveats without 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?

The description covers the essential activation flow and duplicate-registration behavior, which are the non-obvious aspects of calling this tool. However, with no output schema, it does not describe the shape or content of the response beyond noting it is identical in both cases. This is a minor gap for a simple 4-parameter creation tool.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description reinforces that email and password are the primary inputs but does not add new meaning beyond what the schema provides for name or agent_attribution.

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

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

The description opens with a specific action verb and resource: 'Create a Scriptivox account from an email address and password.' It also clarifies that no credential is needed, which distinguishes this registration flow from authenticated account-management or API-key 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?

The description gives clear usage context by stating what this tool is for and the key caveat that the account is unusable until the confirmation link is followed. It does not explicitly name sibling alternatives or when-not-to-use cases, but no sibling tool covers account creation, so the context is sufficient.

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?

Beyond the annotations (readOnlyHint=false, etc.), the description discloses critical behavioral details: the secret is returned only once and cannot be retrieved again, and it requires an OAuth 2.1 user access token. This goes beyond what annotations provide and is essential for safe invocation.

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 with zero filler. The key information (once-only secret, OAuth requirement, purpose) is front-loaded and each sentence earns its place. No redundancy.

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

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

For a single-parameter tool with no output schema, the description covers everything an agent needs to know: what it creates, the security caveat, and the auth requirement. It's complete for correct invocation and handling of the result.

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

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

Schema coverage is 100% and the description adds no extra parameter detail beyond what the schema already provides. The field 'name' is well-documented in the schema, and the description doesn't enrich it further. Baseline of 3 is appropriate.

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

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

The description uses a specific verb 'mint' with 'API key' as the resource, specifies the key format (sk_live_...), and states it's for the signed-in person. It clearly distinguishes from revocation tools like revoke_api_key by being the creation counterpart.

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

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

The description explains the tool's role as the bridge from a web account to the transcription API, and mentions the OAuth requirement, providing clear context for when it's needed. It doesn't explicitly mention when not to use it, but the purpose is unambiguous enough for an agent to select it among 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description is consistent with them. It adds context beyond the annotations by naming the segmentation knobs and the required completed status and API key, which clarify the state and auth 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?

Three sentences with no wasted words: purpose, options, and prerequisites are each addressed. The most important information is front-loaded, and nothing from the schema is unnecessarily repeated.

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 export tool with 8 fully documented schema parameters, the description provides the key missing context: output formats, segmentation controls, and required state/auth. It does not spell out the exact response shape, but the format list and read-only annotations make the behavior sufficiently clear for an agent to invoke 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 100%, so the baseline is 3; the description adds a small layer of meaning by grouping `max_words`, `max_chars`, `max_duration`, `sentence_aware`, `include_speakers`, and `strip_chars` as 'segmentation knobs.' It does not explain the parameters in detail, but this grouping helps an agent understand their shared purpose.

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 starts with a specific verb ('Export') and resource ('completed Scriptivox transcript') and names the three concrete output formats (SRT, WebVTT, text). It is clear, but it does not explicitly differentiate itself from siblings like get_transcript_audio, relying on the format list to imply 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?

The description gives explicit prerequisites: the transcription must be in `completed` status and an API key must be configured. This tells an agent when calling is valid, though it does not name alternatives or explicitly say when not to use this tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context beyond annotations: it specifies the exact data scoped to the signed-in person, the fields returned, and the auth requirement. No behavioral contradictions 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 compact sentences with no filler. The core purpose and returned data appear first, followed by the critical auth caveat. Every sentence adds necessary 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 parameterless read-only tool, the description covers purpose, data scope, auth requirement, and expected contents. With read-only annotations already in place and no output schema required, nothing essential is missing.

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

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

The tool has zero parameters, so the schema is empty and no parameter semantics are needed. The description compensates by explaining what the account read returns, which is sufficient for an agent to call the tool correctly.

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 ('Read the account'), names the resource ('signed-in person'), and enumerates the returned data ('current plan, entitlements and quota'). This distinguishes it clearly from siblings like get_pricing, get_product_info, and create_account.

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 clearly states the authorization requirement ('OAuth 2.1 user access token, not an API key'), which is essential for agent invocation. It implies the tool is for the signed-in user's account rather than general product info, though it does not explicitly name alternative tools or when-not-to-use conditions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavioral context by stating that no API key is required, and it does not contradict the annotations.

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

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

The description is compact and front-loaded: it states the purpose first, then enumerates sections, then adds the auth note. Every sentence earns its place, with no redundancy.

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

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

For a simple, side-effect-free documentation tool with one optional parameter, the description plus schema and annotations are nearly sufficient. It does not describe the output format, but the expected return is clearly documentation content.

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

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

Schema coverage is 100%: the single parameter is fully described with an enum and default value. The description repeats the section names but does not add meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb-resource pair, 'Get Scriptivox API documentation,' and enumerates the available sections. This clearly distinguishes it from generic doc tools like get_doc or search_docs.

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 through the section list and the note that no API key is required, but it never explicitly states when to prefer this tool over siblings such as get_doc or search_docs. The context is clear but exclusion guidance is absent.

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

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

The annotations already declare readOnlyHint and idempotentHint, and the description does not contradict them. It adds valuable behavioral context beyond the annotations: the OAuth 2.1 user access token requirement, the polling nature, and the concrete returned fields (status, model, duration, error). This is useful operational detail not present in structured fields.

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

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

The description is compact and front-loaded: purpose, result contents, polling guidance, and auth requirement are each stated in a short, direct sentence. No filler or repetition exists, and every clause contributes to correct tool usage.

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 present, the description adequately explains the return information (overall status plus per-step status, model, duration, and error). It also covers the critical operational context: when to call it, how to call it (polling), and the required auth. For a one-parameter read-only status tool, nothing essential is missing.

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

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

Schema description coverage is 100%, with run_id already documented as 'The run_id returned by run_automation.' The description adds little beyond the schema, only reinforcing the relationship to run_automation. Since the schema carries the semantic weight, the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Check') and identifies the resource ('progress of an automation run'), naming the originating run_automation tool. It clearly distinguishes this from other status tools like transcribe_status by framing it as the automation-run counterpart. The scope is unambiguous and functionally complete.

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

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

The description provides clear context: this tool is used after run_automation, and it instructs the agent to poll it the same way as transcribe_status. It does not explicitly state when not to use it or name alternatives, but the context is enough for correct selection in most cases.

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

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

Annotations already carry readOnlyHint, idempotentHint, and destructiveHint, so the description's 'Read-only — it charges nothing and changes nothing' reinforces but does not contradict them. It adds valuable extras: OAuth 2.1 user access token requirement, Stripe invoice links, supported charge types, and newest-first ordering.

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. The core action and scope are front-loaded, the read-only behavior is stated plainly, and the auth requirement is included in the second sentence 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?

For a simple two-optional-parameter read tool with no output schema, the description covers what the result contains, the ordering, the linking behavior, auth needs, and side-effect safety. Nothing essential is missing for an agent to select and invoke 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?

Input schema coverage is 100%, with both limit and before already documented. The description adds contextual meaning around the result set but does not need to re-explain the parameters, so the baseline 3 is appropriate.

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

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

Description opens with a specific verb-resource pair: 'Read the signed-in person's billing history', then enumerates the exact contents (plan invoices, add-on charges, lifetime purchases, API deposits) and ordering (newest first). This makes it easy to distinguish from siblings like check_balance and get_billing_portal_url even without naming them.

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

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

The description gives clear context for when to call this tool: any time an agent needs the signed-in user's billing history. It does not explicitly name alternative tools or state when not to use it, but the scope is specific enough that an agent can route correctly.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds critical behavioral details beyond these: 'single-use and short-lived', 'does NOT charge anything', and 'does NOT change anything: it returns a link the person must open themselves'. It also discloses the OAuth 2.1 user access token requirement, which is not implied by the annotations.

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

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

The description is concise and well-structured: it leads with the core purpose in the first sentence, immediately clarifies side-effect absence in the second, and wraps up with security/time constraints in the third. Every sentence adds value with no filler, and the most important information 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?

For a tool with no parameters, no output schema, and comprehensive annotations (readOnly, idempotent, non-destructive), the description fully covers what an agent needs: what it returns, its single-use nature, short-lived validity, and auth requirements. There are no gaps that could cause incorrect 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 tool has zero parameters, and the schema coverage is 100% (empty properties). Since there are no parameters to describe, the description adds no parameter-specific semantics, but the baseline for 0 params is 4 per the rubric. The description's focus on the action and constraints is sufficient; there is nothing missing related to parameters.

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

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

The description explicitly states the verb ('Return a link') and the resource ('Stripe billing portal') and clarifies the purpose ('change card, download invoices, cancel subscription'). It distinguishes itself from siblings like purchase_plan (which charges) and get_billing_history (which lists), making the tool's role 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 description gives clear context on when to use the tool (for billing portal access) and notably clarifies that it does NOT charge or change anything, which helps disambiguate from purchase_plan and top_up_balance. It also mentions the OAuth token requirement, guiding on authentication prerequisites. However, it does not explicitly name sibling alternatives or provide conditions for when not to use it beyond its non-destructive nature.

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

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

Annotations already indicate a safe, read-only, idempotent operation. The description adds useful behavioral context: output is markdown, it returns the full page, and no authentication is 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?

Two compact sentences with no filler. The core action is front-loaded, followed by routing guidance and a short auth clarification.

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 read-only tool, the description covers the return format, how to find unknown slugs, index behavior via the schema, and authentication. Nothing essential is missing.

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

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

The schema already documents slug at 100% coverage and even explains how to request the index. The description adds example slugs but does not materially expand beyond the schema.

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

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

States a specific verb and resource: fetches a full Scriptivox documentation page as markdown by slug. Examples and the explicit call-to-search_docs alternative distinguish it from the broader get_api_docs sibling.

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 instructs the agent to call search_docs first when the slug is unknown, which is clear routing guidance. It also notes that no API key is required, removing a common prerequisite question.

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

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

The description adds meaningful behavioral context beyond annotations by stating that no API key is required, which directly affects invocation. It also discloses that signup URLs are included. The annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered; there is no contradiction.

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 concise sentences, with the core purpose front-loaded and the key invocation detail ('No API key required') placed at the end. Every sentence adds value and there is no redundancy with the schema or annotations.

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

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

For a zero-parameter, read-only, idempotent tool, the description provides comprehensive needed context: what data is returned, which plans are included, and authentication requirements. No output schema exists, but the return content is sufficiently described for an agent to invoke the tool and interpret the result.

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

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

The input schema has zero parameters, so the description does not need to explain parameter meaning. The baseline of 4 applies because there are no parameters to document, and the description appropriately focuses on what the tool returns rather than inventing parameter details.

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

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

States a specific verb ('Get') and resource ('Scriptivox pricing information') and enumerates concrete contents: subscription plans (Free, Pro, Team), API pay-as-you-go rates, and signup URLs. This makes the tool's purpose immediately clear and distinct from broader siblings like get_product_info.

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 clear context for when to call the tool ('Get pricing information') and explicitly says 'No API key required,' which is an important usage qualifier. It does not explicitly rule out alternatives such as get_product_info or purchase_plan, but for a simple zero-parameter read tool the guidance is adequate.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds a meaningful behavioral detail beyond annotations: 'No API key required', which informs the agent about authentication requirements.

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

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

The description is one tight sentence that front-loads the operation and resource, then lists topics. Every element earns its place, and there is no redundant 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, read-only tool with one optional enum parameter, the description plus schema and annotations cover everything needed to call it: what it does, which topics are valid, and that no API key is required. No output schema exists, but the tool's purpose does not demand detailed return documentation.

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

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

Schema description coverage is 100%, and the single 'topic' parameter is fully documented with an enum and default. The description repeats the topic list but adds no deeper semantic meaning beyond what the schema already provides, so it meets the baseline but does not exceed 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: 'Get information about Scriptivox capabilities' and enumerates the exact topics covered. It is clear enough to distinguish from siblings like get_pricing or get_api_docs, though it does not explicitly name those alternatives.

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

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

The intended use is implied by the topic list—use this tool when you need capability info about transcription, audio tools, etc. However, it does not explicitly state when to prefer this over related siblings like get_api_docs or get_pricing, and it offers no exclusions.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering safety and side-effect expectations. The description adds valuable behavioral context beyond annotations: it explicitly states 'No API key required' and specifies the return format (names and ISO codes). This enhances transparency without contradicting any annotation.

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 concise sentences: the first states the action and resource, the second covers return content and authentication. Every word earns its place, with no fluff or redundant restatement of the tool name or title. It is front-loaded with the primary purpose.

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

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

For a zero-parameter, read-only informational tool, the description is fully complete. It covers what the tool does, what it returns, and the authentication requirement. Since there is no output schema, explaining the return content is essential, and it does so clearly. No missing details 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 tool takes zero parameters, so there is nothing to explain beyond the schema. With schema description coverage at 100% (trivially), the baseline for zero parameters is 4. The description doesn't need to add parameter info and correctly focuses on return values and authentication.

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 begins with a specific verb ('List') and resource ('all languages supported by Scriptivox for audio/video transcription'), followed by the return content ('language names and ISO codes'). This clearly distinguishes it from sibling tools like transcribe_url or get_pricing, with no ambiguity about its function.

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 clearly states the tool's purpose, making it obvious when to use it (e.g., when needing to know supported languages for transcription). While it doesn't explicitly name alternatives or exclusions, the simplicity of the tool and its distinct resource make the usage context clear. No misleading guidance is present.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds substantial behavioral context: the URL is valid for one hour, supports HTTP Range requests, costs nothing, and requires an OAuth 2.1 user access token. This is valuable information beyond the structured annotations.

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

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

Three sentences, each earning its place: the first states the action and output, the second adds validity and HTTP behavior, and the third clarifies cost, read-only nature, and auth. Fully front-loaded with no redundancy.

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

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

For a single-parameter, read-only tool with no output schema, the description is complete. It describes the return value (signed URL), its validity, supported HTTP behavior, intended use, and authentication requirement. No critical calling information is missing.

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

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

Schema description coverage is 100% for the only parameter, transcription_id, described as a UUID. The description does not add additional parameter-level meaning, but it doesn't need to since the schema already fully documents it. Baseline 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Return a time-limited signed URL for the source audio or video of an existing transcription.' It clearly differentiates from transcription-creation siblings by stating 'it does not transcribe anything,' making the tool's purpose 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?

It gives clear context for when to use the tool: when the media URL is needed to be handed to another tool or streamed. It implicitly excludes transcription creation by saying it reads back existing media and does not transcribe, but it does not explicitly name alternative tools or provide a when-not-to-use statement.

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

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

Annotations already convey read-only, idempotent, non-destructive behavior. The description adds real value beyond those annotations by specifying the OAuth 2.1 user access token requirement and the 'signed-in person's account' scope, which are not expressed in the annotations.

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

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

Three tight, purposeful sentences. The core action is front-loaded, the definition of automations earns its place, and the read-only/no-create note plus auth requirement are each materially useful without adding clutter.

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

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

For a zero-parameter, read-only list tool with rich annotations, this description is complete: it defines the resource, scope, auth requirement, and side-effect profile. No output schema exists, but 'List the automations' sufficiently implies the returned content.

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 and the schema is empty, so the baseline for parameter semantics is 4. The description correctly adds no parameter details that would be redundant with the schema.

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

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

States a specific verb ('List') and resource ('automations on the signed-in person's account'), and defines what an automation is ('saved chains of steps'). This distinguishes it from sibling tools like run_automation and get_automation_run without needing to open their schemas.

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

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

The description gives clear context: it is read-only and scoped to the signed-in person's automations. It also explicitly notes that no create/edit counterpart exists, preventing an agent from searching for one, though it doesn't explicitly name alternative tools like run_automation for execution use cases.

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

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

Annotations already provide read-only, idempotent, and non-destructive hints; the description adds the OAuth 2.1 user token requirement and that results include workspace association. It doesn't contradict annotations, though it could go slightly deeper on edge cases like empty or shared-folder visibility.

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 tight and front-loaded, with the core purpose first and supporting usage context after. 'Read-only' is redundant with the annotation, but the note about no folder-creation tool and the OAuth requirement adds meaningful 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?

For a zero-parameter, read-only list tool with no output schema, the description covers what it returns, why an agent should call it, the auth prerequisite, and the explicit absence of a folder-creation counterpart. Nothing essential is missing 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 tool has zero parameters, so the schema is fully covered and no parameter details are needed. The description appropriately focuses on behavior and output rather than inventing parameter 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?

The description states a specific verb ('List'), a clear resource ('folders'), and the scope ('signed-in person's account'), while also noting the result includes each folder's workspace. It explicitly ties the tool to move_to_folder, which differentiates it from sibling list tools like list_workspaces.

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 tells the agent exactly when to use this tool: to find the folder_id that move_to_folder needs. It also clarifies that no folder-creation tool exists and states the OAuth 2.1 user access token requirement, giving clear selection and prerequisite guidance.

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

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

Annotations already provide readOnlyHint=true and idempotentHint=true, and the description reinforces read-only behavior. It adds new context by specifying the OAuth 2.1 user access token requirement, which is not captured in annotations. The description also clarifies the scope (scheduled, running, queued dispatches), adding value beyond the structured metadata. No contradiction 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 three sentences with no redundancy. It front-loads the primary purpose, then provides the critical usage context (source of IDs), and ends with read-only and auth notes. Every sentence earns its place, and the structure is efficient for an agent to parse quickly.

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

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

For a zero-parameter, read-only listing tool with rich annotations, the description fully covers what the tool does, what it returns (the list of bots and dispatches), and the auth requirement. The output schema is absent, but the description adequately implies the return shape. No missing information prevents 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 tool has zero parameters, so the baseline is 4 per the rubric. The description does not need to explain parameters, and the schema correctly shows an empty properties object. No parameter semantics are required.

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: 'List the signed-in person's meeting bots that are scheduled or currently running, plus any dispatches still queued waiting for a free bot.' It clearly differentiates from siblings by stating it is the source of identifiers (transcription_id, job_id, dispatch_id) needed by stop_meeting_bot and cancel_scheduled_bot, making its purpose 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 description explicitly indicates when to use this tool: to obtain the IDs required by stop_meeting_bot and cancel_scheduled_bot. It also notes the tool is read-only. However, it does not explicitly state when not to use it or mention alternative tools for other scenarios, though the naming of consuming siblings provides strong context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, and the description reinforces this with 'Read-only.' It adds valuable behavior beyond annotations: the two tag sets 'are not kept in step by the product, so both are returned,' plus the OAuth 2.1 user token requirement and the 5-tag limit per transcription.

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 slightly dense but every sentence earns its place: it defines the account scope, the two returned categories, the product caveat, the tag model, and auth requirements. No filler or duplication of schema data.

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 adequately prefaces what is returned: in-use tags with counts and the named-tag registry separately. It also covers account scoping, authentication, and the 5-tag constraint, so an agent has enough context to invoke the tool 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?

The tool has zero parameters, so the schema provides complete coverage and the baseline is 4. The description provides no parameter-specific detail because none is needed; the call is effectively parameterless.

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 verb and resource: listing tags on the signed-in person's account. It clearly distinguishes the two tag categories — tags in use on transcriptions with counts, and the separately maintained named-tag registry — which differentiates this from sibling tools like list_transcriptions and tag_transcriptions.

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 makes the tool's scope and read-only nature clear, so an agent knows when to call it for tag information. It does not explicitly name an alternative for mutating tags, but the context is unambiguous enough for 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?

Beyond the readOnly/idempotent/non-destructive annotations, the description discloses an auth prerequisite ('Requires a configured API key') and a non-obvious response trait ('The full transcript body is omitted'). These are meaningful behavioral constraints that shape whether an agent should call this tool to get content, and there is no contradiction with the annotations.

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

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

Three short sentences, all informative: purpose/features, body-omission warning and alternative, and prerequisite. There is no filler, and the most important scoping information 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?

For a six-parameter list tool without an output schema, the description covers scope, filters, pagination, auth, and the body/alternative. It stops short of naming the exact response envelope or cursor field name, but the cursor-pagination mention plus the schema's cursor/limit definitions make the contract sufficiently clear.

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

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

Schema description coverage is 100%, so all six parameters are already documented. The description's 'status/date filters and cursor pagination' groups the parameters into use cases but does not add substantial semantic detail beyond the schema's own field descriptions, so the baseline of 3 is appropriate.

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

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

The first sentence states an exact operation ('List') and resource ('transcriptions') plus scope ('for the configured API key'). It also signals key behaviors—status/date filters and cursor pagination—and by saying the full body is omitted, it differentiates the tool from content-reading endpoints such as transcribe_status.

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 clear context: use this to enumerate transcriptions with date/status filters and pagination, and it explicitly routes full-body reads to transcribe_status. It does not fully spell out when list_transcriptions should be preferred over search_transcripts or other sibling list tools, but the explicit alternative and optional filters cover the main routing decision.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description reinforces this with 'Read-only' and adds the authentication requirement and the hierarchical relationship of tags/folders/transcriptions. It adds value beyond the annotations by clarifying the data model and access prerequisites, with no contradiction.

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 concise sentences with no fluff. The main purpose is front-loaded, and the additional context about hierarchy and authentication is efficiently stated. Every 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 simple list operation with zero parameters and an existing annotation profile, the description covers the essential context: what it lists, that it is read-only, and authentication requirements. It does not describe the return format or pagination, but for a tool with no parameters and no output schema, this is not a critical gap. It is adequately 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?

This tool takes zero parameters, so the schema fully documents the absence of parameters. The description does not need to add further parameter semantics; its mention of 'the signed-in person's workspaces' implicitly defines the scope based on authentication. The baseline for 0 parameters is 4, which is appropriate.

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

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

The description clearly states the verb 'List' and the resource 'workspaces' for the signed-in person. It also differentiates the tool by noting it is the outermost level of the library, which distinguishes it from sibling tools like list_folders and list_transcriptions.

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

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

The description provides context on when to use this tool: it is the top-level container for tags, folders, and transcriptions. It also mentions the authentication requirement (OAuth 2.1 user access token). However, it does not explicitly state when not to use it or name alternatives, though the hierarchy explanation implies that nested resources would use other list tools.

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?

Beyond annotations, the description discloses an auth requirement (OAuth 2.1 user access token), ownership restrictions on the folder, and precise limit behavior ('more than 50 ids is refused, not truncated'). These add real context beyond the readOnly/destructive hints.

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, each carrying necessary information. Primary action is first, then edge-case behavior, then constraints. 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 two-parameter mutation with no output schema, the description covers purpose, null behavior, prerequisites, id limit, and auth. The only minor omission is a statement about the response shape, but annotations and the simple operation make this acceptable.

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

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

Schema coverage is 100% and includes the null-to-remove and at-most-50 semantics. The description adds one extra constraint: the folder must already exist and belong to the signed-in user, which is a meaningful validation rule for folder_id not present in the schema.

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

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

The description opens with a specific action and resource: 'File up to 50 existing transcriptions into a folder.' It also clarifies the second mode, moving them out via folder_id null, which makes the scope unmistakable. No sibling tool performs this action, so there is no confusion with alternatives.

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

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

It gives a prerequisite ('folder must already exist and belong to the signed-in person') and directs the agent to list_folders for valid ids, which is concrete guidance on preparation. It doesn't explicitly name an alternative tool or say when not to use it, but no sibling overlaps with this operation, so the context is sufficient.

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

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

The description adds important behavioral details beyond the annotations: it 'Does NOT charge anything' and clarifies the user must complete payment by opening the link. It also states the auth requirement. This meaningfully supplements the basic readOnlyHint/idempotentHint flags without contradicting them.

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

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

Three tightly written sentences deliver the action, the key safety clarification, the product scope, and the auth requirement. Every sentence contributes necessary information and the most important caveat 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?

For a simple one-parameter tool, the description covers what the tool does, what it returns, the auth requirement, and the crucial 'no charge' behavior. It does not mention possible errors or edge cases, but given the low complexity and presence of the enum schema, this is a minor 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 schema already documents the single required parameter with an enum and a description. The description adds context about what a web plan is and that it excludes API credit, but it does not explain the difference between 'monthly', 'yearly', and 'team' beyond the schema. This meets the baseline for high schema coverage.

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

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

The description opens with a specific verb and resource: 'Start checkout for a Scriptivox web subscription and return a Stripe Checkout URL.' It clearly identifies what the tool does, what it returns, and separates it from related billing and account 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?

The context for use is clear: it is for purchasing a web subscription via Stripe Checkout, and it notes the OAuth 2.1 user access token requirement. It does not explicitly name alternatives or exclusion conditions, but the product scoping ('grants no API credit') helps an agent distinguish when this is the wrong tool.

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

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

Annotations already declare destructiveHint and idempotentHint, so the description need not repeat those. It adds value by explicitly stating the revocation is permanent, cannot be undone, and requires a specific OAuth token type, which goes beyond the structured annotations without contradicting them.

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 deliver the purpose, irreversibility, and auth requirement with no filler or repetition. The key action is front-loaded, and every 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 simple one-parameter mutation with annotations covering idempotency and destructiveness, the description covers purpose, scope, permanence, and auth requirements. A minor gap is that no return value or success confirmation is described, but this is not critical for such a focused 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 coverage for the single parameter is 100%, with key_id already described as 'not the secret.' The description adds no additional parameter-level detail, so the baseline of 3 applies because the schema fully handles parameter 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?

The description states a specific verb ('revoke'), a precise resource ('API key'), and a clear scope ('belonging to the signed-in person'). This clearly distinguishes it from related tools like create_api_key without needing to open 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?

The description implies usage context by noting irreversibility and requiring an OAuth 2.1 user access token, but it does not explicitly state when to use this tool versus alternatives such as create_api_key or any conditions for not using it. The guidance is present but left to inference.

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

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

Annotations only indicate readOnly=false, openWorldHint=true, non-idempotent, and non-destructive. The description adds meaningful behavioral detail beyond this: it spends LLM credits, returns immediately while running asynchronously, requires polling, suppresses duplicate re-runs, and requires OAuth 2.1. The duplicate-suppression note does not contradict the general idempotentHint=false caution because it describes a specific narrow same-input case rather than claiming full idempotency.

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

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

Four dense sentences front-load the core action and immediately warn about credit consumption. Every sentence contributes necessary operational information, and the polling instruction is especially valuable for an async 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?

For a side-effecting, long-running tool with no output schema, the description covers the required inputs and their source, the return identifier, the polling lifecycle, duplicate suppression, and the auth requirement. Minor omissions such as specific error responses do not undermine an agent's ability to invoke and monitor the tool 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?

The schema already provides 100% coverage of both parameters, including that automation_id comes from list_automations and that transcription_id must be a completed transcription. The description largely restates these constraints rather than adding deeper parameter-level details, so the baseline score of 3 is appropriate.

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

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

The description names the exact operation ('Run one of the signed-in person's existing automations') and the specific resource it acts on ('one completed transcription'). It clearly distinguishes itself from related siblings like get_automation_run and list_automations by explaining that this tool initiates execution and returns a run_id immediately.

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

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

It gives clear context for when to use the tool: run an existing automation over a completed transcription, requiring a user token and spending credits. It also explicitly instructs the agent to poll get_automation_run until succeeded or failed, which effectively defines the follow-up tool. It stops short of explicitly listing exclusions or when-not-to-use cases, so it is not a full 5.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds useful extras: results are sorted best-match-first and no API key is required, neither of which is encoded in the schema or annotations.

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

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

Three sentences with no filler: purpose, return behavior, and usage guidance are each covered once. The most decision-relevant information 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?

The tool is simple, parameters are fully documented in the schema, annotations cover safety, and the description covers return content and ordering despite no output schema. Nothing needed to select or invoke the tool is missing.

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

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

Schema description coverage is 100%, and the schema already documents query as natural language and limit with default/max. The description does not add deeper parameter semantics, so the baseline of 3 applies.

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

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

The description opens with a specific verb and resource ('Search the Scriptivox documentation and agent guides') and states the output shape ('matching documents with their URLs and summaries, best match first'). This clearly distinguishes it from siblings like get_doc or get_api_docs, which retrieve specific known documents.

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

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

It gives an explicit use context: 'Use this before guessing a URL.' That tells an agent when to prefer this tool, though it does not explicitly contrast with get_doc or get_api_docs when the document is already known.

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?

Beyond the annotations, the description adds that this operates on the signed-in person's library, returns results newest first, is read-only, and requires an OAuth 2.1 user access token. This is valuable context about data scope, ordering, and authentication that is not present in the annotations or schema.

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

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

The description is information-dense but efficient: purpose and filters are front-loaded, followed by practical routing guidance, a sibling distinction, and the auth requirement. Every sentence earns its place and no content is redundant with the schema or annotations.

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

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

Given the full schema coverage, the read-only/idempotent annotations, and the explicit note that the returned transcription IDs feed several sibling tools, the description covers everything an agent needs to select and call this tool correctly. The absence of an output schema is mitigated by the clear statement that this is the source for transcription IDs and by the mention of newest-first ordering.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions the filter categories ('folder, tag, workspace, status or filename') but does not add meaning beyond what the schema already provides for each parameter. It correctly implies the query parameter matches filenames, but the schema already says this.

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

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

The description uses a specific verb and resource: 'Find transcripts in the signed-in person's library,' and enumerates the filtering dimensions. It also explicitly differentiates itself from list_transcriptions by stating what that sibling does instead. This leaves no ambiguity about the tool's 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?

It explicitly says this is where transcription IDs for several named sibling tools should come from ('start here'), giving concrete when-to-use guidance. It also provides a when-not-to-use case by explaining that list_transcriptions is a different API-key-based operation for metered jobs.

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

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

Annotations only mark readOnly/idempotent/destructive as false; the description adds the important behavioral facts: the result is asynchronous, it consumes meeting minutes, it is rate limited to 5 bots/hour, and OAuth 2.1 user auth is required. No contradiction with annotations.

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

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

Five short sentences each carry distinct value: what it does, uniqueness/single-URL limit, minutes consumption, async follow-up, and auth. It is front-loaded with the core action and contains 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 creation tool with no output schema, it covers platforms, side effects, rate limiting, auth, the async nature of the result, and the tracking path. An agent has enough information to invoke it correctly and understand what to expect.

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

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

Schema description coverage is 100%, so the schema already documents title, language, meeting_url, and scheduled_time with descriptions. The description mostly reinforces the single-URL constraint already present in the schema and does not add parameter-level semantics beyond 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 opens with a precise verb and resource: 'Send a bot to join ONE Zoom, Google Meet, Teams or Webex call and record it, producing a speaker-attributed transcript after the call ends.' This clearly distinguishes it from the many list/status/cancel siblings as the active meeting-bot creation tool.

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

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

It explicitly says when to use it ('the only tool here that creates new transcription work'), what it does not accept ('never a list'), and what to do next ('track it with list_scheduled_meetings'). Rate limits and account-minute consumption add decision-relevant constraints beyond the schema.

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?

Beyond annotations that mark destructive/idempotent behavior, the description clarifies the exact consequence: recording stops but recorded content is still processed. It also states the auth requirement (OAuth 2.1 user access token), which is context the schema/annotations don't provide. No contradiction with annotations.

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

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

Three short sentences, each earning its place: action + non-destructive nuance, source of identifiers, and auth requirement. Key behavioral detail 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?

For a two-parameter action with annotations and no output schema, the description covers behavior, identifier provenance, and auth. The only small gap is not explicitly stating that exactly one of job_id/transcription_id must be supplied, despite the either/or wording.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explaining the two identifiers are alternatives and that they come from list_scheduled_meetings, which the bare schema doesn't convey. It doesn't fully specify exclusivity/requiredness, hence not a 5.

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

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

The description opens with a specific action ('Tell a meeting bot ... to leave') and clearly identifies the resource (bot currently in a call), which distinguishes it from siblings like start_meeting_bot and cancel_scheduled_bot. The scope is unambiguous: a live call, not a scheduled 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 specifies the target state ('currently in a call') and tells the agent where to get the identifiers (list_scheduled_meetings). It doesn't explicitly name sibling alternatives or exclusions, but the 'currently in a call' condition makes the use case clear enough.

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

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

The description goes well beyond the annotations by disclosing tag creation on first use, the 5-tag-per-transcription cap with skip behavior, rejection of more than 10 IDs, and the required OAuth 2.1 user access token. These are exactly the behavioral details an agent needs and that annotations do not provide.

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?

Every sentence in the description earns its place: the core operation, the motivating use case, character/tag limits, overflow behavior, and authentication requirement. The most critical information is front-loaded without unnecessary fluff.

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 relatively simple two-parameter batch operation, the description covers prerequisites, input constraints, behavioral edge cases, and authentication. No essential information is missing for selecting and invoking the tool correctly, even though there is no output schema.

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

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

Even though schema coverage is 100%, the description adds meaningful parameter-related semantics: tags are created if absent, a transcription can hold at most 5 tags with further tags skipped, and passing more than 10 IDs causes refusal rather than truncation. This adds real behavior beyond the schema's basic constraints.

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 action—adding tags to existing transcriptions—and includes a concrete use case. It clearly distinguishes itself from read-only sibling tools like list_tags and list_transcriptions by emphasizing the mutating batch operation on up to 10 transcriptions.

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 clear context for when to use this tool ('label these interviews as Q3') and explains that tags need not pre-exist. It does not explicitly name alternatives or exclusion conditions, so it falls just short of a perfect score.

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

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

Goes beyond annotations by explicitly stating that this operation does NOT charge anything and that the user must open the returned link to complete payment. It also discloses the OAuth 2.1 user token requirement and notes the per-hour billing context, giving the agent important behavioral and auth information.

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 core action and output, followed by essential clarifications. The pricing detail is slightly tangential but still useful context; overall there is no wasted wording.

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

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

For a simple one-parameter tool, the description covers the action, the returned value, the fact that no charge occurs until the link is opened, and the auth requirement. No critical information is missing for an agent to invoke 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 100%, and the sole parameter amount_cents is already documented as 'Amount to add, in US cents. A project minimum applies.' The description reinforces the purpose but does not add substantial new parameter-level detail beyond the schema.

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

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

States a specific action ('Start checkout to add credit') and the output ('return a Stripe Checkout URL'). The resource (prepaid API balance) is named, and the tool is clearly differentiated from siblings like check_balance and get_billing_portal_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?

The description clearly conveys when to use the tool: when adding credit to the prepaid balance and initiating a Stripe checkout. It also clarifies the expected flow ('the person must open the link'), though it does not explicitly name alternatives or state when not to use it.

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

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

Annotations already declare idempotentHint and destructiveHint, but the description adds specific behaviors: releasing reserved balance, returning 409 CONFLICT on already-terminal jobs, and requiring a configured API key. These are valuable beyond the annotations and do not contradict them.

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 three concise sentences, front-loaded with the core action and purpose. Every sentence adds distinct value (action, idempotency, error case, requirement), with no redundancy or 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 cancel operation, the description covers the key facets: what it does, idempotency, error handling (409), and setup requirement (API key). It does not explain the response format, but since there is no output schema and the tool is straightforward, this is not a significant 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 coverage is 100% and the parameter transcription_id is described as 'The transcription ID to cancel (UUID).' The description does not add further parameter-level details, but with full schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the action (cancel) and the resource (in-flight Scriptivox transcription), and adds the side effect of releasing reserved balance. It distinguishes from siblings like transcribe_delete, which handles deletion of completed transcriptions, by specifying 'in-flight'.

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 the tool is for in-flight transcriptions and mentions idempotency and 409 on already-terminal jobs, which gives context on when it's appropriate. However, it does not explicitly state when not to use it or mention alternatives like transcribe_delete or stop_meeting_bot.

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

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

Annotations already provide idempotentHint=true and destructiveHint=true, but the description adds valuable detail: it specifies 'soft-delete' (implying recoverability), the 409 CONFLICT error when in-flight, and the need to cancel first. These go beyond the annotations and help the agent predict behavior. Could be a 5, but it doesn't describe success return or error payloads, so a 4 is appropriate.

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

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

Two sentences, with the core action front-loaded, followed by key behaviors (idempotent, conflict case, API key). No wasted words; every clause earns its place.

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

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

For a delete operation with no output schema, the description covers the essential behavior: soft-delete, idempotency, conflict handling, and authentication. It does not state the expected success response (e.g., 200, 204), but this is a minor gap given the tool is a simple delete. Overall it provides enough for an agent to 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 description coverage is 100%, so the single parameter 'transcription_id' is already fully documented as 'The transcription ID to delete (UUID).' The description adds no further parameter-specific guidance (e.g., format, validation). Baseline 3 is correct because the schema already does the heavy lifting.

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 ('soft-delete') and resource ('Scriptivox transcription record'), clearly distinguishing it from siblings like transcribe_cancel and transcribe_status. It also communicates the idempotent nature, which further clarifies its purpose.

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 explicitly tells the agent when not to use it: if the job is in-flight, cancel first via transcribe_cancel. It also mentions the API key requirement, which is a prerequisite for using the tool. No ambiguity remains about the intended use case.

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

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

Annotations already indicate this is read-only, idempotent, and non-destructive. The description adds useful behavioral context beyond those annotations, including that it is meant for polling long-running jobs and that a configured API key is required, which helps the agent understand the operational context.

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

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

Two sentences with no filler. The primary action is front-loaded, followed by concrete use cases and a necessary auth prerequisite. Every 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 single-parameter read-only status check, the description is complete enough: it identifies the input, the situations to call it, and the auth requirement. It does not describe the exact shape of status responses, but with no output schema and a simple operation, an agent has sufficient guidance to invoke 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?

The input schema already provides 100% coverage for the single parameter, describing transcription_id as returned from transcribe_url or transcribe_upload. The tool description adds no additional parameter-level meaning, so the schema carries the full burden and the baseline of 3 is appropriate.

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

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

The description states a clear action ('Check the status') and a specific resource ('a Scriptivox transcription job'). It does not explicitly differentiate from the similarly named sibling 'transcription_status', so it loses the top point, but the core purpose is immediately understandable.

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 explicit conditions for use: long-running transcriptions, after a timeout, or to verify completion. It does not mention when not to use it or name alternatives, so it stops short of full routing guidance.

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

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

Annotations already mark this as non-read-only and non-destructive; the description adds the filesystem-access limitation, a 5 GB max file size, and the configured API-key requirement. It does not contradict the annotations, though it leaves longer-running/asynchronous outcomes to the await_completed parameter rather than stating them up front.

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 compact and front-loaded: the core purpose and the most important warning appear in the first sentence, followed by actionable alternatives and constraints. Every sentence earns its place and there is no filler.

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

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

For an 8-parameter upload tool, the description plus schema provide nearly everything: local-only constraint, max size, auth, alternatives, and parameter semantics. It stops just short of fully explaining the return/result shape and the potential long-running nature of the operation, which would be especially useful given there is no output schema.

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

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

The schema covers all 8 parameters, so the baseline is 3; the description goes further by adding the 5 GB file-size ceiling and emphasizing that file_path must be a local file visible to the server. This is material constraint information not present in the schema.

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

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

The description names the exact operation and target: 'Transcribe a LOCAL file by uploading it to Scriptivox.' The explicit contrast with transcribe_url immediately distinguishes this tool from its closest sibling.

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 states the key exclusion ('NOT AVAILABLE over the hosted MCP endpoint: this server has no access to your filesystem'), then gives the concrete alternatives: transcribe_url, running the server locally over stdio, or the REST upload flow. It also states the API-key prerequisite, so an agent knows exactly when this tool is usable.

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

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

Annotations already mark readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false; the description adds beyond these by disclosing an auth requirement ('Requires a configured API key') and a known failure mode of auto-detection. It does not contradict annotations, and the added context helps agents anticipate edge cases even though side effects like cost are not mentioned.

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?

Four sentences, each earning its place: purpose, capabilities, parameter recommendation with rationale, and prerequisite. The recommendation is front-loaded in a clearly highlighted RECOMMENDED block, and there is no filler or repetition of schema 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?

The description conveys the core operation and a key usage caveat, but with no output schema it omits the return value and the async/polling behavior implied by await_completed and webhook_url. It also does not mention that transcription can be long-running or that webhook events will be delivered. This leaves an agent partially uninformed about what to expect after calling the tool.

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

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

Schema coverage is 100%, establishing a baseline of 3. The description adds value beyond the schema by recommending the language parameter explicitly and explaining the failure conditions that justify it. It also ties top-level features (diarization, word-level timestamps) to the relevant parameters, giving agents extra semantic anchoring.

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

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

The description opens with a specific verb and resource: 'Transcribe audio or video from a public URL using Scriptivox AI.' This clearly distinguishes it from sibling transcribe_upload (local file upload) and transcription_url (URL retrieval) by emphasizing the public-URL input. The feature summary (119 languages, diarization, timestamps) reinforces scope.

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

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

The description gives concrete guidance on when to pass the language parameter explicitly, noting auto-detect failure on short clips, code-switched audio, and music-leading files. It also states the API key requirement. It does not explicitly contrast with alternatives (e.g., when to prefer transcribe_upload), but the public-URL wording and parameter guidance supply clear usable context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds deprecation context and the fact that it is a backward-compatibility alias, which goes beyond the annotations. It does not add details about return format or pagination, but for a deprecated alias that is identical to a sibling, this is reasonable. The description adds useful behavioral context without contradicting the annotations.

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

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

The description is brief and front-loads the deprecation warning, which is the most actionable information. However, there is slight redundancy: 'Alias kept for backward compatibility' and 'Identical behavior to transcribe_status' convey overlapping information. Still, it is efficient overall, with no unnecessary filler or excessive 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 simple one-parameter tool with annotations covering safety and no output schema, the description is complete. It tells the agent the tool is deprecated, points to the replacement, and states it behaves identically. There is no missing information that an agent needs to decide whether to use this tool, and the low complexity means fewer gaps to fill.

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

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

The schema provides 100% coverage for the single parameter, transcription_id, with a clear description ('The transcription ID (UUID).'). The description does not add any parameter-specific information, but it is not needed given the full schema coverage. The baseline of 3 applies because the schema already carries the parameter meaning, and the description does not need 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?

The description clearly identifies the tool as a deprecated alias for transcribe_status, and states 'Identical behavior to transcribe_status.' This makes the purpose unambiguous to anyone familiar with the sibling, but it does not explicitly state the action (e.g., 'get transcription status') in its own right. It distinguishes itself from the active tool and other siblings by pointing to the replacement, so it is clear what it is not, but the actual function is implied rather than stated outright.

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

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

The description explicitly instructs to use 'transcribe_status instead' and notes the deprecation timeline ('Will be removed in 2.0.0'). This gives clear when-to-use and when-not-to-use guidance, and names the alternative directly. There is no ambiguity about which tool should be selected.

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

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

The description adds lifecycle behavior: deprecation, backward-compatibility scope, and removal version. However, it delegates all runtime behavior to transcribe_url and does not disclose side effects, return behavior, or async characteristics beyond what the schema hints at.

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 that leads with the deprecation warning and alternative before explaining compatibility and removal. Every clause earns its place with no redundancy.

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

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

For a deprecated alias, pointing to transcribe_url and covering all parameters via schema is largely sufficient. Still, with no output schema and no mention of return values or event behavior, an agent encountering this tool alone would need to inspect transcribe_url for complete operational 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 100%, so the parameters are already fully documented. The description adds no parameter-level semantics, which is acceptable but not helpful beyond the baseline.

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 immediately identifies the tool as a deprecated alias for transcribe_url and states 'Identical behavior to transcribe_url', which establishes the action and resource by reference. The annotation title 'Transcribe from URL' adds basic purpose, though actual behavior is not independently described.

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 explicitly says to use transcribe_url instead, marks the tool as deprecated, and states removal plans. This is unambiguous when-to-use versus when-not-to-use guidance, with the alternative named directly.

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