CatchAll (by NewsCatcher)

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 a mutation action without describing side effects, error handling, idempotency, or behavior when an entity is already in the dataset. This is a significant 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, clear sentence with no redundancy. It is front-loaded with the action and concise, appropriate for a straightforward operation. 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?

Although an output schema exists (per context signals) and the operation is simple, the description is extremely minimal. It lacks critical context such as error conditions, idempotency, or any requirements for the entities to already exist. For a tool with no annotations, more behavioral detail is needed to make it 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%, meaning all parameters have descriptions in the schema. The tool description adds no additional meaning about parameters, such as the relationship between entity_ids and dataset_id, so it meets the baseline but does not exceed it.

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

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

The description states a specific verb 'Add' with a clear resource 'existing entities' and target 'dataset'. The word 'existing' distinguishes it from creation tools, but it does not explicitly name alternatives like create_entities_batch or create_entity, relying on the reader to infer the distinction.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites (e.g., entities must already exist) or indicate that it is for linking existing entities rather than creating new ones. There are no exclusions or references to sibling 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?

With no annotations, the description must disclose behavioral traits. It does add a specific note about webhooks being first-class resources that survive project deletion, which is valuable. However, it does not cover other behaviors such as idempotency, error handling, or whether duplicate additions are allowed. The webhook note partially compensates for the lack of 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 two concise sentences with no wasted words. The primary purpose is front-loaded, and the webhook note adds important context without being verbose. It is well-structured for quick scanning.

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 an output schema, so return format is covered. The description covers the core action and a key behavioral nuance, but it omits details about when to use this tool vs siblings, idempotency, or possible errors. For a tool that adds resources, these are relevant gaps.

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

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

Schema description coverage is 100%, so parameters are already well-documented. The description adds context about webhooks within the resources parameter, clarifying their behavior. This is a modest addition beyond the schema, so a 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 action: 'Add one or more resources to a project.' It identifies the verb, resource, and target. However, it does not explicitly differentiate from sibling tools like assign_webhook_resource or remove_project_resource, though the core purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention scenarios like assigning a webhook to a project (covered by assign_webhook_resource) or removing resources (remove_project_resource). The only usage hint is the webhook note, but it does not state when to choose this tool over others.

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

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

With no annotations, the description carries the full burden. It discloses parsing, appending, duplicate skipping, and column requirements, but does not mention side effects, failure modes, or auth nuances beyond the schema's api_key note. Adequate but not rich.

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 paragraphs with no fluff. The purpose is front-loaded, and the alternative is stated at the end. Every sentence contributes to understanding the tool's operation or constraints.

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

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

The description covers the core operation, data format requirements, and the key alternative. While it doesn't address error handling or detailed edge cases, the schema and output schema likely cover those. For a tool of this complexity, it is sufficiently 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%, so baseline is 3. The description adds meaningful context for the 'file' parameter by specifying required CSV columns and duplicate behavior, which is not present in the schema. This elevates it above baseline.

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

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

States a specific verb and resource ('Append entities from a CSV file to an existing dataset') and explicitly distinguishes from the sibling create_dataset_from_csv by naming it. This makes the tool's scope immediately clear and prevents confusion.

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 when-to-use (append to existing dataset) and when-not-to-use (create new dataset, pointing to create_dataset_from_csv). Also gives concrete content requirements (name column required, domain/description recommended) and notes duplicate rows are skipped, guiding correct 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does not meet it. 'Map' implies a mutating association, but the description never states whether the operation is idempotent, what happens if the resource is already mapped to the webhook, whether duplicates are created or replaced, or what side effects occur. For a write-style tool with zero annotation coverage, this is a meaningful transparency gap.

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

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

The description is two sentences with the core purpose front-loaded and a compact, bulleted 'Use when' clause. There is no filler or redundancy. It is slightly terse but every sentence earns its place, so a 4 rather than 5, which would demand a bit more useful substance packed in.

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

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

The description covers purpose and usage trigger, the schema covers all parameters at 100%, and an output schema exists so return values need not be spelled out. The notable gap is behavioral depth (idempotency, duplicate handling, side effects), which was already penalized under behavioral transparency, leaving the definition adequate but not fully complete for a mutating tool.

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

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

Schema description coverage is 100%, so the input schema already documents all four parameters (api_key, webhook_id, resource_id, resource_type) with meaningful descriptions. Per the rubric, high coverage earns a baseline of 3. The description's mention of resource types (job/monitor/monitor_group) mildly reinforces the resource_type parameter but adds no semantics beyond what the schema already provides.

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

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

The description states a specific verb+resource ('Map a resource to a webhook') and enumerates the three accepted resource types (job, monitor, monitor_group), making the operation unambiguous. It implicitly distinguishes itself from create_webhook (creating the webhook itself) and remove_webhook_resource (the inverse unmapping), though it never names these siblings explicitly, which keeps it from 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?

