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

The description discloses important behaviors: queued/dispatched steps are marked CANCELLED, completed steps are not reversed, and billing only for completed steps. This adds value beyond annotations (idempotentHint true) and does 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 sentences long, front-loaded with the primary purpose, and each sentence provides necessary detail without redundancy. No wasted words.

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

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

Given the presence of an output schema and the tool's simplicity, the description fully covers the cancellation semantics, step handling, and billing impact. It is complete for an AI agent to understand and invoke 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 covers the sole parameter (workflow_id) with 100% description coverage. The description does not add additional meaning beyond the schema, so a 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 clearly states the tool cancels an in-progress workflow, specifies behavior for steps (queued/dispatched marked CANCELLED, completed not reversed), and mentions billing implications. This distinguishes it from sibling tools like submit_workflow or get_workflow_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 implicitly tells when to use (to cancel an in-progress workflow) but does not explicitly mention when not to use or suggest checking status first. It provides clear context without 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 indicate non-readonly, non-destructive, non-idempotent, open world. Description adds cost transparency ('Flat fee $0.05 per file') and hard limit on content length. Could mention error handling or job status.

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

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

Concise, well-structured with no wasted sentences. Front-loaded with purpose, then conditions, then supported formats. Uses bolded limits and alternative tool names.

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 4 parameters fully covered, output schema present, and description providing cost and limits, the tool is fully documented. No missing context for an agent to use 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%, but description adds meaning: explains content can be text or base64 depending on input format, defaults, and the 10k character limit. Only minor gap is no explicit mention of encoding default in description.

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

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

The description uses a specific verb ('offload an inline document conversion') and resource ('Botverse'), distinguishes from sibling tool convert_from_url, and clearly states the tool's 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 states when to use (self-generated content under 10,000 chars), when not to use (longer or external files), and directs to convert_from_url as alternative. Also lists supported input/output formats.

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 are minimal, but the description adds critical behavioral details: async operation (returns job_id immediately), server-side processing, and flat fee of $0.05 per file. 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?

Well-structured with numbered steps and clear sections. Slightly verbose but every sentence adds value including cost and polling instructions.

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?

Comprehensive coverage for an async conversion tool: workflow, supported formats, async pattern, cost, and integration with sibling tools. Output schema exists, so return values are documented separately.

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 covers both parameters with descriptions. The description adds value by listing supported input formats (not in schema) and explaining the workflow context, exceeding baseline for 100% 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?

Clearly states the tool offloads document conversion to Botverse using an already-uploaded file. It specifies the workflow and differentiates from siblings like convert_content and convert_from_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?

Explicitly provides a step-by-step workflow: call get_upload_url, upload file, then convert_file. It also mentions polling get_job_status and get_download_url, and contrasts with convert_from_url for URL-based conversions.

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?

Discloses server-side processing, immediate job return, polling frequency (every 5s), and pricing ($0.05 per file). Annotations (readOnlyHint=false, etc.) are not contradicted; description adds rich behavioral context beyond 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 front-loaded with the main value, then structured logically: when to use, alternatives, supported formats, workflow steps, pricing. No redundant sentences; every sentence serves a 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?

Given that output schema exists (context signal) and annotations are minimal, the description covers all needed context: conversion is async, returns job_id, polling procedure, pricing, supported formats, and input constraints (public URL). Complete for its complexity.

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 baseline 3. Description adds value by clarifying source_url accepts Dropbox, Google Drive, etc. share links, and reiterates output_format enum. This extra context justifies a 4.

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

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

The description clearly states the tool converts a document from a public URL using Botverse, with specific verb 'Offload a document conversion'. It distinguishes from sibling convert_content by specifying when to use each (URL vs. string content). Supported inputs and outputs are listed, making 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?

Explicitly states 'Use this when the source document is at a public URL' and provides counterexample: 'If you already have the content as a string, use convert_content instead.' Also mentions supported formats and workflow steps (polling, download). No ambiguity.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds a key behavioral detail: 'URL expires in 24 hours.' This provides useful context beyond annotations. No contradictions.

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 that front-load the purpose and include a usage guideline and additional detail. No unnecessary words.

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

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

Given the simple tool (one parameter, good annotations, output schema exists), the description covers all needed aspects: what it does, when to call, and an important expiration detail. It is complete for an agent to invoke 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 has 100% coverage with a description for the only parameter ('job_id'). The tool description does not add additional meaning beyond what the schema provides, so 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 clearly states the function: 'Get a presigned HTTPS URL to download the completed output file.' It uses a specific verb ('Get') and resource ('presigned HTTPS URL'), and distinguishes from sibling tools like get_job_status and get_upload_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 explicitly tells when to use the tool: 'Call after get_job_status returns "complete".' This provides clear context, though it does not mention when not to use or alternatives.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds essential polling specifics (5s interval, indefinite loop, expected durations), far exceeding the annotations' baseline.

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 concise sentences, all necessary, no redundancy. The most critical information (purpose and polling behavior) is front-loaded, with no wasted words.

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

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

For a simple polling tool with a single parameter, an existing output schema, and rich annotations, the description fully covers the how (polling mechanics), when (until terminal), and what to expect (status values and timing).

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 job_id, with a clear description of its source (returned by job-creating tools). The description adds no new parameter semantics beyond reinforcing that job_id comes from those tools.

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 'Poll' and resource 'status of a transcode or convert job', clearly distinguishing it from sibling tools that create or manage jobs (e.g., transcode_video, cancel_workflow).

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?

