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

With no annotations provided, the description carries the full burden of transparency. It only states 'Check the status of export jobs' without disclosing whether the operation is read-only, what statuses are returned, or any side effects. This is a clear gap for an API tool.

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

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

The description is a single, concise sentence with no filler words. It is appropriately sized for a simple status-check tool, though it could be slightly more informative without sacrificing brevity.

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 lacks an output schema, so the description should explain what 'status' means (e.g., possible values, whether it's a snapshot or poll). It also fails to mention how this fits with sibling tools like annotation_export, leaving the agent without enough context to invoke it correctly in a workflow.

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 100% coverage for both parameters (project_id and export_ids), each with a description. The tool description adds no additional meaning beyond the schema, so the baseline score 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 'Check the status of export jobs' uses a specific verb ('check') and resource ('export jobs'), clearly conveying the tool's function. It is distinguished from siblings like annotation_export (which creates exports) and annotation_download_export (which downloads them), though it doesn't explicitly mention the project_id scope that appears in the schema.

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

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

No guidance is provided on when to use this tool versus alternatives such as monitor_job_status or annotation_export. The description is a standalone statement without any context about typical workflows (e.g., after starting an export) or exclusions.

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

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

With no annotations provided, the description must carry the full burden of disclosing behavior. It only states that it retrieves a download URL, but does not explain what happens if the export is not completed, whether the URL expires, or if any authentication is required. This is a significant gap for a tool that depends on a prior async export process.

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

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

The description is a single, front-loaded sentence that conveys the core purpose with zero wasted words. It is appropriately concise for a simple read-only operation.

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

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

The tool has a simple two-parameter input and no output schema. The description mentions the return value ('download URL') and the precondition ('completed export'), but it lacks details on error behavior, URL validity, or workflow sequencing with sibling tools. It is adequate for a straightforward tool but with clear gaps.

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

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

The schema provides 100% coverage for both parameters (export_id and project_id), but the descriptions are minimal ('ID of the export', 'ID of the project'). The tool description adds no extra context about parameter relationships or formatting. Baseline 3 applies because the schema already documents the parameters adequately.

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 a specific action ('Get download URL') on a specific resource ('completed export'). It distinguishes from siblings like 'annotation_export' (which creates exports) and 'annotation_check_export_status' (which checks status) by focusing on the final download step.

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

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

The phrase 'for a completed export' implies the appropriate time to use the tool (after export completion), and the sibling names suggest a workflow. However, it does not explicitly state when to use it versus alternatives or mention that one should first check export status via a sibling tool. Thus, usage context is implied but not explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Create an export' without mentioning whether the operation is asynchronous, what the return value looks like, or any side effects, leaving agents without critical 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?

The description is a single concise sentence with no waste. However, it conveys little beyond the tool name itself, making it under-specified despite being concise.

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

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

With five parameters, no output schema, and no annotations, the description fails to explain essential context such as how the export is initiated, what the response includes, or how it relates to export status and download tools. This leaves a major completeness gap for a mutation 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?

The input schema provides descriptions for all five parameters (100% coverage), so the baseline is 3. The description itself adds no parameter-level semantics beyond what the schema already documents, so it neither enhances nor detracts from schema clarity.

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 ('Create') and resource ('export of project annotations'), clearly distinguishing it from sibling tools like annotation_check_export_status and annotation_download_export, which handle checking and downloading exports.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention that checking export status or downloading exports are separate steps, nor does it state any prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only mentions the synchronous nature, omitting details about error handling, idempotency, success/failure responses, or any side effects. This is a minimal disclosure for a mutation tool.

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

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

The description is a single, front-loaded sentence with zero wasted words. It efficiently conveys the core action and a critical differentiator (synchronous) in minimal space.

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?

As a simple upload tool with no output schema and no annotations, the description is minimal but includes the key synchronous trait. However, it does not mention any processing behavior, error conditions, or what happens after the upload, leaving some operational gaps for the 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?

Schema description coverage is 100%, and the description adds no extra parameter-level information. The baseline of 3 applies because the schema already documents all parameters, including the annotation_format enum.

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 ('Upload pre-annotations to a project') and the resource (project). The word 'synchronous' explicitly differentiates from the sibling tool annotation_upload_preannotations_async, 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?

The description implies usage for synchronous uploads, but it does not explicitly state when to choose this tool over the async alternative or provide any context about prerequisites or suitable scenarios. The guidance is implicit rather than explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions 'asynchronous' without explaining what that entails, such as returning a job ID, polling status via monitor_job_status, error handling, or completion semantics.

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 sentence that is direct and free of filler. It communicates the core action and a key qualifier, earning its place without any 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 tool is an asynchronous operation with no output schema and no annotations. The description omits critical operational context, such as how to monitor progress, what response is returned, and how it relates to the monitor_job_status sibling. This leaves the agent with significant gaps in understanding.

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?

All three parameters are fully documented in the input schema with descriptions and an enum for annotation_format, so the schema provides complete parameter semantics. The description adds no additional meaning beyond what the schema already states.

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 'Upload pre-annotations to a project' with a qualifier 'asynchronous' that distinguishes it from the likely synchronous sibling tool 'annotation_upload_preannotations'. The verb and resource are specific and unambiguous.

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

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

No guidance is given on when to use this tool versus the synchronous alternative or other upload tools. The word 'asynchronous' implies a distinction but it is never explained, so the agent receives no decision-making 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Create a new dataset' only states the action; it does not reveal whether the dataset is created empty, whether it requires permissions, what happens on duplicate names, or what the response looks like. This is insufficient for a mutation tool.

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

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

The description is a single, front-loaded sentence with zero wasted words. It is appropriately concise for a simple creation tool, and the structure is clean.

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 output schema and no annotations, the description is too sparse. It does not explain what creating a dataset entails (e.g., whether files can be added later), any side effects, or the return value. This leaves the agent guessing at the tool's full behavior and consequences.

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 all parameters individually described (e.g., dataset_name, data_type, dataset_description). The tool description adds no additional parameter semantics, but per the baseline, the schema already provides adequate meaning.

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

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

The description 'Create a new dataset' uses a specific verb and resource, clearly distinguishing it from sibling tools like dataset_list, dataset_get, and dataset_upload_files. It is concise and unambiguous, though it lacks additional detail such as whether the dataset is empty or requires a project connection.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. Usage is implied by the tool's name and the existence of sibling tools, but there is no mention of prerequisites, such as needing a project first, or 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?

No annotations are provided, so the description carries the full burden. It merely says 'Get detailed information' which implies a read-only operation but does not disclose any behavioral traits such as permission requirements, error handling, response format, or whether the dataset may be modified. This is similar to the 'update_drive' example where the description implied mutation but lacked details on reversibility or permissions. The description is minimal and does not add meaningful transparency beyond what the name suggests.

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 sentence with no unnecessary words. It is front-loaded and directly communicates the action and resource. Although it is very brief, it earns its place with zero waste, aligning with the highest level of conciseness seen in the calibration example.

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 annotations and no output schema, the description needs to provide more context to be complete. It does not specify what 'detailed information' includes, how the tool behaves (e.g., errors if dataset not found), or why to use it instead of dataset_list or query_dataset_info. The one-liner is insufficient for the agent to correctly select and invoke the tool in a broader 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?

The input schema fully covers the only parameter, 'dataset_id', with the description 'ID of the dataset'. Since schema coverage is 100%, the baseline is 3. The tool description does not add any additional meaning beyond what the schema already provides, but it also does not conflict or omit anything.

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 the specific verb 'Get' and identifies the resource as 'a dataset', with 'detailed information' as the object. This clearly states the tool's purpose and distinguishes it from dataset creation or upload tools. However, it does not differentiate it from sibling tools like dataset_list or query_dataset_info, which may both retrieve dataset information.

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

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

The description provides no guidance on when to use this tool versus alternatives. It is a single sentence with no mention of prerequisites, exclusions, or which scenarios call for this tool over dataset_list or query_dataset_info. The presence of sibling tools that perform similar lookup functions makes this lack of guidance a significant gap.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a key behavior (includes both linked and unlinked datasets), but does not mention pagination, result fields, or any other side effects. For a simple list tool, this is minimal but acceptable.

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, concise sentence that immediately conveys the tool's purpose. There is zero wasted information and the phrasing 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 with one optional param and no output schema. The description covers the core functionality (listing all datasets, including linked/unlinked) but lacks detail about the response format or fields. Given the low complexity, this is nearly complete, but a bit more context about return values would be helpful.

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

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

The schema has only one parameter (data_type) with a clear description and enum, so schema coverage is 100%. The tool description adds no additional parameter semantics, keeping the baseline at 3.

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 'datasets', with scope 'all datasets (linked and unlinked)'. This distinguishes it from the sibling tool dataset_get, which targets a specific dataset, and from project_list which lists projects.

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 (when you need all datasets), but does not explicitly state when to use this over dataset_get. It also does not mention any exclusions or alternative tools. The 'all' wording hints at broad coverage but lacks direct guidance.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only restates the tool's primary action ('upload individual files') and gives no details on upload behavior, such as whether files are appended or overwritten, size limits, async processing, or required permissions. This is a significant transparency gap for a mutation tool.

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

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

The description is a single, front-loaded sentence of 7 words with zero filler. Every word is meaningful and the structure directly states the action and object.

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 has no annotations and no output schema, the description leaves out crucial context: whether the operation is synchronous or asynchronous, what is returned (e.g., job ID), any limits on file size/count, and error behavior. This is a bare minimum description for a straightforward upload tool but is insufficient for an agent to predict side effects.

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

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

The input schema covers 100% of parameters with descriptions ('Array of file paths to upload' and 'Type of data being uploaded'), so the description adds no additional parameter meaning. Per the rubric, baseline 3 is appropriate when schema coverage is high.

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 (Upload) and the resource (individual files to a dataset). The word 'individual' hints at a distinction from the sibling tool 'dataset_upload_folder', but it does not explicitly name or elaborate on that distinction, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives. With sibling 'dataset_upload_folder' present, the description should explicitly state that this is for individual files rather than folders, but it simply says 'individual files' without explaining when it is appropriate.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only states the basic action without details on error handling, overwriting behavior, recursion, authentication, or side effects, which are important for an upload mutation tool.

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

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

The description is a single, front-loaded sentence that uses only essential words. It is concise without sacrificing clarity.

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 a mutation operation with no output schema and no annotations. The description does not explain return values, error behavior, prerequisites (e.g., dataset must exist), or how it differs from the sibling upload tool, leaving significant gaps.

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

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

Schema coverage is 100%, with both parameters having descriptions in the schema. The tool description adds no additional meaning beyond the schema, so the baseline score 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 clearly states the tool's purpose: uploading all files from a folder to a dataset. The verb 'upload' and resource 'folder to a dataset' are specific, and the scope 'all files' distinguishes it from the sibling tool dataset_upload_files.

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

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

No guidance is provided on when to use this tool versus alternatives such as dataset_upload_files. It does not mention prerequisites, use cases, or exclusions, leaving the agent without direction for tool selection.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It discloses that the tool lists active operations and their status, implying a read-only operation, but does not explain what 'active' means, whether it returns operation IDs for follow-up, or any edge cases. It is not misleading but minimal.

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, focused sentence with no wasted words. It front-loads the core verb and resource, making it easy to parse.

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 simplicity (no parameters, no output schema), the description is largely sufficient. It clearly states the listing scope and what is included (status). However, it lacks context on what qualifies as an 'active operation' and how this relates to sibling monitoring tools, which could lead to ambiguity in complex workflows.

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

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

The tool has zero parameters, so there is no parameter schema to augment. The description has no parameter information to add, matching the baseline of 4 for zero-parameter 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 uses a specific verb ('List') and resource ('active operations') with a clear scope ('all' and 'their status'). It distinguishes from siblings like monitor_job_status (specific job), monitor_project_progress (project-level), and monitor_system_health (system-level), though it does not explicitly name 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 provides no when-to-use guidance, exclusions, or comparisons to alternatives. It only states what it does, leaving the agent to infer when to choose this over sibling tools like monitor_job_status or query_operation_history.

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

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

With no annotations, the description carries full responsibility for disclosing behavior, but it only states the tool 'monitors' status. It does not explain whether the call blocks until completion, returns immediately with a status snapshot, or requires polling. There is no mention of possible status values, error conditions, or side effects. This lack of detail leaves the agent uncertain about how to interpret the tool's behavior.

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

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

The description is a single concise sentence that is front-loaded with the verb and object. It avoids unnecessary words and is easy to scan. However, it is slightly under-specified, but that is more a completeness issue than a conciseness problem. The structure is appropriately compact.

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 absence of annotations and output schema, the description does not provide enough context for an agent to fully understand how to use this tool across the sibling ecosystem. It does not explain how job IDs are obtained, what statuses are returned, or how this differs from other monitor/check tools. The overall context is too vague for reliable 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 input schema already provides 100% coverage for the sole parameter (job_id) with a clear description. The tool description does not add any extra meaning beyond the schema, but the high schema coverage means the parameter is sufficiently documented. Since the schema does the heavy lifting, a 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 identifies the action (monitor) and resource (job status), so the core purpose is evident. However, it does not distinguish this from sibling tools like monitor_project_progress or monitor_active_operations, which also monitor statuses. The phrase 'background job' is generic and could refer to any asynchronous task.

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

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

There is no guidance on when to use this tool versus alternatives such as annotation_check_export_status or monitor_active_operations. No prerequisites, exclusions, or examples of appropriate invocation are provided. The description implies usage for any background job but does not define the context or criteria for choosing 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?

No annotations are provided, so the description must disclose behavioral traits itself. It only says 'Get', implying a read-only operation, but offers no detail on output format, pagination, permissions, or side effects. The description adds no meaningful behavioral context beyond the inherent meaning of 'get'.

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 concise sentence that conveys the core function without any fluff or redundancy. It is appropriately sized for the tool's simplicity.

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

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

The tool has no output schema, so the description should clarify what 'progress statistics' entails and what the agent can expect in the response. The vague phrasing and lack of distinction from similar siblings leave the description incomplete for a tool with no annotation support.

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 a complete description for 'project_id' (100% coverage). The description adds no extra meaning to the parameter, but since the schema is sufficient, 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 clearly states a specific verb ('Get') and resource ('progress statistics for a project'), which makes the tool's function understandable. However, it does not differentiate from the sibling tool 'query_project_statistics', which likely serves a similar 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 provides no guidance on when to use this tool versus alternatives such as 'query_project_statistics' or 'monitor_job_status'. There is no mention of context, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool 'checks' health, implying a read-only action, but does not disclose what data is returned, whether authentication is needed, or what 'health and status' concretely includes. This is minimal behavioral transparency.

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, focused sentence with no filler or redundancy. It conveys the core purpose efficiently, earning a perfect score for conciseness.

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

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

Given the low complexity (0 params, no output schema, no annotations), the description is minimally viable but lacks context about the output format or what health/status details are included. The agent knows what the tool does but not what to expect from its response, leaving a clear gap.

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

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

The tool has zero parameters, so the schema imposes no requirements. Per the baseline for 0 params, a score of 4 is appropriate; the description doesn't need to explain parameter semantics because there are none.

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 the specific verb 'Check' with a clear resource 'health and status of the MCP server'. This distinguishes it from sibling monitoring tools like monitor_job_status and monitor_project_progress, which focus on narrower task-specific health.

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 does not provide any guidance on when to use this tool versus the many sibling monitoring tools. While the name and scope imply server-level health, nothing explicitly tells the agent to prefer this over alternatives for server diagnostics.

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

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

With no annotations provided, the description carries the full burden of disclosing side effects and requirements. It merely says 'Create' without mentioning that this operation may involve file uploads, create associated resources, or require specific permissions. The agent has no warning about the operation's mutating impact or potential asynchronous behavior.

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

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

The description is a single sentence with no superfluous text. It front-loads the action ('Create') and includes the essential object ('annotation project') and key components ('dataset and guidelines'). This is concise and well-structured, despite being minimal.

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 (10 parameters, nested objects, no output schema), the description is far too sparse to be complete. It does not explain what happens after creation (e.g., return value), whether the dataset must pre-exist, or how options like autolabel and rotation_config affect the project. The agent would need to infer all of this from the schema alone.

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

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

The input schema covers 90% of parameters with detailed descriptions, so the baseline for this dimension is 3. The tool description adds minimal semantic value by highlighting 'dataset and guidelines' as key components, but it does not explain how these relate to other parameters like files_to_upload or rotation_config. 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 clearly states the action ('Create') and the resource ('a new annotation project'), and it specifies the core inputs ('with dataset and guidelines'). This distinguishes it from sibling tools like dataset_create, which focus on dataset creation rather than project creation.

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

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

The description provides no guidance on when to use this tool versus alternatives such as dataset_create or project_update_rotation. It does not mention prerequisites (e.g., whether the dataset must already exist) or exclusion criteria, leaving the agent to infer usage from the schema alone.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only says 'get detailed information' and does not explicitly mention that this is a read-only operation, potential errors (e.g., project not found), authentication requirements, or the structure of the returned details. The description adds little beyond the tool's name.

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 sentence that is clear, front-loaded, and free of unnecessary words. It gets straight to the point without wasting space, making it highly efficient.

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

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

For a simple get operation with one parameter and no output schema, the description is minimally adequate but lacks depth. It does not describe what 'detailed information' includes, nor does it mention any constraints or error scenarios. Given the absence of annotations and output schema, the description could provide more context to be truly complete.

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

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

The input schema fully describes 'project_id' with 100% coverage, so the description does not need to add parameter details. The description's mention of 'specific project' aligns with the parameter but does not enrich it beyond the schema's own description. Baseline of 3 is appropriate given 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 clearly states the tool's function: 'Get detailed information about a specific project'. It uses a specific verb ('get'), identifies the resource ('project'), and narrows scope to 'specific project', which distinguishes it from the sibling 'project_list' that likely lists all projects.

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 for retrieving one project but does not explicitly contrast with alternatives like 'project_list' or state when not to use it. The word 'specific' hints at a singular project, but there is no clear when-to-use guidance or exclusions.

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

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

No annotations are provided, so the description carries the full burden of sharing behavioral traits. It only states 'list', which implies a read operation, but fails to disclose pagination, filtering, required permissions, or the structure of the response. This is a significant gap for a tool with no output 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 a single, front-loaded sentence with no wasted words. It precisely conveys the tool's function in five 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 zero-parameter list tool, the description is adequate but not fully complete. It lacks details about return values (no output schema), possible filtering, or edge cases like empty lists. The simplicity mitigates the gap, but the absence of output schema and minimal behavioral info keeps it from being more complete.

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

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

The input schema has zero properties, so there are no parameters to describe. According to the rubric, 0 params yields a baseline of 4. The description adds no param details, but none are needed since the schema fully covers 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 'List all projects for the client' uses a specific verb ('List'), identifies the resource ('projects'), and implies scope ('all', 'for the client'). It clearly distinguishes from sibling tools like project_get (singular retrieval) or project_create (creation).

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 does not explicitly state when to use this tool versus alternatives like project_get or dataset_list. Usage is implied by the name and sibling context, but no exclusions or alternative recommendations are provided, making it usable but not clearly guided.

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?

This is a mutation tool with no annotations provided, so the description carries the full burden of disclosure. It only says 'Update rotation configuration' and does not explain whether updates are partial or full, any permission requirements, reversibility, side effects, or what the response looks like. This is a significant gap for a mutation operation.

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

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

The description is a single concise sentence with no redundant words, making it efficient in length. However, it is perhaps too minimal to convey necessary context, though this is more a completeness issue than a conciseness one. It is well-structured and front-loaded with the verb.

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

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

With no output schema and no annotations, the description must explain behavior and return values, but it does not. It fails to cover important operational details such as the effect on existing rotation counts, validation rules, or the response format. The tool's moderate complexity (nested config object) demands more context than this minimal description provides.

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 50% with only project_id described; rotation_config and its nested properties lack descriptions. The tool description adds no parameter information, failing to explain what rotation_config fields mean or how they are applied. The descriptive parameter names help slightly, but the description does not compensate for the undocumented config object.

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

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

The description clearly states the verb 'Update' and the resource 'rotation configuration' for a project. It distinguishes itself from sibling tools like project_create and project_get by specifically targeting rotation settings.

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 its purpose, but it does not explicitly state when to use this tool or mention any alternatives. There are no exclusions or prerequisites provided, making the usage context implied rather than explicitly guided.

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

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

No annotations are provided, so the description carries the full burden. 'Get' implies a read operation, but the description does not disclose return format, data scope, permissions, or any limitations. It is minimal and lacks 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?

The description is a single, concise sentence with no unnecessary words. It is optimally brief.

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?

Despite the tool's simplicity, the description is incomplete given the existence of sibling dataset_get. There is no output schema to clarify what 'detailed information' means, and the lack of usage guidance leaves significant ambiguity about when to choose this 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?

The schema has 100% coverage for the single parameter dataset_id with a brief description. The tool description adds no additional meaning beyond the schema, 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 states a clear verb-resource pair: 'Get detailed information about a dataset.' However, it does not distinguish itself from the sibling tool 'dataset_get', which likely serves a similar purpose, so it lacks sibling differentiation.

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

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

There is no guidance on when to use this tool versus dataset_get or other dataset-related tools. No context, exclusions, or alternative suggestions are provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'query', which implies read-only, but adds no context about ordering, pagination, filter behavior, or whether any side effects occur. The description contributes minimal behavioral insight beyond the tool name.

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, concise sentence with no redundant words. It is front-loaded and easy to parse. While it omits a few contextual details, its brevity is appropriate for the simple action it describes.

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

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

The tool has no output schema and no annotations, so the description must explain return values and key behaviors. It does not describe the format of operation history, default ordering, or the effect of the status filter. This leaves the agent without essential information for invoking the tool and interpreting results.

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 fully describes both parameters (limit and status) with clear descriptions, so schema coverage is 100%. The description does not add any extra parameter semantics. Baseline of 3 is appropriate since the schema handles parameter meaning.

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

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

The description uses the specific verb 'query' and resource 'history of operations', making the basic function clear. However, it does not specify the scope of operations (e.g., project, dataset, job), which could be ambiguous given sibling tools like monitor_job_status. Nonetheless, 'history' implies past operations, distinguishing it from active-operation monitors.

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

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

The description provides no guidance on when to use this tool versus alternatives like monitor_active_operations or monitor_job_status. There is no mention of appropriate context, exclusions, or preferred scenarios. This leaves the agent without sufficient direction for tool selection.

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

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

With no annotations and no output schema, the description must disclose behavioral details, but it only says 'get' (implying read-only) and 'detailed statistics' without explaining what is returned, pagination, or any side effects. This is a significant transparency gap for a tool with no structured documentation.

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

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

The description is a single, front-loaded sentence with no filler or redundant information. It efficiently communicates the core action, though it sacrifices detail.

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

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

Given the absence of an output schema and annotations, the description should explain the return format or extent of the statistics. It does not, nor does it clarify how this tool relates to the several similar query/monitor siblings, making it incomplete for reliable tool selection and result interpretation.

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 provides 100% coverage for the sole parameter project_id, so the baseline is 3. The description does not add any additional meaning to the parameter beyond what the schema already states; it simply repeats 'project' context.

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 action ('Get') and resource ('detailed statistics for a project'), which distinguishes it from the sibling project_get (which likely returns project configuration) and monitor_project_progress (which tracks progress). However, it doesn't specify what 'statistics' entails (e.g., usage, export counts, performance), leaving some 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 monitor_project_progress or query_dataset_info. The description gives no context for tool selection or exclusions, leaving the agent to infer usage.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose return behavior, matching semantics, pagination, or potential errors. The one-liner gives no detail beyond the basic intent, leaving the agent guessing about results and side effects.

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, concise sentence that is front-loaded with the key action and resource. Every word is useful, and there is no extraneous 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?

Despite the simple schema, the description leaves gaps: no return format, no usage guidance, and no differentiation from project_list beyond the name/type filter. For an agent to properly invoke and interpret results, it needs more context, making this incomplete.

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

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

Schema coverage is 100% (query has a description). The tool description adds meaning by clarifying that the query can match by name or type, which the schema description does not specify. This enriches the parameter semantics beyond the plain 'Search query string'.

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 ('Search') and resource ('projects'), and specifies the criteria ('by name or type'), clearly distinguishing it from sibling tools like project_list (list all) and project_get (retrieve by ID). This gives a precise scope of operation.

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

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

There is no guidance on when to use this tool versus alternatives. It doesn't state whether to use it for quick lookups, how it differs from project_list, or any exclusions. The description simply states what it does without context for selection.

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