A dedicated 'Use when' clause gives a clear trigger condition ('you want a webhook to fire for a specific job or monitor's deliveries'), which is solid usage context. However, it offers no exclusions and names no alternatives (e.g., remove_webhook_resource for unmapping, or trigger_webhook for manual firing), so it falls short of the explicit when-not/alternative guidance needed for a 5.

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

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

With no annotations provided, the description carries the full burden. It discloses that no API key is required and identifies the HTTP endpoint, which is useful behavioral context. However, it does not describe the response format, what constitutes a healthy status, or any side effects (expected to be none).

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

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

Two short sentences, zero fluff. The key behavioral insight (no API key required) is front-loaded in the second sentence, and the endpoint mapping adds useful precision. Every sentence earns its place.

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

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

For a simple health-check tool with a single optional parameter and an output schema present, the description is mostly sufficient. It correctly signals that no auth setup is needed and maps to a known endpoint. It could mention the output schema's meaning or indicate that this tool is useful for liveness checks, but the current state is adequate for an agent to call it correctly.

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

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

Schema description coverage is 100%: the only parameter, api_key, is documented in the schema with its default and meaning. The description adds that no API key is required, which clarifies the optional nature of the parameter but does not add deeper semantic meaning beyond the schema.

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

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

The description states a specific verb ('Check') and resource ('API health status'), clearly indicating the tool's purpose. It does not explicitly differentiate from siblings like get_version or get_dataset_status, but the health-check focus is distinct enough given the tool name.

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

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

The description notes that it maps to GET /health and requires no API key, giving context that this is a lightweight, unauthenticated health check. It does not explicitly state when to use this tool versus alternatives like get_version or get_dataset_status, so the when-to-use guidance is implied 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?

No annotations are provided, so the description carries the burden. It transparently discloses that processing more records costs additional credits, which is a significant behavioral trait. It also clarifies that this operation is a continuation, not a new job, and explains the default behavior when new_limit is omitted. It could mention reversibility or the output shape, but it covers the most critical user-facing consequences.

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, well-structured, and front-loaded with the core purpose. Each sentence adds necessary information: the effect, the cost warning, the applicability condition, and the limit rules. There is no filler or redundancy.

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

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

For a tool with 3 parameters, an output schema, and no annotations, the description is fairly complete. It covers purpose, applicability, cost implications, and parameter constraints. The main gap is not describing what the response contains, but since an output schema exists, the description doesn't need to explain return values. Overall, an agent has enough context to decide when and how to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning by explaining the relationship between new_limit and the previous limit ('must be greater than the previous limit') and the API default behavior when omitted. It also explains the conceptual purpose of new_limit in the context of extending a job. This goes beyond the schema's rote parameter descriptions.

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 ('Expand a job by processing more records beyond the initial limit'), names the resource (a job), and explains the effect (increases records processed). It also distinguishes itself from general job operations by specifying it only applies to jobs submitted with a limit, which helps differentiate it from siblings like get_job_status or delete_job.

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

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

The description provides explicit guidance: 'Only use this when the user wants MORE data processed,' states that it only applies to jobs originally submitted with `limit`, and explains when there is nothing to continue ('If a job was submitted without `limit`, there is nothing to continue'). It also gives necessary constraints on new_limit, making the decision to use the tool unambiguous.

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 carry the full burden of behavioral disclosure. It states only that a new dataset is created and what datasets conceptually are. It does not disclose whether creation is idempotent, what happens on duplicate names, how the created dataset is identified in responses, or whether any side effects occur beyond the creation.

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

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

The description is short and front-loaded with the core action. The second sentence explains the dataset concept and the intended integration path, earning its place. It could be slightly tighter but is well within reasonable length.

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

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

For a creation tool with an output schema, the description adequately covers the basic purpose and downstream usage. However, with no annotations and no mention of how the created dataset is referenced afterward, an agent may miss important operational context such as retrieving the dataset ID or choosing between direct creation and CSV-based creation.

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

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

Schema description coverage is 100%, so the parameters are already well documented in the schema. The description's mention of connected_dataset_ids in submit_query adds downstream context but does not add new meaning about create_dataset's own parameters, so the baseline of 3 is appropriate.

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

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

The description opens with 'Create a new dataset', which clearly names the verb and resource. It also defines what a dataset is (a collection of entities), but it does not explicitly distinguish itself from the sibling create_dataset_from_csv, which also creates datasets but through a different input path.

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 contextual usage for datasets ('Connect a dataset to a job via submit_query...') but provides no guidance on when to prefer this tool over create_dataset_from_csv, append_csv_to_dataset, or add_dataset_entities. There are no exclusions or alternatives mentioned, so an agent gets little decision support.

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 discloses that rows with only a name produce lower-quality enrichment, that max file size is plan-dependent, and that additional columns are mapped to entity attributes. However, it does not mention any failure modes, idempotency, or side effects beyond creation, which are minor gaps for a create 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 concise and well-structured. It leads with the primary action, then provides necessary constraints and an alternative in a clear, scannable format. Every sentence contributes value, with no redundant fluff. The two-paragraph layout keeps 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 that an output schema exists and parameters are fully described, the description covers the essential usage context: what the tool does, required CSV format, enrichment caveats, file size constraints, and the alternative tool. It does not mention authentication or prerequisites, but these are implied by the api_key parameter and standard API usage. The description is sufficiently complete for an agent to call the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful semantics about the 'file' parameter by explaining the required columns and the enrichment behavior, which goes beyond the schema's simple 'CSV content' description. It also clarifies the role of additional columns. This added context justifies a score above the baseline.

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

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

The description opens with a clear statement: 'Create a new dataset by uploading a CSV file.' This specifies the verb (create), resource (dataset), and method (uploading CSV). It also explicitly distinguishes itself from the sibling 'append_csv_to_dataset' by noting that the alternative is for adding rows to an existing dataset, which prevents confusion.

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

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

The description gives explicit usage guidance: it states the required CSV structure (must have a 'name' column, and recommends 'domain' or 'description' for enrichment) and warns about file size limits. It directly names the alternative tool and the condition for using it ('To add CSV rows to an existing dataset, use append_csv_to_dataset instead'), leaving no ambiguity about when to choose 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the core action without revealing side effects, idempotency, auth requirements, failure modes, or limits. For a batch operation, important behaviors like partial success or validation are not mentioned. This is a minimal disclosure.

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

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

The description is a single sentence with no redundant words. It is front-loaded and efficient. However, its brevity may be too sparse for the tool's complexity, but it earns a 4 for being concise and clearly 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?

The description is insufficient for a batch creation tool. It does not explain return values, error handling, validation rules, or any prerequisites. Even though an output schema exists, the description adds no operational context. An agent would need to infer behavior from the schema alone, which is insufficient for a non-trivial mutation.

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, including the entities structure and optional api_key. The description adds no parameter-specific meaning beyond what the schema already provides. Given 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description states a clear action: 'Create multiple entities in one call.' It specifies the verb (create), the resource (entities), and the key differentiating factor (multiple vs single, implying batch). This distinguishes it from the sibling tool create_entity without needing further context.

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 alternatives like create_entity. While the batch aspect is implicit, there is no explicit statement such as 'use this for bulk operations' or 'prefer create_entity for a single entity.' The description lacks any contextual or exclusionary 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 present, so the description carries the full disclosure burden. It states that this is a create operation and adds the required identifying-field rule, but it does not address duplicate handling, idempotency, auth requirements, or side effects beyond creating the record. For a write operation this is a meaningful gap.

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

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

The description is compact and front-loaded: one scoping sentence followed by a code-formatted precondition. There is no filler or repetition of schema property descriptions.

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 input schema and output schema cover parameters and return shape, and the description adds the essential validation rule. However, there is no routing to create_entities_batch for multiples or update_entity for edits, and with no annotations the definition lacks behavioral context such as idempotency, making it minimally viable rather than 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%, so the baseline is 3, and the description adds meaning beyond the schema by specifying the non-obvious cross-field rule that name alone is insufficient and one of description or additional_attributes.company_attributes.domain must be supplied. It also clarifies that entities are companies or persons.

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 opening sentence clearly names the operation and resource ('Create a single entity (a company or person)') and scopes it to one record. It does not explicitly contrast with create_entities_batch or update_entity, so sibling differentiation is mostly implicit.

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

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

The description supplies a concrete precondition: name plus at least one identifying field (description or domain). It does not say when to prefer create_entities_batch for bulk creation or update_entity for existing entities, so usage context is implied 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, the description carries the full burden and discloses substantial non-obvious behavior: timezone handling rules, the 7-day backfill window constraint, plan-dependent minimum frequency, and the removal of inline webhook config. It does not cover auth/permission requirements or whether creation triggers an immediate first run, which keeps it below 5.

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?

Purpose is front-loaded, followed by a workflow note and a scannable bulleted list of constraints. Every section adds non-redundant value beyond the schema; the length is justified given the number of operational gotchas for an 8-parameter tool.

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

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

Output schema covers return values, and the description covers the failure-prone operational details (timezone, backfill window, webhook centralization, plan limits). Minor gaps remain around auth requirements and whether the monitor executes immediately on creation, but for a complex tool with no annotations this is strong.

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%, setting a baseline of 3. The description adds meaning beyond the schema for schedule/timezone (always include a timezone; schedule text overrides the arg), backfill (7-day end_date constraint), and webhook_ids (register with create_webhook first; no inline config).

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

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

Opens with a specific verb + resource + source: 'Create a recurring monitor from a completed job.' The second sentence ('Monitors re-run a job's query on a schedule') pins down what a monitor is, clearly distinguishing this from siblings like create_webhook, update_monitor, disable_monitor, or submit_query.

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?

Gives explicit workflow positioning: 'Use the explore -> refine -> automate pattern: submit a job, refine until results match, then create a monitor.' It also routes webhook setup to the create_webhook sibling. It stops short of a 5 because it never explicitly says when-not-to-use this in favor of update_monitor/disable_monitor/delete_monitor.

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 states 'create' (a write operation) but does not mention authentication requirements, permission needs, idempotency, or any side effects. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

Two sentences with no filler. The primary action is front-loaded and the second sentence adds the key conceptual insight about project grouping and filtering, making every sentence earn its place.

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

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

The tool is simple and an output schema exists, but with no annotations the description should still provide more guidance on authentication or when to use an existing project versus creating a new one. It is adequate but leaves meaningful usage and behavioral gaps.

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

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

Schema description coverage is 100%, so the input schema fully documents the name, api_key, and description parameters. The description adds context about project grouping but does not add meaning to the parameters themselves, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb and resource ('Create a new project') and then explains what a project is for, which distinguishes it from create_dataset, create_monitor, and create_webhook. An agent can identify this as the container/grouping tool rather than a resource-creation tool.

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

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

The second sentence gives clear context: projects group related resources and enable filtering by project_id. This implies when a project container is needed, but it does not explicitly state when not to use it or point to alternatives like create_dataset for non-grouped resources.

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 says 'Create a new webhook endpoint' and lists use cases, but does not disclose any side effects, authentication requirements, validation behavior, or consequences of creation. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is concise, with the core purpose stated in the first sentence and the use cases formatted as a bulleted list. Every sentence earns its place, and the information is front-loaded and scannable for an agent.

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 11 parameters and the presence of an output schema, the description provides sufficient context for an agent to know when to call the tool and what the primary use cases are. The parameter details are handled by the schema, and the description covers the main decisions (when to use and the optional project association). It is slightly lacking in broader context about webhook behavior, but that is not essential for a create operation.

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

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

The schema has 100% coverage, so the baseline is 3. The description adds minor semantic value by explaining when to use project_id ('associate with a project from the start'), but does not elaborate on other parameters beyond what the schema already documents. It neither compensates for gaps nor contradicts 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 states a specific verb (create) and resource (webhook endpoint), and the 'Use when' bullets clarify the exact scenarios for using this tool. It clearly distinguishes from siblings like update_webhook, delete_webhook, test_webhook, and trigger_webhook by focusing solely on 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 explicit 'Use when' conditions covering registration of URLs, obtaining a webhook_id, and associating with a project from the start. While it doesn't explicitly state when not to use or name alternative tools, the given conditions are specific and actionable, so it earns a 4 rather than a 5.

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

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

With no annotations, the description carries the burden of disclosing destructive behavior. It clearly states permanence and the non-cascade to referenced entities, which is the most important side-effect information. It does not detail auth requirements or other side effects, but the return shape is covered by an 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?

Two short sentences with the main action front-loaded and the key clarification in the second sentence. There is no filler or redundant restatement of the tool name.

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

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

For a simple delete operation with one required parameter and full schema descriptions, the description covers the operation, permanence, and association semantics. It lacks explicit sibling-tool routing, but the destructive behavior is sufficiently scoped for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents both api_key and dataset_id. The description adds no parameter-level detail beyond the general dataset scope, which is acceptable given the 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 states 'Permanently delete a dataset' with a specific verb and resource, and the second sentence clarifies scope by noting that referenced entities survive. This clearly distinguishes it from sibling tools like delete_entity and remove_dataset_entities.

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

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

No explicit when-to-use or alternative tools are named, but the statement that referenced entities are not deleted provides an implied boundary: this tool removes the dataset and its associations, not the entities themselves. It could be stronger by pointing to delete_entity or remove_dataset_entities for entity deletion.

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 says 'Permanently delete' which discloses irreversibility, but with no annotations provided, the description carries the full burden. It doesn't disclose side effects, cascading deletions, auth requirements, or what happens to associated data. The word 'permanently' adds some value but leaves significant behavioral gaps.

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

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

The description is a single short sentence with no waste. It is front-loaded with the action and resource. However, it is so brief that it misses opportunities to add behavioral context.

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

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

For a destructive tool with no annotations and no output schema details, the description is incomplete. It doesn't explain return values, error conditions, or side effects. An agent would not know what to expect after calling it or what prerequisites exist.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds no parameter-level detail beyond what the schema provides. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states a specific verb ('delete') and resource ('entity'), and the title reinforces it. It is clear what the tool does, though it doesn't explicitly distinguish itself from sibling delete tools (delete_dataset, delete_project, etc.) beyond the resource name.

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

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

No guidance on when to use this tool versus alternatives. It doesn't mention that deletion is permanent, irreversible, or that related resources may be affected. The description simply states the action without 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. It clearly states 'Permanently delete' which conveys irreversibility, and 'and its results' indicates the scope of deletion. However, it does not mention any additional behaviors such as authentication requirements, error conditions, or effects on dependent resources. The core destructive nature is disclosed, but richer context is missing.

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

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

The description is extremely concise—two short paragraphs with no wasted words. The purpose is front-loaded in the first sentence, and the usage condition is clearly separated. Every sentence earns its place, making it an efficient and well-structured definition.

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 simple delete operation with two parameters (one required) and an output schema exists, so return values need not be explained. The description covers the key aspects: what it does, the permanent nature, the scope (results), and the usage condition. It does not mention potential error cases or prerequisites beyond the job being owned, but given the simplicity, it is adequately complete.

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

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

Schema coverage is 100%—both job_id and api_key are described in the input schema. The description adds no extra meaning beyond what the schema provides (e.g., no format, constraints, or additional context). Since the schema already documents both parameters, the baseline score of 3 applies; the description does not need to compensate.

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

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

The description clearly states the action: 'Permanently delete a job and its results.' It specifies the resource (job) and the scope (and its results), which distinguishes it from other delete tools like delete_dataset or delete_project. The verb 'delete' and the explicit scope leave no ambiguity about what the tool does.

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 a clear usage condition: 'Use when: You want to remove a job you no longer need from your account.' This tells the agent when to invoke it. It does not explicitly list when not to use it or mention alternatives, but the tool name and scope make the context straightforward. The guidance is sufficient for an agent to decide to use this tool over sibling delete 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?

There are no annotations, so the description carries the behavioral disclosure burden. It discloses irreversibility ('Permanently') and the side effect ('stop its scheduled runs'), which are critical for a delete operation. It does not cover auth requirements or cascading effects on historical data, but the key behavioral traits are present.

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

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

The description is short and front-loaded with the core action, followed by a clear usage condition. Every sentence earns its place, with no repetition of the title or schema.

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

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

For a simple two-parameter delete tool with an output schema, the description covers the operation's purpose, when to use it, and its irreversible effect. Nothing needed for correct invocation is missing.

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

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

Schema description coverage is 100%, so the schema already documents both parameters fully. The description adds no extra semantic detail beyond the schema, such as constraints or relationships between parameters. 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 states a specific verb and resource: 'Permanently delete a monitor and stop its scheduled runs.' It clearly distinguishes this from the sibling disable_monitor by emphasizing permanent removal. The purpose is unambiguous.

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

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

The description explicitly says when to use the tool ('when you want to remove a monitor entirely') and names the alternative for pausing: 'use disable_monitor to only pause it.' This gives the agent a clear routing decision.

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

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

No annotations are present, so the description carries full behavioral disclosure. It clearly states the destructive action, the default detach-but-keep behavior, the effect of delete_resources=true, and the webhook exception. This is richer and more transparent than most mutation descriptions.

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 core operation, then logically expands to default behavior, the optional flag, and the exception. Every sentence earns its place; there is no redundant filler.

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

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

Despite having no annotations, the description is complete for a delete tool: it defines destructive scope, parameter-driven behavior, and the key exception. The output schema covers return values, and the high schema coverage covers parameters, so nothing essential is missing.

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

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

The schema covers all three parameters (100% coverage), so the baseline is 3. The description adds value by detailing the default resource behavior and explaining the webhook exception more fully than the schema does, particularly the ownership nuance that webhooks may belong to other projects.

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 opening sentence 'Delete a project' states a specific verb and resource, and the rest of the description expands what that operation entails (detaching vs. deleting resources). The name and title are not merely restated; the scope is unambiguous and distinguishable from sibling delete_* tools.

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

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

The description provides clear context for when to use delete_project and when to set delete_resources=true, but it never names alternatives or states when to use other delete_* tools. Usage is implied by the operation name rather than explicitly contrasted with siblings.

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

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

No annotations are provided, so the description must carry the behavioral burden. It explicitly discloses that deletion is permanent and names the affected resource. It does not detail cascading effects or permission requirements, but the key irreversible, destructive behavior is clearly stated.

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

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

The description is compact and front-loaded: the core action appears in the first sentence, and the 'Use when' bullet adds a clear trigger without extra wording. Every sentence earns its place.

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

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

For a simple deletion tool with one required parameter and an output schema, the description covers the essential invocation context. It could mention the distinction from remove_webhook_resource, but the current description plus schema provides enough information for an agent to use the tool correctly.

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

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

Schema description coverage is 100%, and both parameters (api_key and webhook_id) are already documented in the schema. The description adds no parameter-level meaning or format guidance, so the baseline of 3 applies.

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

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

The description opens with 'Permanently delete a webhook endpoint,' which is a specific verb-resource pair and makes the destructive nature explicit. It clearly distinguishes this from update_webhook, create_webhook, and remove_webhook_resource.

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 'Use when' block provides a clear condition: 'You want to remove a webhook from your account.' It gives the agent a trigger context, though it does not explicitly mention when not to use this tool or name the closest alternative such as remove_webhook_resource.

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 discloses both the primary effect (stop scheduled runs) and an important behavioral trait (the operation is reversible via enable_monitor). It does not state whether currently executing runs are affected or whether any confirmation is required, but the core behavior is transparent.

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

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

Two short sentences with no filler. The primary purpose is first, and the reversibility note is second. Every word earns its place.

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

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

For a single-required-parameter, simple mutation tool with an output schema, the description covers the necessary context: what it does, and how it relates to enable_monitor. Nothing essential is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents monitor_id and api_key. The description adds no new parameter-level semantics, which is acceptable given the schema's completeness. 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 action: disabling a monitor to stop its scheduled runs. It also anchors the tool relative to its obvious inverse sibling 'enable_monitor', removing ambiguity about what disabling means versus deleting or updating.

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 communicates when to use the tool: when the monitor's scheduled runs should stop but the monitor should remain available for later use. It does not explicitly contrast with delete_monitor or list conditions, but the reversible framing provides sufficient context for an agent to choose this over destructive 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?

With no annotations, the description carries the full behavioral burden. It conveys the state transition and scheduling impact, but does not mention edge-case behavior such as calling on an already-enabled monitor, idempotency, or permission requirements.

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

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

A single sentence that front-loads the verb and resource, then adds the one behavioral consequence that matters. There is no filler or repetition.

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

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

For a simple enable operation with full parameter coverage and an output schema available, the description plus schema is sufficient for an agent to invoke it correctly. It lacks deeper edge-case guidance, but that is not essential here.

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

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

Schema description coverage is 100%, so the schema already documents monitor_id, api_key, and backfill. The description does not add parameter-specific meaning beyond what the schema provides, 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 uses a specific verb ('Enable') and resource ('previously disabled monitor') and explains the consequence: resume scheduled runs. It clearly distinguishes itself from sibling tools like disable_monitor and update_monitor.

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 usage condition is clear: use it for a disabled monitor that should resume scheduled runs. However, it does not explicitly name alternatives or exclusion cases, so it stops short of full routing guidance.

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

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

No annotations are present, so the description carries the full burden. 'Get' implies read-only, but it does not disclose authentication requirements, what happens for invalid/unknown dataset_id, error behavior, or any side effects. This is minimal for a no-annotation tool.

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

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

The description is a single, front-loaded sentence with no filler or repetition. It is concise but leans on the tool name; no structural issues.

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 one required parameter, one optional parameter, and an output schema present, the description plus schema are largely sufficient for simple retrieval. The main gaps are the lack of usage guidance and behavioral caveats, but the tool's low complexity keeps the definition from being incomplete.

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

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

Schema description coverage is 100%: api_key and dataset_id are both described in the schema. The description adds no parameter-level information beyond saying 'details', so it doesn't exceed the schema baseline.

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

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

States a clear verb and resource ('Get... dataset') and the cardinality 'single' distinguishes it from list_datasets and get_dataset_status. However, 'details' is vague and it doesn't explicitly call out sibling tools or what subset of fields is returned.

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 'single' implies this is for retrieving one dataset rather than listing/searching, and the sibling list_datasets is a natural alternative. But there is no explicit when-to-use, when-not-to-use, or mention of get_dataset_status, so the guidance is implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It only says 'Get', implying a read-only operation, but does not mention authentication, rate limits, error conditions, pagination, or any side effects. For a tool with no annotations, this is a significant gap.

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

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

The description is a single, efficient sentence that front-loads the verb and resource and includes a relevant example. Every word adds value, with no redundancy or filler.

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

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

For a simple get tool with an output schema, the description is adequate but not exhaustive. It explains the core purpose (status history) and gives an example, but does not clarify what statuses are included or any edge cases. Given the output schema likely covers return details, this is a reasonable score.

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% description coverage for both parameters (dataset_id and api_key), so the schema itself documents them adequately. The tool description adds no extra parameter semantics beyond what the schema already provides, which meets the baseline for high 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 action (get) and resource (dataset status history), and the phrase 'status history' plus 'over time' distinguishes it from a simple current-status lookup. However, it does not explicitly name a sibling tool to contrast with, so it is clear but not fully differentiated.

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

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

The description implies when to use it (to track enrichment progress over time) but provides no explicit guidance on when not to use it or what alternative tools (e.g., get_dataset, get_job_status) are better suited. The context is clear but lacks 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 behavioral disclosure burden. 'Get' implies a read operation with no side effects, but the text does not state what happens for a missing entity, auth requirements, or that no data is modified. It is minimally transparent but not 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 one concise sentence with no filler or redundant phrasing. The core purpose is stated immediately and completely.

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

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

For a simple two-parameter read tool with a full input schema and an output schema, the description is mostly sufficient. The only notable gap is the lack of explicit routing guidance versus list_entities and minor behavioral caveats.

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 both entity_id and api_key are already documented in the input schema. The description adds no extra parameter-level nuance, so the baseline score 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 specific verb ('Get') and resource ('single entity's details'), and the singular scope clearly distinguishes it from sibling bulk operations like list_entities. Even though no sibling is named, the purpose is instantly recognizable.

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 list_entities for bulk retrieval or create/update/delete for mutations. The word 'single' hints at scope but does not give an explicit usage rule or exclusion.

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 and does so thoroughly. It discloses the full status progression, expected latency ranges, partial-result availability during 'enriching', how to detect whether more results may appear via 'progress_validated < candidate_records', and recovery behavior using the same job_id after transport/session failure.

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 longer than average but every sentence earns its place: it front-loads the core purpose, then organizes polling cadence, terminal states, partial-result behavior, and failure recovery into logical sections with no filler or repeated schema content.

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

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

Given the moderate complexity of job-status polling, the description covers everything an agent needs: when to call, how often to poll, which states are active vs terminal, when partial results are available, how to coordinate with pull_results, and how to resume. An output schema is flagged as present, so enumerating return fields is unnecessary.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful context for job_id by confirming it comes from submit_query and that the same job_id should be reused to resume after failures, which goes slightly beyond the schema. api_key is adequately covered by the schema itself.

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

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

The description opens with a specific verb and resource: 'Check the status of a submitted job.' It further clarifies this is the post-submit polling tool by stating 'Call this after submit_query', which distinguishes it from siblings like get_dataset_status, get_monitor_status, and pull_results.

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

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

The description gives explicit timing guidance ('First check after ~1-2 minutes, then poll every 30-60 seconds'), terminal conditions ('Stop polling when status is completed or failed'), active states to continue polling, and explicit anti-patterns ('Do NOT call this tool in a tight loop'). It also tells the user when to use pull_results instead, covering the key alternative workflow.

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 implies a read-only operation by stating 'get status history' and 'timeline', but it does not explicitly state that no mutations occur, nor does it disclose any error handling, rate limits, or auth specifics beyond what the schema already notes. This is adequate for a simple get, but lacks explicit safety disclosure.

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

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

The description is two sentences long, with the core purpose front-loaded and the 'Use when' guidance immediately following. Every word earns its place; there is no fluff or redundancy.

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

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

An output schema is present (though not shown), so the description need not explain return format. For a simple read tool with one required parameter, the description covers the purpose and usage scenario adequately. It does not mention pagination or limits, but given the simplicity, this is a minor gap.

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

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

Schema description coverage is 100%, with both api_key and monitor_id having clear descriptions. The description adds no additional meaning beyond what the schema provides, so the baseline of 3 applies. It does not elaborate on format or usage nuances.

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 the status history of a monitor.' This is a specific verb-resource pair that distinguishes it from other monitor-related tools (list_monitors, enable_monitor, etc.). It even clarifies it provides a timeline of state changes, which is unique.

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 includes an explicit 'Use when' section that specifies the intended scenario: viewing the timeline of a monitor's state changes. It does not mention alternatives or when not to use, but the context is clear enough for an agent to select this tool over siblings like list_monitor_jobs.

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

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

With no annotations, the description must carry the behavioral burden. It communicates that this is a read-only fetch of one project's details, and an output schema covers return shape. However, it does not mention authentication expectations, error behavior, or edge cases.

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 states the resource and scope immediately and earns its place.

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

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

The tool is simple, and the schema plus output schema cover most invocation needs. However, the ambiguity with get_project_overview and list_projects is not addressed, so an agent may not reliably know which tool fits a given request.

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

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

Schema description coverage is 100%, so the parameters are already adequately documented. The description adds no additional meaning beyond what the schema provides, which aligns with the baseline score for high 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 uses a clear verb and resource, 'Get a single project's details,' which accurately conveys what the tool does. However, it does not differentiate this tool from siblings like get_project_overview or list_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?

There is no guidance on when to choose this tool over alternatives. The phrase 'a single project' implies a use case, but the description never names or contrasts get_project_overview or list_projects, leaving the agent to infer selection criteria.

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 does not explicitly state read-only semantics, permissions, error behavior, or whether the overview is computed fresh, though the 'Get' verb and counts framing imply a read operation. This is adequate but not rich 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?

A single sentence with no filler; the parenthetical clarification about counts grouped by type and status earns its place. The action verb is front-loaded, immediately telling the agent what will happen.

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 only one required parameter and an output schema present, the description plus schema is sufficient for an agent to invoke the tool correctly. It does not cover error cases or alternative selection, but for a simple read-only overview the missing detail is minor.

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 both api_key and project_id already described in the schema, so the baseline is 3. The description adds no parameter-specific detail beyond indicating that project_id identifies which project's overview to retrieve.

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 ('Get'), a clear resource ('a project's resource overview'), and defines the output as 'counts grouped by resource type and status'. This differentiates it from siblings like get_project and list_project_resources.

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

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

The description implies the tool is for retrieving aggregate overview data, but it does not explicitly state when to prefer it over alternatives such as get_project or list_project_resources, nor does it provide exclusion criteria. The usage context must be inferred rather than stated.

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

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

With no annotations provided, the description carries the full burden. 'Retrieve' implies a read-only operation but does not explicitly state that no data is modified or that it only reads usage data. It adequately conveys the non-destructive nature via the verb 'retrieve', but lacks explicit safety statements or any discussion of potential side effects (none expected).

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: one main sentence followed by two bullet points. It front-loads the purpose, and every sentence adds value. No redundancy or unnecessary 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 tool's simplicity, an output schema is present (so return values are covered), and the description clarifies both the function and appropriate usage. Nothing critical is missing for an agent to correctly invoke this getter 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 provides a full description of the api_key parameter, including its optionality and alternative authentication methods (header or env var). The description does not add extra meaning beyond that, so the baseline of 3 for full schema coverage 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 (retrieve) and the resource (plan features and usage limits) for a specific subject (your API key). It is distinct from all sibling tools, which focus on datasets, projects, monitors, and webhooks, not user limits.

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 'Use when' section explicitly lists two concrete scenarios: checking plan allowances and verifying usage before running a large job. This gives clear guidance on when to call the tool, and because no sibling tool covers the same functionality, alternatives are unnecessary.

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 adds meaningful behavioral detail: the tool maps to a GET endpoint and does not require an API key, which signals a read-only, unauthenticated operation. It could mention that providing an optional api_key is allowed but unnecessary, yet the schema already makes that parameter optional with a default.

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

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

Two sentences with no filler: the core purpose is front-loaded, followed by the key behavioral detail about authentication. Every sentence earns its place, and the description is appropriately sized for a simple version-check tool.

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

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

For a tool with one optional parameter and an output schema present, the description is complete. It tells the agent what the tool does, how it maps to the HTTP API, and whether authentication is needed. No critical information for correct invocation is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces that no API key is required, which clarifies the optional parameter's semantics, but it adds no new details beyond what the schema already states. This aligns with the calibration baseline where the schema does the heavy lifting.

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

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

The description states a specific verb ('Get') and resource ('current API version'), which is unambiguous and distinct from all sibling tools. The title and description align exactly, and the scope is clear without needing to inspect the schema.

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

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

The description provides clear context by mapping the tool to GET /version and explicitly stating that no API key is required. This tells an agent when the tool can be used (without authentication) and implies it is a lightweight read operation. It does not explicitly name alternatives, but none are plausible for this unique operation.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It does convey that this is a read operation returning configuration details (URL, method, headers, status), but it does not mention auth requirements, error behavior, or whether the webhook must exist. This is adequate but not rich.

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

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

The description is compact and front-loaded with the primary action, followed by a concise 'Use when' list. Every sentence earns its place, and there is no redundant filler.

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

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

For a simple by-ID retrieval tool with two fully documented parameters and an output schema, the description is adequate. It names the key output concepts and when to use it. It could add a note about authentication fallback or non-existent webhook behavior, but these are minor gaps given the tool's simplicity.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description adds only the contextual point that retrieval is by webhook ID, which does not significantly extend the schema meaning. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Retrieve'), names the resource ('full configuration of a specific webhook'), and clarifies it is identified by 'webhook_id.' This distinguishes it from list_webhooks or get_webhook_history without needing to open the schema.

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

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

The 'Use when' block gives a clear trigger: inspecting a webhook's URL, method, headers, or status by ID. It does not explicitly name alternative tools to avoid, but the by-ID qualifier and the mention of configuration details imply when this tool is the right choice versus listing or history 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?

No annotations are provided, so the description carries the full burden. It discloses that manual test deliveries are included only in webhook mode, a useful behavioral nuance. However, it doesn't explicitly state the operation is read-only, nor does it mention pagination limits or error conditions, though some of these are implied by the 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 concise and well-structured: a clear opening sentence followed by a bulleted list of the two modes. Every sentence serves a purpose, and the key information is front-loaded.

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

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

Given the tool's complexity (two modes, mutual exclusivity), the description covers all critical usage aspects. The schema documents parameter details, and the output schema documents the return format. Nothing essential is missing for an agent to call this tool correctly.

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

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

Schema coverage is 100%, so all parameters are documented. The description adds significant value by explaining the two modes, the relationship between resource_type and resource_id, and the mutual exclusivity with webhook_id. It also clarifies that manual test deliveries only appear in webhook mode, which is not in the schema.

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

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

The description clearly states the tool retrieves webhook delivery history and distinguishes two query modes: by resource (resource_type + resource_id) or by webhook (webhook_id). This is specific and differentiates it from siblings like get_webhook (which likely fetches webhook configuration) and list_webhooks.

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

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

The description explicitly instructs to query in exactly one of two modes and explains when to use each, including a note that manual test deliveries only appear in webhook mode. It doesn't explicitly name alternative tools or state when not to use this tool, but the guidance is clear and actionable.

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

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

With no annotations, the description carries the full burden and fully meets it: it discloses that the endpoint is preview-only, does not create a job or start processing, produces non-deterministic LLM-generated suggestions, and does not persist them (they must be passed explicitly to `submit_query`). This is exactly the behavioral context an agent needs.

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 one-sentence summary is front-loaded, and the Use when / Do not use when / Key behavior sections are tight bullet lists. No sentence is filler; the layout lets an agent scan intent, exclusions, and behavioral caveats quickly.

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

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

The description is complete for a preview tool: it covers selection intent, the key alternative, side-effect profile, non-determinism caveat, and reuse path. An output schema exists, so not restating return values is acceptable, and no required behavioral or usage context appears missing.

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

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

Input schema coverage is 100%, so the schema already documents all four parameters and their detailed constraints. The description does not add parameter-level meaning beyond mentioning `date_modification_message`, which appears to be an output rather than an input; 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?

Opens with a specific verb and object: 'Preview suggested validators, enrichments, and date ranges before submitting.' It reinforces the scope with 'preview-only endpoint' and explicitly distinguishes itself from the processing-oriented sibling `submit_query`, so an agent can tell them apart by intent.

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 'Use when' conditions for inspecting/editing suggestions and previewing date adjustments, plus a 'Do not use when' condition that routes to `submit_query` for immediate processing. This gives an agent clear decision criteria rather than leaving the choice to inference.

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

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

With no annotations provided, the description carries the full burden. It only states the action without disclosing behavior such as pagination, filtering, read-only nature, or response structure. The schema covers parameters, but the description adds no behavioral 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 clear sentence, front-loaded with the core action. 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 rich schema with 100% parameter coverage and an output schema, the description is sufficient for the core purpose. It doesn't mention optional filters, but those are in the schema. Adequate.

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

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

Schema description coverage is 100%, so parameters are already documented. The description doesn't add any extra meaning about parameters, but doesn't need to since the schema is thorough. Baseline 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 action (list) and the resource (entities within a dataset), distinguishing it from siblings like list_entities and list_datasets. It is 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 on when to use this vs alternatives like list_entities or get_entity. The description does not mention any conditions or exclusions, so an agent must infer the intended use from the name alone.

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

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

Annotations are absent, so the description must carry the full burden of behavioral disclosure. It provides no information about pagination, filtering, sorting, side effects, or default behavior. The description is nearly a tautology of the title, offering no behavioral context beyond the basic action.

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?

While concise, the description is under-specified. A single sentence with no structure adds no value beyond the title. For a tool with 9 parameters, more detail and structure would be beneficial to guide usage.

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

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

Given the tool's complexity (9 optional parameters) and the existence of an output schema, the description is incomplete. It does not explain how filters interact, default behavior, or what the response contains. The output schema exists but is not referenced or summarized in the description.

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 each parameter having a clear description (e.g., page, search, sort_by). The description adds nothing about parameters. Baseline 3 is appropriate because the schema fully documents parameter semantics.

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

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

The description uses a specific verb 'List' and resource 'datasets', clearly identifying the action. It distinguishes from get_dataset (singular) and list_dataset_entities by resource type, but does not explicitly contrast with sibling tools. It is clear but not fully differentiated.

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

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

No guidance is provided on when to use this tool versus alternatives like list_dataset_entities or list_projects. The description only states the action without any context on selection criteria, prerequisites, or exclusions. The agent is left to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It only says 'List' and does not disclose pagination behavior, default page size, filter combination semantics, read-only guarantees, or any side effects. Listing implies read-only, but the description adds no behavioral depth beyond the 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 short and free of fluff, making it easy to scan. However, it is nearly a restatement of the title and carries very little information, so it is not an exemplary use of the available 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?

With 9 optional parameters Scott, no annotations, and many sibling list tools, the description leaves an agent without enough context about scope, default behavior, or when to choose this tool. The output schema covers return shape, but invocation context is largely missing.

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

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

Schema description coverage is 100%, and every parameter already includes defaults, constraints, and examples. The description itself adds no parameter-level meaning, so the baseline score of 3 is appropriate because the schema does the heavy lifting.

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

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

The description states a clear verb ('List') and resource ('your entities'), so an agent knows the basic operation. However, it does not differentiate from sibling tools like list_dataset_entities or list_project_resources, leaving ambiguity about scope.

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

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

There is no guidance on when to use this tool versus the many list_* siblings. The single-sentence description provides no context about which listing scenario this applies to, no exclusions, and no alternatives.

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

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

No annotations are provided, so the description carries the full burden. It conveys that this is a read-only listing action ('List... Returns...'), which is adequate for a simple retrieval tool. However, it does not disclose details like pagination, result ordering behavior, or whether failed/running jobs are included, so it adds only basic behavioral 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 concise and front-loaded with the core purpose. The second sentence adds useful detail about returning run history, though it slightly repeats 'for a monitor,' preventing a perfect conciseness score.

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

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

This is a simple single-required-parameter listing operation with a full output schema and fully documented parameters. The description covers the essential purpose and scope. It could be slightly more complete by explicitly distinguishing itself from list_user_jobs, but nothing critical is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema fully documents monitor_id, sort, and api_key. The description adds no parameter-level meaning beyond the schema, which matches the baseline expectation for high schema coverage.

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

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

The description uses a specific verb and resource: 'List all jobs spawned by a monitor' and clarifies the return value as 'the history of scheduled runs.' This clearly distinguishes it from list_monitors (which lists monitors) and list_user_jobs (which lists user-level jobs) without needing to inspect the schema.

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

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

The description establishes a clear context: use this tool when you need the jobs associated with a specific monitor. It does not explicitly name alternatives or state when not to use it, but the wording 'all jobs spawned by a monitor' gives enough situational guidance to route an agent correctly.

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

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

With no annotations, the description carries the behavioral disclosure burden. It reveals useful return fields but does not mention pagination behavior, filtering/ownership defaults, authentication requirements, or explicitly state that this is a read-only listing operation. It is not misleading, just incomplete.

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

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

The description is compact and front-loads the core action, with a second sentence adding valuable return-field detail. The first sentence slightly repeats the tool name/title, but overall there is no wasted content.

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

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

Given a fully described 6-parameter schema and the presence of an output schema, the description is adequate for basic invocation. It does not explain pagination or ownership defaults, but those are already covered clearly in the schema, so no critical context is missing.

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

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

Schema description coverage is 100%, so every parameter is already documented in the input schema. The description adds no extra parameter-level meaning, making the baseline 3 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?

States a specific verb+resource ('List all your monitors') and enumerates the returned fields (schedule, status, reference query, webhook config). It is clearly distinct from sibling monitor-related tools, though it does not explicitly contrast itself with list_monitor_jobs or get_monitor_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 implies use when a monitor listing is needed, but it does not explicitly state when to use this tool over alternatives or mention any exclusions. Sibling tools like list_monitor_jobs and get_monitor_status are not referenced, leaving routing largely to inference from tool names.

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. The description only restates that resources are listed and does not mention pagination, the optional resource_type filter, authorization requirements, or whether the result set spans multiple resource types.

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, well-formed sentence with no filler or redundancy. It is concise and front-loaded with the core action, though it could be slightly richer without becoming verbose.

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 input schema covers all parameters and an output schema exists, so an agent can construct a valid call from the structured data alone. However, with no annotations and only a one-sentence description, the tool's pagination behavior, resource_type filter, and relationship to sibling listing tools are left implicit, 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?

Schema description coverage is 100%, so the parameters are already fully documented in the input schema. The description adds no extra meaning beyond reinforcing that the list is scoped to a project, so the baseline of 3 is appropriate.

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

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

The description gives a clear verb ('List') and identifies the object and scope ('resources contained in a project'), so an agent knows immediately what the tool does. It does not explicitly distinguish itself from sibling tools like list_datasets or list_monitors, but 'contained in a project' narrows the focus sufficiently.

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

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

Usage is implied by the phrase 'contained in a project' and by sibling tools such as add_project_resources and remove_project_resource, but no explicit guidance is given about when to prefer this tool over list_datasets, list_monitors, or other list tools. No exclusions or alternative routing 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 does not explicitly state that the operation is read-only or non-destructive, nor does it mention authentication requirements, pagination behavior, or any side effects. The phrase 'List your projects' implies a read operation but does not confirm it, leaving the agent to infer safety.

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 with the core purpose. While extremely brief, it avoids redundancy and is structurally efficient. However, it is so terse that it verges on under-specification, preventing a perfect score.

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

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

The description is minimal but the output schema exists, so return structure is covered. However, it does not mention filtering, pagination, or ownership scoping, which are part of the tool's behavior. The agent must rely on the schema to understand these capabilities. For a list tool with five parameters, the description is adequate but lacks enrichment that would help an agent understand when to use it in different scenarios.

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

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

Schema description coverage is 100%, so all five parameters are already documented with descriptions. The tool description adds no additional meaning about the parameters. Per the rubric, a baseline of 3 is appropriate when the schema fully covers parameter semantics.

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

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

The description states a clear verb and resource: 'List your projects.' This is unambiguous and distinguishes from sibling tools like get_project (singular) and list_project_resources (which lists resources within a project). However, it does not explicitly differentiate itself from other list operations, so it misses the top score.

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. There is no mention of when list_projects is appropriate compared to get_project, list_project_resources, or other list operations. It simply states what it does without context on selection criteria.

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

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

No annotations are provided, so the description carries the burden. It discloses the read-only nature implicitly ('List') and the scoping to a specific resource. However, it doesn't mention pagination behavior, filtering by is_active, or that it returns webhook details vs just IDs. The description is adequate but not rich in behavioral 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 compact and front-loaded: the first sentence states the core function, and the 'Use when' section adds practical guidance. Every sentence earns its place with no redundancy.

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

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

The tool has an output schema and 100% parameter coverage, so the description doesn't need to explain return values or parameters. It provides the key selection context (which resource types, when to use). It could mention pagination or the is_active filter, but these are already in the schema, so the description is complete enough for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all 6 parameters. The description adds the semantic context that resource_id refers to a job/monitor/monitor_group and that the tool answers 'which webhooks will fire for it', which aligns with the schema. Baseline 3 is appropriate since the schema 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 tool's function: listing webhooks mapped to a specific resource, and explicitly names the resource types (job/monitor/monitor_group). It distinguishes itself from sibling tools like list_webhooks and list_webhook_resources by focusing on a specific resource's webhook mappings.

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 a clear 'Use when' section with a concrete condition: having a job or monitor ID and wanting to know which webhooks will fire for it. It doesn't explicitly state when not to use it or name alternatives, but the context is clear enough for an agent to select it appropriately.

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 present, so the description must carry behavioral context. It adds one useful behavioral detail: listing includes 'public groups plus any organization-visibility groups your organization can access.' It does not disclose other behavioral traits like pagination behavior, rate limits, or idempotency, though this is a read-only list operation and the output schema covers return values.

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 front-loads the core definition in one sentence, then adds a compact two-bullet 'Use when' section. Every sentence earns its place: what the tool lists, why it matters, and how the result is used downstream.

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

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

For a simple list operation with all parameters optional and fully documented, the description provides enough context: what a source group is, what visibility scope is returned, and how the slug is consumed by submit_query. The output schema covers the return shape, so no additional return documentation is needed; a note on pagination would be the only minor gap.

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

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

The input schema already documents page, api_key, and page_size with 100% coverage, so the baseline is 3. The description's mention of obtaining a slug for submit_query concerns output data rather than this tool's parameters, so it adds no direct parameter semantics.

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

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

The first sentence states a specific verb ('List') and resource ('source groups'), and defines them as 'named domain allowlists,' which immediately distinguishes this from other list_* siblings. The 'Use when' bullets reinforce that this tool exposes reusable named sets of source domains, so an agent can identify it correctly.

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

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

The description includes an explicit 'Use when' section with two concrete conditions: discovering reusable named sets of source domains and obtaining a group's slug to attach to submit_query via source_groups. It does not list exclusions or alternative tools, but the target use cases are clear and unambiguous.

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 disclosure burden. It accurately states that this is a list/read operation and describes the returned data fields. It does not mention pagination behavior or authentication requirements, and it does not explicitly assert read-only safety, though the verb 'List' makes it reasonably evident.

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

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

The description is two short sentences with no filler. The main action is front-loaded, and the return fields are listed efficiently. Every sentence adds useful information.

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

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

With an output schema present, all parameters optional, and 100% schema coverage, an agent can invoke this tool without additional guidance. The description covers scope and return fields. Minor gaps include not mentioning pagination defaults or how this differs from monitor-job listing, but these are largely covered by the schema and output schema.

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

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

Schema description coverage is 100%, so the parameter schema fully documents all seven optional parameters. The description adds no parameter-specific meaning beyond what the schema already provides, earning the baseline score of 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 uses a specific verb ('List') and resource ('jobs submitted by you') and enumerates the returned fields. It clearly indicates user-owned job history, distinguishing it from single-job status retrieval, though it does not explicitly reference sibling tools.

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

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

The intended context is implied: use when you need your own job history. However, there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives like list_monitor_jobs or get_job_status. Some usage context is present, but the description does not actively route the agent.

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 burden of behavioral disclosure. The verb 'List' and phrase 'see which jobs/monitors' imply a read-only operation, but the description does not explicitly state side-effect safety, pagination behavior, or the exact shape of the returned mapping. It is adequate for a simple read tool but adds little beyond the tool name and 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 two short sentences with no filler. The core action is front-loaded, and the 'Use when' block is immediately useful. Every word 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 output schema exists and all parameters are already well documented, the description covers the essential decision-making context. It could be slightly stronger by explicitly mentioning monitor_group (since the resource_type filter supports it) or by routing the inverse operation to list_resource_webhooks, but the current description is sufficient for correct invocation in most cases.

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

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

The input schema already describes all five parameters with 100% coverage, so the baseline is 3. The description adds minimal extra semantic value beyond noting that the webhook is attached to jobs/monitors, which loosely maps to the resource_type filter. It does not clarify formats, defaults, or relationships beyond what the schema already provides.

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

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

The description uses a specific verb and resource: 'List the resources mapped to a webhook.' This clearly identifies the operation and distinguishes it from sibling tools like list_webhooks (which lists webhooks) and list_resource_webhooks (which would map in the opposite direction). The added detail about jobs/monitors further pins down the resource scope.

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

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

The description gives an explicit 'Use when' condition: wanting to see which jobs/monitors a webhook is attached to. This clearly frames the appropriate context. It does not explicitly name alternatives or state when not to use this tool, so it stops short of full exclusion guidance.

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

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

No annotations are provided, so the description carries the burden. 'List all your webhooks' transparently implies a read operation with no side effects, which is adequate for a simple listing tool. It does not disclose pagination behavior or sorting, but these are already covered by the input schema and output schema, so no serious gap exists.

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

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

The description is compact: a one-sentence purpose statement followed by a concise 'Use when' bullet list. Every sentence earns its place, and the most important information is front-loaded.

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

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

For a simple list operation with no required parameters, a fully detailed schema, and an output schema, the description is nearly complete. It explains what the tool does and when to use it. It could be more complete by explicitly contrasting with resource-scoped webhook tools, but this is not a significant gap.

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

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

Schema description coverage is 100%, so all four parameters (page, api_key, page_size, project_id) are already documented in the schema. The description adds no additional parameter-level semantics beyond stating the use case for finding webhook_id.

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

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

The description states a specific verb and resource: 'List all your webhooks', and clarifies scope with 'configured in your account'. This clearly distinguishes it from single-webhook retrieval (get_webhook) and resource-scoped listing (list_resource_webhooks) by emphasizing the account-wide scope.

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

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

The 'Use when' section explicitly gives two concrete scenarios: viewing all webhook endpoints and finding a webhook_id for monitors/jobs. It provides clear context for when to call this tool, though it does not explicitly state when not to use it or name alternative 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?

No annotations are provided, so the description bears the full burden. It clearly communicates the operation is a safe-looking download, but does not disclose details like required job completion state, file encoding or naming, or what happens if the job has no results. The core behavior is clear enough for a simple read-style 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 compact and well-structured: one clear opening sentence followed by two focused bullets. Every sentence contributes functional guidance, and the key usage criteria are front-loaded.

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

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

With an output schema present, full schema coverage, and a simple two-parameter interface, this description covers the essential usage context. It misses a small amount of operational nuance, such as whether the job must be completed or whether the CSV includes headers, but nothing critical blocks 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?

Schema description coverage is 100%, with both `job_id` and `api_key` documented. The description adds no extra parameter-level detail, but the schema already fully explains the parameters, so the baseline score of 3 is appropriate.

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

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

States a specific verb ('Download'), a resource ('a job's results'), and an output format ('CSV'). The phrase 'full job output' makes the scope clear unless the agent needs a different format. It effectively distinguishes itself from sibling pull tools.

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

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

Explicitly provides 'Use when' conditions and names the alternative `pull_results`, including the exact condition for preferring this tool (spreadsheet/CSV format). This gives concrete routing guidance with minimal 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?

With no annotations, the description must carry the behavioral disclosure burden. It states that the tool returns the latest monitor run and formats it as CSV, implying a read-only download, but it does not mention what happens when no runs exist, whether results are filtered by date, or any auth/rate-limit behavior. This is adequate but lacks richer 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 first sentence states the action and outcome succinctly, and the bullets add only necessary usage context. Every sentence earns its place; there is no redundancy or filler.

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

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

The tool is simple, has an output schema, and the description covers the CSV format and when to select it over a sibling. Missing details such as empty-result behavior and explicit read-only confirmation are minor, but given the absence of annotations, the description is strong but not maximally 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 description coverage is 100%, so the schema already documents both `monitor_id` and `api_key`. The description does not add parameter-level meaning beyond the implied 'latest run for the given monitor' context, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb ('Download') and identifies both the resource ('latest monitor run's results') and the output format ('CSV file'). It also differentiates the tool from `pull_monitor_results` by explicitly framing it as the CSV-format variant, making the purpose unmistakable.

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

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

The 'Use when' bullets provide explicit conditions: most recent monitor run output, CSV format, offline analysis/export. It also directly instructs to prefer this over `pull_monitor_results` when the consumer needs spreadsheet/CSV format, giving clear routing guidance versus an alternative.

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

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

No annotations are provided, so the description carries the full burden. It states the tool 'retrieves' results, implying a read operation, but does not disclose any permissions, rate limits, or side effects. It does mention the return structure (run_info, records, all_records), which adds some transparency, but lacks explicit behavioral context.

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

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

Two concise sentences: the first states the primary action, the second details the return fields. The content is front-loaded and there is no fluff or redundant information.

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

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

The tool is simple with one required parameter and an output schema. The description covers the basic purpose and return fields. However, it lacks any mention of when to choose this over similar sibling tools like pull_results or pull_monitor_csv, leaving a gap in agent decision-making.

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?

Both parameters are fully described in the schema (100% coverage). The description adds no additional meaning, examples, or format details beyond what the schema already provides, so it contributes nothing extra for the parameters.

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

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

The description clearly states the action ('Retrieve the latest results from a monitor') and specifies the return fields (run_info, records, all_records). It is a specific verb+resource. However, it does not explicitly differentiate from sibling tools like pull_results or pull_monitor_csv, so it is clear but not fully distinguished.

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

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

No guidance on when to use this tool versus alternatives like pull_results or pull_monitor_csv. The description does not mention any selection criteria, exclusions, or context that would help an agent decide when to call 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 carries the full burden. It discloses partial-result semantics, pagination behavior tied to job state, and failure-mode handling — all non-obvious behaviors an agent needs to know. It does not mention rate limits or auth specifics, but the api_key parameter in the schema covers authentication, so the remaining gap is minor.

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?

Front-loaded purpose in the first sentence, followed by well-organized lifecycle usage guidance. Roughly 90 words for a paginated, state-dependent retrieval tool is appropriately economical. Every sentence earns its place, though the three usage sentences could arguably be tightened without losing meaning.

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

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

Complete for a tool of this complexity. The description covers call timing, partial results, pagination strategy, and failure handling, while the output schema covers return values and the schema covers parameters at 100%. Nothing an agent needs to invoke this tool correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds context around pagination ('iterate all pages', 'typically page=1') that reinforces the page parameter's role, but it doesn't add syntax or format details beyond what the schema already documents. The description and schema together are coherent, though neither exceeds the other's contribution.

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

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

Opens with a specific verb and resource: 'Retrieve the results of a job.' The description also names the payload ('clustered, validated, and enriched web results'), which distinguishes this from sibling pull_job_csv (CSV format) and pull_monitor_results (monitor context). An agent can immediately tell what this tool does and how it differs from its siblings.

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

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

Provides explicit lifecycle guidance: call before completion for partial results, after completion for the full set, repeatedly while active, iterate all pages at completed, and once more on failure. This is precisely the kind of when-to-call instruction that prevents agent misuse, and it maps directly to the job lifecycle an agent will be driving via submit_query and get_job_status.

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 does disclose the critical trait that entities themselves are not deleted, which adds real value beyond the tool name. However, it does not mention other behavioral aspects such as whether the operation is idempotent, whether it affects dataset metadata, or what happens if an entity_id does not exist in the dataset.

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 well-structured sentence with the key non-deletion caveat placed in a parenthetical. Every word earns its place, and the essential distinction is front-loaded without any redundant phrasing.

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, the schema covers all parameters, and an output schema exists, so the description does not need to explain return values. The core behavioral distinction is captured. The only minor gap is the absence of explicit guidance on when to use this versus delete_entity or add_dataset_entities, but for a straightforward removal operation the description is largely sufficient.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters clearly. The description does not add any parameter-specific detail beyond what the schema provides, which meets the baseline but does not exceed it.

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

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

The description states a specific verb ('Remove') and resource ('entities from a dataset'), and the parenthetical clarifies that this removes the association rather than deleting the entities themselves. This clearly distinguishes the operation from delete_entity and delete_dataset, leaving no ambiguity about the tool's 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 parenthetical implies that if you want to permanently delete entities, you should use a different tool (e.g., delete_entity), but it does not explicitly name alternatives or state when this tool should be preferred over siblings like add_dataset_entities. The usage context is implied rather than stated.

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