Provides explicit polling instructions: interval (5 seconds), terminal states ('complete' or 'failed'), non-terminal states explanation ('queued'/'processing' normal, 5-15 minutes), and a strong directive to poll indefinitely, not stop early.

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 indicate non-read-only and non-destructive behavior. The description adds useful context: URL expires in 15 minutes, raw bytes upload, and linking to transcode/convert tools. 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 sentences, front-loaded with core purpose. Every sentence adds value: purpose, expiry, post-upload steps. No wasted words.

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

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

Given an output schema (not shown), the description need not explain return values. It covers input parameters, expiry, and follow-up tools. Lacks mention of authentication prerequisites, but that is generally implicit.

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 description does not need to explain parameters fully. It adds example MIME types (e.g., 'video/mp4', 'text/markdown'), which is helpful but not a substantial addition beyond schema definitions.

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

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

The description clearly states the tool gets a presigned PUT URL for uploading any file (video, audio, document). It distinguishes from siblings like get_download_url and explicitly mentions post-upload steps using transcode_video or convert_file.

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 explains when to use the tool (to get an upload URL) and what to do after upload. It implicitly distinguishes from alternatives (e.g., get_download_url for download) but does not provide explicit when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint and idempotentHint. Description adds 'current' implying real-time, but minimal extra behavioral detail.

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, front-loaded, no unnecessary words. Efficient and clear.

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 with output schema, description fully covers purpose and usage context. No gaps.

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

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

No parameters; schema coverage is vacuously 100%. Baseline 4 applies as description need not add param info.

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?

Clearly states verb 'check' and resource 'prepaid wallet balance'. Differentiates from sibling tools by being the only balance-check 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?

Explicitly advises using before large batch jobs to confirm funds. No alternatives or exclusions given, but clear 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?

The description states that each call may advance the workflow by dispatching steps, indicating a side effect, but annotations declare readOnlyHint=true. This is a direct contradiction, making the behavioral disclosure misleading.

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 at two sentences, with the purpose front-loaded and no unnecessary words. Every sentence adds 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?

Given the availability of an output schema, the description provides sufficient context for a typical polling tool, including behavior and termination conditions. It lacks mention of initial statuses but is still fairly 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?

There is one required parameter (workflow_id) with schema coverage of 100%. The description does not add additional meaning beyond the schema's description, so a 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 clearly states the tool retrieves the current status of a workflow and all its steps, using a specific verb 'Get' and resource 'workflow status'. It is easily distinguishable from sibling tools like submit_workflow, cancel_workflow, etc.

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 polling guidance (every 5-10 seconds) and termination conditions (COMPLETED, FAILED, etc.). It explains when to use the tool but does not explicitly discuss when not to use or alternatives, though the context is clear.

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

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

Beyond annotations, the description discloses key behaviors: it returns immediately (non-blocking), requires polling, needs auto-refill, and explains execution semantics (dependency order, parallel branches). This adds significant value 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?

Five sentences cover purpose, execution model, polling, billing, and schema reference. Every sentence adds unique value with no redundancy or fluff. The description is front-loaded with the core 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?

The description covers essential aspects: execution order, parallelism, polling interval, billing prerequisite, and schema reference. It lacks details about error handling or failure modes, but given the idempotentHint and output schema, it is largely sufficient for a competent agent.

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

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

The description adds detailed structural requirements for the 'definition' parameter beyond the schema, specifying that it must include workflow_id and steps with id, tool, and inputs. This helps the agent construct valid input despite nested objects.

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

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

The description clearly states the tool submits a multi-step workflow to the Botverse workflow engine, distinguishing it from sibling tools like cancel_workflow and get_workflow_status. The verb 'submit' and resource 'workflow' are specific and actionable.

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: for multi-step workflows with dependency ordering and parallel branches. It includes practical guidance like polling frequency and billing requirement, but does not explicitly mention when not to use or compare against other workflow-related 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?

The description discloses key behaviors: immediate job_id return, wallet debiting on completion, polling frequency (every 5 seconds), and expected durations for large files. Annotations are minimal but not contradicted; the description adds significant value beyond 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 well-structured and front-loaded with the core purpose, followed by supported sources, limits, and post-invocation steps. It is slightly verbose but 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?

Given the tool's complexity (nested options, polling required), the description covers purpose, usage, parameters, limitations, and follow-up steps thoroughly. The existence of an output schema reduces the need to document return values, making this complete.

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

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

Schema coverage is 100%, but the description adds practical context: how to pass share links without conversion, trimming syntax with examples, and explanations of h264_profile options. This meaningfully supplements 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 clearly states the tool's purpose: to offload video/audio transcoding using a public URL, avoiding an upload step. It distinguishes from siblings like transcode_video (which likely requires upload) by specifying 'no upload step needed.'

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 guides when to use (public URLs from various services, direct HTTPS URLs) and provides detailed polling instructions. It does not explicitly state when not to use, but the context and limitations (2 GB, long processing times) imply appropriate scenarios.

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?

Discloses key behaviors beyond annotations: async processing, immediate job_id return, wallet debit on completion, source constraints. No contradiction with annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=false).

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?

Description is concise with 4 sentences, front-loading the main action. Slightly verbose with polling flow, but overall efficient and structured.

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

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

Covers purpose, constraints, async flow, and side effects. With an output schema (not shown), return values need not be detailed. Lacks failure/error handling info, but still fairly complete for a complex 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?

Input schema has 100% description coverage for all parameters. The description adds no additional semantic detail beyond the schema, so it meets the baseline but does not elevate.

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

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

The description clearly states the tool's purpose: offload video transcoding to a server-side service. It identifies the verb 'transcode' and the resource 'video', and distinguishes from siblings like convert_file or transcode_from_url by emphasizing async execution and specific constraints.

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?

Provides clear usage context: source must be ≤10 min and ≤5 GB, polling instructions, wallet debit. However, does not explicitly mention when to use alternatives like transcode_from_url for URL inputs.

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