Trillboards DOOH Advertising

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. It reveals important traits: activation_key expires in 24 hours, IAB segments are only emitted when registered IDs are explicitly supplied, and free-form labels remain custom parameters. It also outlines the return structure.

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

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

The description is well-organized with clear sections (purpose, when-to-use, returns, example) and front-loaded with the primary action. It is slightly long but each section contributes useful information without unnecessary 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?

Given there is no output schema, the description compensates by detailing return fields (activation_key, targeting, screen_count, etc.) and providing a concrete example. It covers the tool's core behavior, though it omits edge cases like invalid IAB IDs or error handling.

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 top-level properties with descriptions, but nested enums like income and purchase_intent lack descriptions. The description adds value through an example and the IAB caveat, but does not systematically explain each parameter 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 opens with 'Activate an audience signal for DSP targeting,' which clearly states the specific action (activate), the resource (audience signal), and the intent (DSP targeting). It also mentions returning an activation_key, further distinguishing it from sibling tools like get_signals or semantic_audience_search.

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 'WHEN TO USE' section lists three concrete scenarios, such as converting signals into targeting parameters and activating registered IAB segments. It provides clear context for when to invoke the 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?

With no annotations provided, the description carries the full burden and does well: it discloses the algorithmic behavior (trailing mean/stddev, z-score), computes baseline statistics, and describes the return payload. It doesn't explicitly state side-effect safety, but the focus on detection and returns implies a read-only 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 structured into clear sections (purpose, when to use, returns, examples) and every sentence contributes value. It is longer than average but appropriate given the tool's complexity and the absence of an output 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?

The description fully compensates for missing annotations and missing output schema by detailing return values, providing example invocations, and explaining the detection logic. It is complete enough for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful context beyond the schema by explaining how parameters like metric, lookback_hours, and threshold_sigma interact in examples, but it doesn't provide per-parameter semantics beyond what the schema already offers.

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 ('Detect anomalies') and clearly identifies the resource ('observation patterns'), making the tool's purpose explicit. It distinguishes from siblings like predictive_query by focusing on statistical outlier detection in observation data.

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 'WHEN TO USE' section lists concrete scenarios such as monitoring audience patterns and detecting equipment anomalies, providing clear usage context. It does not explicitly name alternative tools or state when not to use this tool, but the context is strong enough to guide selection.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It discloses the request limit (up to 100), the return fields (success, processed, failed, total_earnings, errors), and the offline sync scenario, implying partial failures and earnings crediting. This goes beyond a minimal description, though it could mention idempotency or authentication details.

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

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

The description is well-structured with separate sections for purpose, usage, returns, and an example. It is somewhat long but every section adds value, and the example is useful for illustrating the expected input. No superfluous content is present.

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

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

The tool has a single parameter with a nested object structure, no output schema, and no annotations. The description compensates by detailing the return values and providing an example. It adequately covers the essential usage context, but could elaborate on error handling or idempotency for full completeness.

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

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

The input schema already provides descriptions for all properties, achieving 100% coverage. The description adds an example illustrating the array structure, but it does not explain parameter meanings beyond what the schema offers. Since schema coverage is high, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool records multiple impressions in a single request with a limit of 100. This distinguishes it from the sibling 'record_impression' tool which likely handles one at a time. The verb 'record' and resource 'impressions' are specific and unambiguous.

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

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

The 'WHEN TO USE' section explicitly provides three use cases: bulk reporting, efficient batch processing, and offline sync. This gives clear context on when to invoke this tool. It does not name alternatives explicitly, but the context naturally differentiates it from single-record operations.

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. It does disclose the key mutation behavior: 'optionally pushes a sensing profile to the device' and includes deployment_status values (generated, pushed, push_failed). However, it stops short of explaining consequences like overwriting existing profiles, permission requirements, or reversibility of a push.

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

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

The description is well-structured with clear sections (overview, when to use, returns, examples) and front-loaded with a concise first sentence. While longer than the get_calls example, the length is justified by the tool's complexity and the detailed return fields. No extraneous fluff.

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

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

Despite having no output schema, the description enumerates all return fields (profile details, metadata, deployment status, suggested queries) and provides two examples covering both auto_deploy outcomes. This gives the agent sufficient understanding of expected output and side effects for a complete interaction.

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

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

Schema coverage is 100% with each parameter described. The description adds value by providing concrete example intent strings and clarifying auto_deploy behavior through examples (false for review, true for direct push). This goes beyond the bare schema 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 uses a specific verb 'configure' with a clear resource: 'what a screen should sense using natural language' and specifies the outcome (generates and optionally pushes a sensing profile). This clearly distinguishes it from the many read-oriented sibling tools like get_signals or get_device.

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 'WHEN TO USE' section provides four concrete scenarios (setting up a new screen, changing detection, custom events, translating business intent), giving solid context for when to invoke this tool. However, it does not explicitly state when not to use it or mention alternatives, which prevents a top score.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It goes beyond the schema by noting that campaigns start in 'draft' status and must be activated via update_campaign, and it lists the return fields (campaign_id, name, status, budget, screen_count, dates). This is meaningful behavioral context, though it doesn't cover auth requirements or potential errors.

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

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

The description is well-structured with clear headings (summary, WHEN TO USE, RETURNS, example) and is front-loaded with the primary purpose. Every section earns its place, and the example is appropriately detailed without being bloated.

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 (12 parameters, nested targeting objects) and the absence of an output schema or annotations, the description covers key aspects: the draft status lifecycle, return values, and a realistic invocation example. This provides sufficient context for an agent to select and invoke the tool correctly.

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

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

The schema already provides 100% description coverage for all 12 parameters, so the baseline is 3. The description adds a concrete example showing how parameters combine in practice (e.g., nested targeting with geo and venue_types), which clarifies correct usage beyond individual schema descriptions. This justifies a 4.

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

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

The description starts with a clear, specific verb and resource: 'Create a new advertising campaign targeting DOOH screens.' This distinguishes it from sibling tools like create_media_buy or create_experiment by explicitly naming the campaign object and the DOOH 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?

The 'WHEN TO USE' section provides clear scenarios (setting up campaigns, targeting venues/locations/audiences, allocating budget) and explicitly points to update_campaign for a follow-up action. However, it does not explicitly state when not to use this tool or mention alternative tools like create_media_buy, 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 must carry behavioral disclosure. It states that the tool creates an experiment and returns an object, and explains the causal measurement intent. However, it does not mention side effects, whether the operation is synchronous, permission requirements, or reversibility. 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 front-loaded with the core purpose, followed by a focused WHEN TO USE section, RETURNS, and a compact EXAMPLE. Every section 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?

Given the tool's moderate complexity (8 params, no output schema, no annotations), the description covers purpose, usage context, return object, and a full example. It does not mention error conditions or prerequisites (e.g., campaign must exist), but overall it provides sufficient operational context.

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

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

Schema coverage is 100% with descriptive defaults and ranges. The description adds a concrete example showing how campaign_id, experiment_type, treatment_dmas, control_dmas, holdout_pct, and target_mde fit together. This goes beyond the schema and helps the agent construct a valid invocation.

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 states a specific action: 'Create an incrementality experiment for a campaign.' It then names the three experiment types (geo-holdout, ghost ads, PSM), clearly distinguishing this from sibling tools like create_campaign and get_incrementality. The verb+resource 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?

A dedicated 'WHEN TO USE' section lists clear scenarios (setting up A/B test, defining treatment/control DMAs, configuring parameters). It does not explicitly mention when not to use it or name alternative tools, but the context is sufficient to guide selection.

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

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

With no annotations, the description is the sole source of behavioral transparency. It discloses return values (media_buy_id, campaign_id, creative_deadline, etc.) and the overall action, but it does not mention potential side effects (e.g., billing), validation rules, or the distinction between legacy buy_spec and the newer packages parameter. This is adequate but 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 well-structured with clear sections: purpose, WHEN TO USE, RETURNS, and EXAMPLE. It is longer than necessary but the example is instructive and the structure makes it easy to scan. It could be trimmed slightly without loss, hence 4.

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 10 parameters with nested objects, no output schema, and no annotations. The description compensates by listing return fields and providing an example, but it omits important context about the two distinct parameter paths (legacy buy_spec vs. packages) and does not clarify which parameters are needed for a valid request. This is a notable gap for a complex tool.

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

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

Schema description coverage is 70% and the description adds an illustrative example showing nested parameter usage for name, buy_spec, creative, and buyer_ref. However, it does not clarify the relationship between buy_spec (labeled 'legacy' in the schema) and packages, or explain total_budget and brand fields. The example adds value but leaves ambiguity around the two competing parameter structures.

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

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

The description clearly states the verb 'create' and the resource 'media buy (campaign)' with a specific target 'DOOH screens', distinguishing it from sibling tools like create_campaign. The phrase 'from an AdCP buy specification' adds specificity and aligns with the tool's 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 'WHEN TO USE' section explicitly lists three scenarios: programmatic DOOH buy via AI agent, DSP trading desk agents, and automated media buying workflows. This provides clear context, but it does not mention when not to use this tool or alternative tools, preventing 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 what the tool does (creates a webhook), lists available events, and describes the return payload including the HMAC secret. However, it omits important behavioral details such as authentication requirements, idempotency, whether duplicate webhooks are allowed, or error conditions that might occur. The addition of the 'RETURNS' section adds some context, but the description could be more transparent about side effects and prerequisites.

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 structured with clear headers (WHEN TO USE, AVAILABLE EVENTS, RETURNS, EXAMPLE) and the main purpose is front-loaded in the first sentence. It is longer than a simple one-liner but every section adds useful context. The example is valuable, and the return fields are clearly listed. Slight redundancy exists between the example and the parameter list, but overall it is well-organized.

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 no output schema, the description's 'RETURNS' section is critical and it provides a clear list of output fields. The tool has 4 parameters, and the description explains typical usage, events, and gives a concrete example. It does not cover error handling, rate limits, or edge cases, but for a create operation with good schema support, it is reasonably 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 each parameter already has a description in the schema. The tool description adds an example and repeats the secret explanation, but it does not significantly augment the schema. Moreover, the 'AVAILABLE EVENTS' list in the description is a partial subset of the enum values in the schema, which could mislead an agent into thinking only those 9 events are supported rather than all 26 in the enum. This is a minor detractor, keeping it at baseline rather than higher.

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

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

The description clearly states the tool's purpose: 'Create a new webhook subscription for real-time events.' The verb 'create' plus resource 'webhook subscription' is specific and distinguishes it from siblings like update_webhook, delete_webhook, and test_webhook. It also includes detailed event categories and return fields, leaving no ambiguity.

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

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

A dedicated 'WHEN TO USE' section explicitly lists relevant scenarios: 'Setting up real-time notifications for device events', 'Integrating with external systems', and 'Monitoring ad playback and impressions'. This provides clear context, but does not mention exclusions or alternatives (e.g., update_webhook for modifying existing webhooks), hence not 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 transparency burden. It discloses that the tool queries a pre-computed table or computes ad-hoc correlations, and details the exact return structure. It doesn't mention auth requirements or rate limits, but the read-only nature is strongly implied through 'queries' and 'computes.'

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

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

The description is well-structured with clear sections: intro, WHEN TO USE, RETURNS, and EXAMPLE. Each section earns its place, and the front-loaded purpose ensures immediate understanding. No irrelevant details or 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 has no output schema, yet the description thoroughly documents all return fields (correlation_r, p_value, metadata, etc.) and includes examples. It covers purpose, usage, return format, and parameter illustrations, making it complete for an agent to select and invoke the tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value with concrete example values for signal_a and signal_b (attention_score, ad_fill_rate) and shows how to use filters (venue_type, daypart). This goes beyond the schema's enum-like examples, warranting a 4.

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

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

The description clearly states the tool's purpose: 'Discover correlations between different signal types,' with a concrete example. It distinguishes itself from sibling tools by focusing on cross-signal correlation analysis, and the verb+resource pairing is specific and actionable.

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

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

A dedicated 'WHEN TO USE' section enumerates four clear scenarios (understanding relationships, finding hidden patterns, etc.) and includes two full examples. However, it does not explicitly name alternative tools or state when not to use this tool, so it falls just short of a perfect score.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states 'Soft-delete', indicating non-permanent deletion, and lists return fields (success, device_id, message) plus an example. This adds valuable context beyond a simple 'delete' term, though it does not address permissions or recoverability nuances beyond the soft-delete label.

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 with clear sections (definition, WHEN TO USE, RETURNS, EXAMPLE). The first sentence delivers the core purpose, and each subsequent section provides justifiable detail without redundancy. It is an ideal length for a single-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?

For a single-parameter delete tool with no annotations or output schema, the description covers the essential context: use scenarios, return values, and a usage example. It is sufficiently complete for an agent to select and invoke the tool, though it could briefly elaborate on the implications of soft-delete (e.g., whether the device remains visible in list_devices).

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 fully describes device_id as 'Your internal device identifier to delete' with length constraints, so the baseline for parameter semantics is met. The description's example uses a concrete identifier but does not add new semantic detail beyond the schema. There is no ambiguity introduced.

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 'Soft-delete a device from the partner account', which clearly identifies the action and resource. The 'soft-delete' nuance adds specificity beyond just 'delete', and the WHEN TO USE list further clarifies its scope. This distinguishes it from other tools in the same domain, such as delete_webhook.

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 WHEN TO USE section provides three concrete scenarios (decommissioned devices, test cleanup, relocation) that give explicit context for when to invoke the tool. However, it does not mention when not to use it or cite alternatives like a hard-delete or re-registration tool, so it lacks full exclusion or alternative 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 full burden. It discloses the return shape (success, webhook_id, message) but does not mention irreversibility or consequences of deletion, which is a gap for a destructive 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 well-structured with clear sections for purpose, usage, returns, and an example. Every sentence adds value, and the overall length is appropriate.

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 tool with one parameter and no output schema, the description covers purpose, usage, and returns adequately. It could add a warning about the permanent nature of deletion but is otherwise complete.

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

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

The input schema already documents the parameter (webhook_id) with a pattern and description (100% coverage). The description adds an example value, which is helpful but does not significantly go 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 clearly states 'Delete a webhook subscription' with a specific verb and resource. It is distinct from sibling tools like create_webhook or update_webhook, but does not explicitly name alternatives.

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

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

A 'WHEN TO USE' section provides three specific scenarios, which is explicit guidance. However, it lacks exclusions or references to alternative tools, so it does not fully reach the top score.

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

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

With no annotations provided, the description carries the full burden. It reveals the return structure and the example implies a read-only operation, but it does not explicitly state that the tool has no side effects, nor does it mention any behavior around error handling for the tool call itself (e.g., invalid path). The RETURNS section provides useful output context, but deeper behavioral disclosure 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 well-structured with WHEN TO USE, RETURNS, and EXAMPLE sections. It is longer than the minimum, but each section contributes meaningful information. The example is particularly helpful without being redundant. It is not excessive, so a 4 is appropriate.

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 (2 params), has no output schema, and no annotations. The description compensates well by listing the return fields, providing usage guidance, and including an illustrative example. It covers the essential aspects needed for an agent to select and invoke the tool correctly. A small gap is the lack of explicit statement about response status codes for the tool itself, but overall it is fairly complete.

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

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

Schema coverage is 100% and both parameters are described in the schema. The description adds value with a concrete example showing a real path with template syntax and method 'GET', which clarifies how to format the path. This goes beyond the schema's dry descriptions, earning a 4 rather than the baseline 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 first sentence clearly states 'Describe a single API operation including its parameters, response shape, and error codes.' This uses a specific verb ('describe') and resource ('API operation'), and the singular scope distinguishes it from sibling tools like list_endpoints. No ambiguity.

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

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

The 'WHEN TO USE' section explicitly lists two use cases: inspecting an endpoint's full contract before calling it, and discovering error codes and recovery. This gives clear context for when to use the tool. However, it does not explicitly mention alternatives or when not to use it, so it stops short of 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 full responsibility for behavioral disclosure. It states the action, lists return parameters (success, device_status, next_heartbeat_seconds), and provides a concrete example. However, it does not address idempotency, prerequisites, or error handling, leaving some behavioral uncertainty.

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 efficiently structured with clear sections (WHEN TO USE, RETURNS, EXAMPLE) and a front-loaded purpose. Every section adds value, and the example is instructive without being redundant with the 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?

The description compensates for the lack of an output schema by explicitly listing return values and provides context on cadence and example usage. However, it omits potential prerequisites (e.g., device registration) or error conditions, making it slightly incomplete for a production context.

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

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

The input schema provides complete descriptions and an enum for status, so the description adds little beyond an illustrative example. The example demonstrates realistic parameter usage but does not introduce new semantic information; the schema already does the heavy lifting.

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

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

The description opens with 'Send a heartbeat signal from a device to report its status,' providing a specific verb and resource. It clearly distinguishes from sibling tools like register_device and get_device by framing it as a status-reporting action, and the WHEN TO USE section reinforces this 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 'WHEN TO USE' section explicitly lists three applicable contexts and recommends a cadence of every 30-60 seconds. While it does not name alternatives or exclusions, the guidance is clear and specific enough to direct appropriate use.

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 transparency burden. It discloses that the tool returns screens, total count, online_count, and real-time audience data when available, including a caveat about data availability. This conveys the read-only nature and likely output shape, though it does not discuss potential side effects or limitations beyond data availability.

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

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

The description is well-structured with clear sections: summary, when to use, returns, and example. It is somewhat long due to the detailed RETURNS list, but every section contributes information useful for tool selection and invocation. The main purpose 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 four nested parameters and no output schema, the description sufficiently covers the tool's behavior, return structure, and usage scenarios. It does not mention error handling or rate limits, but for a discovery query tool, the provided details are strong. The example further enhances completeness.

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

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

The schema already covers 100% of parameters, so the baseline is 3. The description adds value with a concrete example showing how to combine venue_types, location, audience_profile, and limit, plus a RETURNS section that clarifies how parameters affect the response. This goes beyond the schema's per-field 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 tool's function: discovering available DOOH screens across the exchange network, with specific use cases for filtering by venue, location, and audience. It does not explicitly differentiate from siblings like get_live_audience or semantic_audience_search, but the verb 'discover' and resource are specific enough to distinguish it.

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 'WHEN TO USE' section explicitly lists three key scenarios: finding screens by venue type, location, or audience profile, plus getting an overview. This gives clear context for when to use the tool, but it does not state when not to use it or mention alternatives like get_live_audience, so it stops short of 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 full burden. It discloses the side effect of creating or reusing DSP segments, the data pushed (MAID hashes), and possible status outcomes ('no_cohort', 'credentials_missing', 'empty_cohort'). It does not cover rate limits or authentication specifics, but the disclosed behavior is above average.

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

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

The description is well-structured with clear paragraphs, a WHEN TO USE section, a RETURNS list, supported destinations, and an example. Every section adds value without redundancy; the front-loaded purpose sentence immediately communicates the tool's function.

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 output schema, the description explicitly lists all returned fields and their meaning, covers supported destinations, and provides a usage example. The tool has only two parameters, and the description fully covers its behavior, use cases, and outcomes, making it complete for an agent to select and invoke correctly.

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

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

The input schema already provides full coverage with descriptions for both parameters, including an enum for destination with DSP names. The description adds an example invocation and clarifies destination aliases (e.g., 'ttd (The Trade Desk)'), but most semantic value is already in the schema, so a baseline of 3 is appropriate.

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

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

The description clearly states the tool exports an exposed audience cohort to a DSP for retargeting, specifying the exact mechanism (pushes MAID hashes) and supported destinations. It distinguishes itself from sibling tools like export_dataset by focusing on DSP cohort activation for retargeting.

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 a dedicated 'WHEN TO USE' section with concrete scenarios (e.g., DOOH retargeting, pushing to TTD/DV360/Meta, measuring lift). It does not explicitly mention when not to use the tool or name alternative tools, but the provided use cases are 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 available, the description carries the full burden and does well by disclosing k-anonymity enforcement (suppressing groups under 5), the query process, and the return structure. It does not mention potential rate limits or permission requirements, but the provided behavioral details are substantial and valuable.

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

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

The description is well-structured with clear sections and front-loaded purpose. It is somewhat long, but every section (filters, when-to-use, returns, dataset types, examples) adds necessary value. No filler, though slightly more verbose than the absolute minimum.

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 there is no output schema and no annotations, the description fully compensates by explaining return fields (data, metadata, suggested_next_queries), dataset type semantics, filtering capabilities, and k-anonymity behavior. It also provides examples for common use cases, making it complete and self-contained.

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 beyond the schema by explaining each dataset type, giving filter usage examples, and noting that time_range is required for certain dataset types. This enriches parameter understanding and justifies a 4.

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

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

The description clearly states the tool exports observation data as a structured dataset, with a specific verb and resource. It also lists filtering dimensions and dataset types, effectively distinguishing it from sibling tools like query_observations or get_analytics.

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 'WHEN TO USE' section provides explicit contexts like exporting audience data for external analysis, building ML datasets, or creating cross-signal datasets. However, it does not explicitly name alternative tools or state when NOT to use this tool, so it falls short of 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 full burden. It thoroughly discloses the approximate nature (ANN, recall ~0.96), eventual consistency (replicated pool, up to 5 minutes visibility differences), and what remains stable (relative ranking of already-visible moments). This is exemplary behavioral 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?

Although relatively long, the description is well-structured with clear sections (intro, background, CONSISTENCY, WHEN TO USE, RETURNS, EXAMPLE). Every section earns its place, providing necessary technical context without redundancy. Front-loading the main purpose makes it immediately usable.

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 complexity of embedding-based search with ANN and eventual consistency, and the absence of an output schema, the description fully covers the return format (data, metadata, suggested_next_queries), the consistency caveats, and practical usage examples. It is complete enough for an agent to invoke the tool correctly and interpret results.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value with examples showing how to phrase the query for different scenarios, which illustrates query semantics beyond the schema. However, it does not elaborate on limit or venue_type beyond what the schema already states.

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

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

Description begins with a specific verb+resource+method: 'Find historically similar audience moments across the screen network using embedding similarity search.' It clearly distinguishes the tool from exact query tools (like query_observations) and other semantic search tools by emphasizing the embedding-based ANN approach.

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 'WHEN TO USE' section lists four concrete scenarios, and an explicit exclusion states: 'Do not use this tool where a repeatable, exhaustive result set is required.' This gives clear guidance on when to choose this tool over 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 burden of behavioral disclosure. It states explicitly that it does NOT require authentication, and enumerates the exact return fields including protocols, inventory, audience data, pricing, and discovery URLs. This gives a clear picture of what to expect, though it doesn't address potential side effects or errors.

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 organized with clear sections and each sentence serves a purpose: the opening defines the tool, the authentication note sets expectations, WHEN TO USE provides context, and RETURNS lists the output. It is efficient without unnecessary fluff.

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

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

For a zero-parameter capability discovery tool, the description is comprehensive: it states the purpose, usage context, authentication requirements, and full return structure. Since there is no output schema, the explicit return field list is crucial and well provided.

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

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

The input schema has zero parameters (schema coverage 100%), so the baseline is 4. The description adds value by detailing the output structure, which compensates for the lack of an output 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 uses a specific verb 'Get' and identifies the resource as 'seller agent's AdCP capabilities and supported protocols'. It clearly distinguishes itself from sibling tools like get_signals or get_pricing by focusing on capability declaration.

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 'WHEN TO USE' section lists three concrete use cases: discovering protocols, understanding audience signals/methodology, and getting MCP endpoints. It also notes that authentication is not required, but it does not explicitly mention when not to use or alternatives.

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

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

With no annotations provided, the description carries the full burden. It discloses the return structure (summary, time_series, top_devices, breakdown) and includes two concrete examples that illustrate behavior. It does not mention rate limits or auth, but for a read-only analytics tool the return format and examples provide substantial transparency.

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

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

The description is well-structured with clear headers: summary, WHEN TO USE, RETURNS, and EXAMPLES. The opening line is a crisp summary, and every section contributes meaning without unnecessary verbosity. The two examples are illustrative but not redundant.

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

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

For a tool with no output schema and four optional parameters, the description is notably complete. It explains the purpose, when to use, what to expect in the response (four categories), and gives two realistic usage examples. It does not explain edge cases like overlapping dates, but such details are not essential for a partner analytics read tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by showing realistic parameter combinations in examples (e.g., start_date/end_date with group_by 'device' and 'day'). It also clarifies that 'breakdown' corresponds to the group_by dimension, reinforcing the schema's enum.

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

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

The description opens with 'Get analytics data for the partner account,' which is a clear verb+resource pairing. The 'WHEN TO USE' section enumerates specific use cases (overall performance metrics, device performance, reports on impressions/earnings, comparing over time) that distinguish this general analytics tool from more specialized siblings like get_network_stats or get_roas.

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 'WHEN TO USE' section provides explicit context: viewing performance metrics, analyzing devices, generating reports, comparing time periods. However, it does not explicitly state when NOT to use this tool or name alternatives, so it stops short of 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 explaining behavior. It discloses output structure, defines key metrics, and even provides the aCPM formula. It implies read-only behavior via 'Get' but does not explicitly state side-effect-free operation or any rate limits, though these are less critical for a data retrieval 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 uses clear section headers (WHEN TO USE, RETURNS, formula) and is well-organized. The opening includes a slightly promotional sentence about FEIN edge AI, which adds some fluff but is not waste; overall it is efficient and scannable.

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

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

Given the tool has a single parameter and no output schema, the description is thorough: it explains the return structure with nested fields, defines the units (0-1 scores, seconds), and provides the aCPM formula. This is complete enough for an agent to understand what to expect.

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

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

Schema coverage is 100% for the single parameter campaign_id, with a basic description 'Campaign identifier'. The tool description adds no extra semantic detail about the parameter beyond what the schema already provides, 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 clearly states the action ('Get edge AI attention metrics for a campaign') and identifies the unique FEIN-powered aspect. It distinguishes itself from siblings like get_campaign_performance or get_social_attention by specifying the type of attention metrics and the FEIN technology.

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 WHEN TO USE section provides clear contexts such as measuring actual attention, comparing aCPM vs CPM, and getting face/dwell/emotion data. However, it does not explicitly mention when not to use this tool or name alternatives, so it stops short of full exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention that this is a read-only operation, potential permissions required, rate limits, or edge cases like missing campaigns. The 'RETURNS' section describes output format but not behavioral traits, leaving a 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 well-structured with a clear main sentence, 'WHEN TO USE' bullets, 'RETURNS' field list, and a practical example. It is concise, front-loaded, and every section adds value without unnecessary fluff.

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

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

Since there is no output schema, the description compensates by listing all return fields (date, uniqueDevices, liftPct, etc.) and providing an example. It covers the essential context for a daily timeseries tool, though it omits minor details like default date ranges (already in schema) or significance interpretation. Overall, it is adequately complete for this complexity.

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

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

Schema description coverage is 100%, so the parameters (campaign_id, start_date, end_date) are already well-documented. The description adds a concrete example showing parameter usage, but it does not add meaning beyond the schema, such as default behaviors or constraints. This 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 opens with 'Get daily attribution timeseries for a campaign,' which clearly states the verb (get), resource (attribution timeseries), and scope (daily, for a campaign). This is specific enough to distinguish from sibling tools like get_campaign_attribution or get_multi_touch_attribution, and the 'RETURNS' section reinforces the exact 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 'WHEN TO USE' section provides clear use cases: tracking attribution trends over time, identifying strongest lift days, and building dashboards with daily granularity. However, it does not explicitly mention when not to use this tool or name alternative tools, so it falls short of the full 'when/when-not/alternatives' criterion.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explains that the tool uses historical audience data to predict typical patterns, and it discloses details about confidence based on sample count and the meaning of sample_count. This gives the agent useful context about how the prediction works and its reliability.

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

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

The description is well-structured with clear sections (purpose, when to use, returns, example). It is longer than minimal, but every section adds value, including the example that ties parameters to a realistic use case. No unnecessary 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?

Given the lack of an output schema, the description thoroughly explains the return fields (predicted_face_count, predicted_attention, typical_income, typical_lifestyle, confidence, sample_count). Combined with the example and the schema's parameter coverage, the description gives the agent everything needed to invoke the tool correctly and interpret results.

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

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

The schema already documents all four parameters with clear descriptions (day, hour, screen_id, lookback_days) and 100% coverage. The description adds no additional parameter meaning beyond a concrete example, which is helpful but not beyond the schema's 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 clearly states the tool's specific function: 'Predict what the audience will look like at a screen at a specific time.' It uses a precise verb (predict) and resource (audience at a screen/time), and the mention of historical data distinguishes it from related tools like get_live_audience.

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 'WHEN TO USE' section provides clear use cases: planning campaigns, estimating audience composition, and comparing times of day. It gives explicit context for when to use the tool, though it does not mention when not to use it or directly 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?

With no annotations, the description carries the burden of behavioral disclosure. It explains the underlying algorithm (pgvector, HNSW cosine similarity) and return format, but it does not disclose edge-case behavior, error handling, or side effects. Since this is a read-only lookup, it is acceptable but not fully 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?

The description is well-structured with clear sections for purpose, technical details, usage scenarios, return fields, and an example. Every sentence adds value, and the key functionality is front-loaded in the first line.

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 quite complete for a read tool with 5 parameters and no output schema. It explains the return structure, similarity semantics, and gives a usage example. It lacks detail on filtering behavior for country/venue_type, but the schema descriptions cover that.

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 covers 100% of parameters with descriptions, so the baseline is 3. The description adds an example that demonstrates a typical invocation, but it does not enrich parameter semantics beyond what the schema provides.

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

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

The description clearly states the tool's function: finding screens with similar audience profiles using pgvector similarity. It distinguishes itself from sibling tools like semantic_audience_search by focusing on lookalike audience matching for campaign expansion and targeting.

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 'WHEN TO USE' section provides clear scenarios (expanding reach, finding similar inventory, building lookalike segments). It does not explicitly mention when not to use or name alternative tools, but the guidance is concrete 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 provided, the description carries the burden of conveying behavior. It clearly indicates a read-only status check by using 'Check' and lists the specific data points returned. It does not mention side effects (none expected) or auth requirements, but for a simple status query the transparency is adequate.

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, front-loaded with the core function and followed by usage guidance. Every word earns its place; no filler 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?

For a zero-parameter tool with no output schema, the description is adequately complete. It states what the tool does, what information it provides, and when to use it. No critical gaps are apparent for an agent to correctly select and invoke the tool.

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

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

The tool has 0 parameters, so the schema provides no parameter info. The description goes beyond the schema by detailing what the tool returns (billing setup, credit balance, Stripe customer ID, payment method status), giving the agent meaningful context about the output despite no input 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 tool's function: 'Check current billing status including whether billing is set up, credit balance, Stripe customer ID, and payment method status.' It uses a specific verb ('Check') and resource ('billing status'), and distinguishes itself from sibling tools like setup_billing and purchase_credits by focusing on querying status rather than modifying it.

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 when-to-use guidance: 'Use this to determine if billing setup is needed before making paid API calls.' It implies the context and purpose, though it does not explicitly name alternatives (e.g., setup_billing). This is clear but falls short of fully explicit alternative specification.

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 explains the return structure in detail and explicitly discloses the null case ('Returns null if no attribution data exists for the campaign'), which is a valuable behavioral trait. It also hints at data freshness with provisional and finalized counts, adding transparency. However, it does not explicitly state whether the operation is read-only or safe, though 'get' implies it. This is a minor gap given the otherwise thorough description.

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

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

The description is well-structured with clear sections: a one-line purpose, 'WHEN TO USE' bullet points, and a structured 'RETURNS' list. It front-loads the purpose and uses concise, scannable formatting. Every section earns its place, providing necessary details (especially return fields) without unnecessary fluff.

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

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

Given the lack of an output schema and annotations, the description provides complete context for using the tool. It fully explains the return object's structure (reach, footfall, cost, quality, dataFreshness) and the null-case behavior. It also covers usage scenarios, making the tool self-sufficient for an agent to understand its purpose, invocation, and interpretation of results.

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

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

The schema covers the single parameter campaign_id with a clear description ('Campaign identifier (UUID or string ID from create_campaign)'). Since schema coverage is 100%, the baseline is 3. The tool description does not add extra semantics about the parameter beyond what the schema provides, though it does contextualize that this is for a DOOH campaign. Overall, the description adds minimal value over the schema, so a baseline score is appropriate.

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

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

The description clearly states the tool's purpose: 'Get comprehensive attribution summary for a DOOH campaign.' It uses a specific verb (Get) and resource (attribution summary for a DOOH campaign), which distinguishes it from sibling tools like get_attribution_timeseries (time-series data) and get_creative_attribution (creative-level data). The detailed RETURNS section further reinforces the tool's specific output 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 provides a clear 'WHEN TO USE' section with three practical scenarios: measuring campaign effectiveness, getting a high-level view, and checking statistical significance. This gives strong contextual guidance for when to invoke the tool. However, it does not explicitly state when NOT to use it or mention alternative tools for specific cases (e.g., get_attribution_timeseries for time-series data), so it lacks exclusions/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 present, so the description must carry the full burden. It discloses return format details, including max 500 clusters, lat/lng rounding to 3 decimals, and specific fields like uniqueDevices and avgConfidence. However, it does not explicitly state read-only behavior, permissions, or data freshness, leaving a moderate 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 moderately sized but well-structured with clear sections: purpose, when-to-use, and return details. Each section earns its place, though the phrase 'exposure' repeats several times and could be tightened slightly.

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 parameter and no output schema, the description thoroughly covers return fields, limits, and rounding behavior. The use cases add practical context. For a simple data retrieval tool, this is complete and self-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?

The input schema already provides 100% coverage for the single campaign_id parameter with a description ('Campaign identifier'). The tool description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

The description opens with 'Get geographic exposure heatmap data for a campaign', using a specific verb and resource that clearly differentiates it from sibling tools like get_campaign_performance or get_analytics. The map visualization context further clarifies 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?

A dedicated 'WHEN TO USE' section provides concrete use cases such as 'Visualizing campaign geographic coverage' and 'Identifying hotspots of ad exposure'. It does not explicitly mention when not to use or name alternatives, but the context is clear enough for a straightforward GET 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 details the return structure (campaign_id, performance metrics, screen_breakdown) and includes an example, which clarifies the data returned. However, it does not explicitly state whether the operation is read-only or discuss side effects, though 'Get' implies read-only.

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 highly structured with clear sections (WHEN TO USE, RETURNS, EXAMPLE). Every sentence serves a purpose, and the content is front-loaded with the primary purpose statement.

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

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

For a single-parameter tool with no output schema, the description compensates by listing all return fields and providing a realistic example. It covers the main use cases and gives enough context for an agent to invoke the tool correctly. No gaps identified.

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 campaign_id as a required Campaign UUID with 100% coverage. The description reinforces this with an example parameter but adds no additional semantic depth beyond what the schema provides, matching the baseline 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 clearly states 'Get detailed performance metrics for a campaign,' specifying a specific verb and resource. It distinguishes from sibling tools by focusing on campaign performance metrics with per-screen breakdowns, which is unique among the many get_* 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 WHEN TO USE section explicitly lists three use cases: monitoring active campaigns, reviewing completed campaigns, and getting per-screen impression breakdowns. This provides clear guidance on when to select this tool over 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 transparency burden and does well by detailing the exact return fields, including venueDistribution, daypartDistribution, and topScreens, plus examples of calls. It does not disclose edge-case behavior or potential errors, but the output structure is thoroughly specified.

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

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

The description is well-structured with clear sections for when to use, return fields, and examples. Every sentence serves a purpose, and the main verb and resource are front-loaded. It is appropriately sized for the tool's complexity.

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 there is no output schema, the description compensates well by listing all return fields and providing two examples. It lacks some edge-case details (e.g., behavior for unknown video IDs) but is largely complete for a read-only analytics tool with three parameters.

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

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

Schema coverage is 100% with descriptions for all three parameters, so the baseline is 3. The description's examples illustrate parameter usage (e.g., venue_type: 'retail', days: 30) and add a bit of context, but it does not significantly deepen the semantic understanding 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 clearly states the tool gets performance metrics for a specific video across the Trillboards DOOH network, listing specific metrics like plays, attention, and audience size. It distinguishes itself from sibling tools by focusing on video-level performance with venue/daypart breakdowns and top screens.

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 'WHEN TO USE' section lists four concrete scenarios, such as checking video performance across screens and analyzing venue/daypart resonance. It provides clear context for when to use the tool, though it does not explicitly mention when not to use it or name direct 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 burden and does a solid job: it details the return structure, lists the performance score formula, and provides examples. It doesn't mention error cases, auth requirements, or edge cases like no matching venue_type, so it's not a 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?

The description is well-structured with clear sections: overview, when to use, returns, and examples. Every sentence contributes meaningful information, and the examples are compact and useful.

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 lacking an output schema, the description fully specifies the return fields (data array with content details and metrics, meta object). Combined with examples and the performance formula, it gives the agent everything needed to invoke the tool correctly.

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

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

Schema coverage is 100%, so this is already well-documented. The description adds value by explaining daypart as 'time context', giving example calls, and clarifying the limit's role in the output size. This goes beyond the schema's basic 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 it returns best-performing content recommendations filtered by venue type and optional daypart. It uses a specific verb and resource, and the focus on recommendations distinguishes it from sibling tools like get_content_performance or search_content.

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 WHEN TO USE section gives concrete scenarios: content scheduling, engagement optimization, daypart rotation, and programming decisions. However, it doesn't explicitly name alternatives or state when not to use this tool, stopping short of the highest bar.

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 return data structure (ranked by attention score, fields like avgAttentionScore) and implies read-only through the verb 'get,' but it doesn't explicitly state safety, permissions, or any side effects. This is adequate but not exceptional.

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

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

The description is well-structured with clear sections (WHEN TO USE, RETURNS), uses bullet points for readability, and every sentence earns its place. 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?

For a simple one-parameter tool, the description is complete: it explains the purpose, provides use cases, and details the return fields (acting as a pseudo output schema). It lacks only explicit notes on edge cases or limitations, but it's sufficient for effective invocation.

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

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

The input schema includes a single required parameter campaign_id with a description 'Campaign identifier,' giving 100% schema coverage. The tool description does not add any additional parameter-level semantics beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description starts with 'Get per-creative attention breakdown for a campaign,' which combines a specific verb (get) with a clear resource (per-creative attention) and scope (for a campaign). This distinguishes it from sibling tools like get_attention_metrics or get_social_attention.

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 WHEN TO USE section explicitly lists three concrete use cases: A/B testing creative variants, identifying engagement drivers, and comparing aCPM. While it doesn't mention exclusions or alternative tools, the context provided 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It thoroughly describes the return behavior: an array of creatives ranked by store visits, including nested fields like attention metrics, bestContext, and dateRange. It does not mention error conditions, permissions, or side effects, but as a read-only 'get' operation, the main behavior is well covered.

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

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

The description is well-structured and front-loaded with a one-sentence summary followed by focused sections. Every line adds value: the purpose statement, three concrete use cases, and a detailed return format list. There is no filler or redundancy, making it appropriately concise despite its 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?

Given the tool has only one parameter and no output schema, the description compensates completely by detailing the return structure with nested objects (attention, bestContext, dateRange) and ranking semantics. Combined with clear use cases, it gives an agent all necessary context to select and invoke the tool correctly.

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

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

The input schema has 100% descriptive coverage for campaign_id ('Campaign identifier'), and the description does not add extra semantic detail for parameters. According to the baseline rule for high schema coverage, a score of 3 is appropriate—the schema already documents the parameter adequately.

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

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

The description clearly states the tool's purpose: 'Get attribution performance by individual creative variant.' It uses a specific verb ('Get') and resource ('creative variant'), and uniquely distinguishes itself from sibling tools like get_campaign_attribution and get_attribution_timeseries by focusing on per-creative performance and providing a concrete outcome ('which creative variant drove the most store visits?').

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 'WHEN TO USE' section lists three specific scenarios, such as comparing A/B/C creative tests and finding optimal creative x context combinations. While it does not explicitly name alternatives or exclusions, the use cases are clear and actionable. This is more than implied usage but stops short of explicitly contrasting with 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It discloses the return structure (flows and channels arrays) and gives an example of the transition pattern, making the tool's behavior transparent. While it does not explicitly mention side effects or permissions, the 'Get' nature and the detailed return info make the operation clear.

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

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

The description is well-structured with a clear first sentence, an example flow, a dedicated 'WHEN TO USE' section, and a 'RETURNS' section. Every sentence adds value, and the information is front-loaded with the core purpose. It is appropriately concise without being under-specified.

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

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

Given the low complexity (one parameter, no output schema, no annotations), the description is highly complete. It explains what the tool does, provides usage scenarios, and details the return format, which covers all necessary context for an agent to select and invoke the tool correctly.

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

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

The input schema already describes campaign_id as 'Campaign identifier' with full coverage. The description's mention of 'for a campaign' adds minimal semantic value beyond schema, essentially restating it. There is no additional detail on format, defaults, or edge cases, so it does not 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?

The description clearly states a specific action ('Get cross-channel customer journey data') on a specific resource ('for a campaign'), with an illustrative flow (DOOH -> mobile -> web -> store). It also distinguishes itself from sibling tools by mentioning Sankey flow and cross-channel journey, which is unique among the listed get_* 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 'WHEN TO USE' section explicitly lists three scenarios where this tool is appropriate, such as visualizing customer journeys and building Sankey diagrams. However, it does not explicitly state when not to use it or point to alternative sibling tools, so it falls short of 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 full burden. It discloses that the tool queries observation_stream and filters for rows with both creative ID and VAS outcome, and it provides a detailed return structure. This goes beyond a simple 'get stats' statement, but it does not mention potential costs, staleness, or access requirements. Still, the provided behavioral context is substantial.

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

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

The description is well-structured with clear sections (overview, when-to-use, returns, example). It is longer than strictly necessary for a zero-parameter tool, but every section adds value: the return spec is critical since no output schema is provided. The example is brief and illustrative.

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 zero parameters, no annotations, and no output schema, the description is highly complete. It specifies the data source, filtering criteria, all return fields with descriptions, usage contexts, and an example. This fully compensates for the absence of an output schema and leaves no ambiguity about the tool's behavior.

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

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

The input schema has zero properties and the description confirms no arguments via the example 'get_dataset_stats({})'. With 0 params, baseline is 4; there is nothing more to explain. The description reinforces that the tool requires no parameters.

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

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

The description explicitly states 'Get statistics about available causal training data' and lists specific metrics (total tuples, unique creatives, venue diversity, date range). It also explains the internal query against observation_stream, distinguishing it from other get_* tools like get_analytics or get_network_stats. The focus on causal training data makes it unique among 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?

A dedicated 'WHEN TO USE' section provides clear conditions for using the tool (checking data sufficiency, diversity, health monitoring, planning). It does not explicitly mention alternatives or when-not-to-use scenarios, but the context is clear and directly tied to causal prediction needs. An explicit exclusion would push it to 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?

No annotations are provided, so the description carries full responsibility. It does not disclose behavioral traits such as read-only nature, authorization requirements, error behavior for unknown device IDs, or rate limits. The return fields are listed, but operational behavior is not addressed.

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

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

The description is well-structured with clear sections (WHEN TO USE, RETURNS, EXAMPLE), each serving a purpose. It is appropriately sized for a simple getter tool, with no redundant information and key details 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?

Despite having no output schema, the description enumerates all return fields and provides a concrete example, making it sufficient for a single-parameter read tool. Minor gaps include lack of error handling info and no mention of the obvious sibling list_devices, but overall it is fairly complete.

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

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

Schema coverage is 100% and the schema description ('Your internal device identifier') aligns with the tool's return description. The DESCRIPTION adds a concrete example ('vending-001-nyc') but does not meaningfully extend the semantic meaning 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 clearly states 'Get detailed information about a specific device' with a specific verb and resource, and the WHEN TO USE section adds concrete use cases (checking status, configuration, debugging). This distinguishes it from sibling tools like list_devices and get_device_ads.

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?

Explicit WHEN TO USE list provides clear context for when to invoke this tool. However, it does not mention when not to use it or name alternative tools (e.g., list_devices for multiple devices), so it falls short of 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 full burden for behavioral disclosure. It only says "for testing," implying a non-production use, but does not explicitly state it is read-only, mention permission requirements, or note any side effects or limitations. The return values are described, but not the behavior.

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

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

The description is well-structured with clear sections: overview, WHEN TO USE, RETURNS, and an EXAMPLE. Each section adds value without excessive verbosity, though the formatting is a bit longer than strictly necessary.

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

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

For a simple one-parameter tool with no output schema, the description covers purpose, usage scenarios, return fields (ads, default_stream, schedule), and provides an example. It is complete enough for an agent to understand and invoke the tool, though it omits edge-case behavior.

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

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

Schema coverage is 100% with a clear description of the fingerprint parameter. The description also includes an example usage that reinforces the parameter. However, it does not add meaning beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description clearly states a specific verb+resource: "Get current ads scheduled for a device (for testing)." This distinguishes it from the many sibling get_* tools by explicitly focusing on device ads, and the parenthetical "for testing" adds useful 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?

A dedicated "WHEN TO USE" section lists three concrete scenarios: testing device ad delivery, debugging which ads are shown, and verifying ad targeting. This provides clear context, though it does not mention when not to use the tool or suggest 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 full weight. It discloses the statistical methods (Bayesian Beta-Binomial with 10K Monte Carlo samples, frequentist chi-square with Yates correction), the structure of the returned array (including latestResult fields), and the empty-array behavior. This goes well beyond a minimal description, though it does not mention side effects or authorization requirements.

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

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

The description is well-structured with clear sections: a one-sentence summary, a brief methodology note, WHEN TO USE, and RETURNS. Every sentence adds value, with no padding 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?

Despite having no output schema, the description thoroughly covers return values: the array of experiments, types (geo_holdout/ghost_ads/psm), and nested latestResult fields (treatment/control rates, lift%, incrementalVisits, pValue, etc.). It also explains the empty-array case, making it complete for a read 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 already provides 100% coverage for the single parameter campaign_id with a description. The tool description adds no additional parameter context, so the baseline of 3 applies.

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

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

The description states a specific verb+resource: 'Get incrementality/lift test results for a campaign.' This clearly distinguishes it from sibling tools like get_campaign_performance or get_roas, as it focuses on causal measurement and lift testing.

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 'WHEN TO USE' section lists three explicit scenarios: proving causal DOOH effectiveness, obtaining Bayesian and frequentist significance measures, and seeing treatment vs. control group rates. However, it does not explicitly name alternatives or state when not to use, so it stops short of 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 full burden. It discloses data freshness (refreshed every 10 seconds), the data source (edge AI sensors), and explains return fields including a staleness metric. It lacks explicit rate limits or error behavior but effectively communicates the real-time nature.

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 long but well-structured with WHEN TO USE, RETURNS, and EXAMPLE sections. Each part adds value; the main verb is front-loaded. A slight deduction for verbosity in the returns list, though it's necessary given the lack of an output 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?

This is a simple one-parameter tool with no output schema. The description comprehensively covers what the tool does, when to use it, the return fields (with meanings), and an example call. No significant gaps remain.

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 100% of parameter documentation for screen_id. The description adds a concrete example ID, but no additional semantic detail beyond what the schema already states. 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 opens with 'Get real-time audience data for a specific screen,' a specific verb+resource+scope statement. It clearly distinguishes from sibling tools like get_audience_forecast or get_analytics by emphasizing 'real-time' and 'specific screen.'

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 WHEN TO USE section explicitly lists three concrete use cases: pre-buy checks, live campaign monitoring, and detailed audience signals. It stops short of naming alternatives or exclusions, so it doesn't earn a 5, but the context is clear enough for an agent to decide.

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 does disclose return fields ('delivery: impressions, spend, avg_cpm, unique_screens, fill_rate') and mentions 'top performers' for breakdowns, which is useful. However, there is an internal inconsistency: the intro lists 'audience segment' as a breakdown, while the RETURNS section omits it. This ambiguity about the actual response structure reduces transparency.

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

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

The description is well-structured with clear headings (WHEN TO USE, RETURNS, EXAMPLE) and no filler. Each section serves a distinct purpose, and the example is a useful, concise illustration. It is appropriately sized for the tool's complexity.

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 no output schema and no annotations, the description provides a solid level of completeness: it explains usage scenarios, lists return fields, and gives an example. However, the breakdown inconsistency and lack of detail about the dimensions parameter leave some gaps, preventing a perfect 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?

Schema description coverage is 100%, so the schema already defines each parameter. The description adds a concrete example with media_buy_id and mentions breakdown dimensions, but it does not clarify the optional dimensions or the legacy 'breakdown_by' parameter. Thus, it stays at the baseline 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+resource ('Get delivery/performance report for a media buy') and clearly distinguishes this tool from siblings like get_media_buys and get_campaign_performance by focusing on media-buy-level delivery with breakdowns by screen, venue, hour, and audience segment. The '[AdCP Media Buy]' prefix also disambiguates the domain.

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 'WHEN TO USE' section explicitly lists three monitoring/optimization/reporting contexts, providing clear usage guidance. However, it does not mention when to avoid this tool or present alternative tools, which keeps it at 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 provided, the description carries the full transparency burden. It discloses that status/budget/flight are read live from the advertisements+placements spine rather than a stored display string, and that delivery snapshots have staleness_seconds 0. It also explains that results reflect current truth even if not rewritten.

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

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

The description is well-structured with a one-sentence purpose, followed by a source-of-truth note, WHEN TO USE, RETURNS, and EXAMPLE sections. Every sentence earns its place, and the format is front-loaded with the core purpose.

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

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

Given the absence of an output schema, the RETURNS section enumerates the fields (media_buy_id, status, currency, total_budget, confirmed_at, revision, packages) and pagination style. It also provides example calls and cross-references the status_filter enum. This makes the description self-sufficient for an agent to use correctly.

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

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

The description adds value beyond the schema through examples showing status_filter arrays and media_buy_ids, and notes that status_filter accepted values are listed on the parameter. It also clarifies pagination is cursor-based. However, it does not explain the 'context' parameter, which is also undescribed in the schema, so it doesn't fully compensate for the 60% 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 opening sentence clearly states the tool lists media buys with status, budget, flight, and optional delivery snapshots. This specific verb-plus-resource description distinguishes it from sibling tools like get_media_buy_delivery or update_media_buy.

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 'WHEN TO USE' section explicitly provides three concrete scenarios: polling open buys, confirming a buy left pending_creatives after sync_creatives, and getting near-real-time snapshots without a full delivery report. This gives clear context and implies when not to use it (e.g., when a full delivery report is needed).

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

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

With no annotations, the description carries the burden of behavioral disclosure and does well: it lists return fields in detail, specifies that channelAttribution sums to 1, and handles the null-return edge case. However, it mentions supported models without indicating how a model is selected given only campaign_id in the schema, leaving a minor ambiguity.

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

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

The description is well-organized with clear headings (WHEN TO USE, RETURNS) and bulleted lists. It is front-loaded with a clear summary sentence and every line provides meaningful information without 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?

Given no output schema and no annotations, the description is remarkably complete: it explains what the tool does, when to use it, what the return object contains, and a key edge case (null response). It is more than sufficient for an agent to invoke the tool correctly.

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

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

The schema already provides 100% coverage with campaign_id described as 'Campaign identifier'. The description adds no further parameter-level detail, 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 clearly states 'Get multi-touch attribution model results for a campaign' with a specific verb and resource, and lists supported models (time_decay, position_based, attention_weighted) which distinguishes it from sibling attribution tools like get_attribution_timeseries or get_campaign_attribution.

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 'WHEN TO USE' section provides clear context (understanding DOOH fit, credit allocation, quantifying DOOH contribution) but does not mention exclusions or explicitly name alternative tools for different scenarios, so it stops short of 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It lists the return fields and gives an example, which is helpful, but it does not mention any potential side effects, authentication requirements, rate limits, or data freshness. For a simple read tool, the absence of such caveats is acceptable but not deeply 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?

The description is tightly structured with sections (WHEN TO USE, RETURNS, EXAMPLE). Every sentence earns its place, with no unnecessary verbiage. It uses clear headings and a realistic example, making it easy to scan.

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 output schema, the description explicitly lists all return fields, which is sufficient for an agent to understand what to expect. It also provides usage context and an example, covering the tool's simplicity comprehensively.

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 fully describes the only parameter (time_range) with enum values, default, and description (100% coverage). The description adds an example with time_range, but that is marginal value beyond the schema. 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 tool's function: 'Get network-wide statistics across all partner screens.' It specifies the verb 'get', the resource 'network stats', and the scope 'across all partner screens,' which distinguishes it from other get_* tools that target campaigns, devices, or analytics. The WHEN TO USE section further reinforces its purpose.

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

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

The 'WHEN TO USE' section provides three explicit use cases: getting a high-level overview, checking online screens, and reviewing impressions/revenue. It gives clear context for when to invoke the tool but does not mention exclusions or alternative tools, so it falls short of 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. It discloses return fields and implies a read-only operation by using 'Get information' and referencing the authenticated account. It doesn't explicitly state non-destructiveness, but the nature of the tool and return list make this clear.

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

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

The description is well-structured with a summary, usage scenarios, return fields, and an example. Every section is concise and serves a purpose, with no filler.

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

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

Despite no output schema, the description lists all key return fields explicitly. It covers what the tool does, when to use it, and what it returns. Given the low complexity (0 params, simple read), this is complete.

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

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

The tool has 0 parameters, which per rubric gives a baseline of 4. The description correctly shows the tool takes no input, so no additional parameter semantics are needed.

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

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

The description explicitly states 'Get information about the authenticated partner account', identifying the specific verb and resource. The 'RETURNS' section further clarifies the scope, distinguishing it from sibling tools like get_billing_status or get_device.

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 'WHEN TO USE' section lists concrete scenarios such as checking partner status and verifying API key. It provides clear context but does not explicitly mention alternatives or when not to use, so it misses full marks.

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

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

No annotations are provided, so the description carries full burden. It discloses the no-auth requirement and describes the return format and content (graduated pricing, free tier, discount tiers). This is meaningful behavioral context. It doesn't explicitly state that the operation is read-only, but the 'get' verb implies it, and no side effects are suggested.

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, front-loaded with the core purpose, and every sentence adds value. The second sentence packs return details, auth requirement, and use case without fluff.

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

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

For a simple tool with one optional parameter and no output schema, the description covers purpose, return contents, auth, and intended use. It could explicitly state the behavior when 'product' is omitted (e.g., returns all products), but the phrase 'all Trillboards products' implies this. Overall, the description is sufficient for an agent to select and invoke the tool.

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

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

Schema description coverage is 100%: the single optional 'product' parameter is fully described with an enum of values. The tool description doesn't add any extra parameter semantics beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose with a specific verb and resource: 'Get machine-readable pricing for all Trillboards products.' It also enumerates return contents (graduated usage-based pricing, free tier thresholds, committed-use discount tiers), which differentiates it from sibling tools like get_products or get_billing_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 provides a clear use case: 'use this to evaluate costs before integrating.' It also mentions the authentication requirement (none). However, it doesn't explicitly name alternative tools or state when not to use it, so it falls short of 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?

No annotations exist, so the description carries the full burden. It discloses that no authentication is required, explains the observed-screen data source, states products are ordered by evidence, and notes that some words may not be evidenced. This is exceptional transparency.

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

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

The description is well-structured with clear sections (WHEN TO USE, RETURNS, EXAMPLE) and front-loaded with the key facts: purpose, no auth, and evidence-based behavior. Despite length, every sentence adds useful information and none feel redundant.

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

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

Given the absence of an output schema, the RETURNS section thoroughly explains the product structure and the brief_interpretation field. Use cases and behavior are covered well. The main gap is the lack of guidance on optional parameters like pagination and filters, though the schema fills those holes.

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 86%, so the schema already documents most parameters. The description adds substantial meaning to the `brief` parameter with a detailed explanation of how it is used and an example, which goes beyond the schema's one-line description. Other parameters are adequately covered by the schema.

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

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

The description opens with 'Get available DOOH advertising products and packages', a specific verb+resource statement. It clearly differentiates this tool from generic inventory tools by describing its evidence-based natural-language matching, 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?

A dedicated 'WHEN TO USE' section lists three concrete scenarios: browsing inventory, comparing pricing, and understanding market/daypart availability. This gives clear context, though it does not mention when not to use the tool or name alternative sibling tools like discover_inventory.

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

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

With no annotations, the description carries full burden. It discloses key behavioral details: the matching logic (purchase events to exposures with time-decay weighting), the computation of incremental ROAS and sales lift, and the edge case of returning null if no transaction data exists. It does not discuss authentication, rate limits, or explicit read-only guarantees, but given the 'Get' verb and return-focused text, this is sufficient.

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 divided into clear sections: purpose, WHEN TO USE, and RETURNS, with bulletized output groups. It's more detailed than necessary for a one-parameter tool but all sections add value, especially the RETURNS list which substitutes for the missing output schema. The metaphorical opener 'Closes the ROAS loop' adds minimal 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 no output schema, so the description compensates by enumerating all returned data groups (transactions, attribution, salesLift, timing) with field names, and explicitly states the null return condition. Combined with the single well-documented parameter and clear usage scenarios, the description is complete enough for an AI to correctly expect the response shape.

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 only parameter is campaign_id, which the schema already describes as 'Campaign identifier' with 100% coverage. The description does not add any additional meaning to this parameter, so it holds at the baseline for good schema coverage.

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

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

The description opens with a specific verb+resource: 'Get Return on Ad Spend (ROAS)'. It then elaborates with the mechanism (matches purchase events to DOOH exposures with time-decay weighting) and output scope (ROAS, iROAS, sales lift). This clearly distinguishes it from sibling attribution tools, though it doesn't name them explicitly.

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 'WHEN TO USE' section lists three concrete scenarios: measuring revenue attributable to DOOH, getting ROAS/iROAS, and sales lift between exposed/control groups. This provides clear context for when to invoke the tool, but it does not mention alternative sibling tools or exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses that signals are deterministic, captured by on-device cameras/microphones, analyzed by ML Kit and Gemini Vision, and returns the exact structure (signals array, metadata counts). This gives substantial behavioral context beyond basic 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 well-structured with clear sections: main purpose, WHEN TO USE, behaviour explanation, RETURNS, and a helpful example. Every section earns its place and the content is front-loaded with the most important information. 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 one-parameter nested object schema and absence of output schema, the description is complete: it explains use cases, behavior, return structure, and gives an example. It doesn't cover error handling or pagination, but for a query tool of this complexity, it is nearly comprehensive.

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 value with a concrete example showing how signal_spec.shapes the request (signal_types, filters, venue_type), making the parameter usage clearer than raw schema alone. This justifies a point 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?

The description clearly states 'Get real-time audience signals from DOOH screens' with a specific verb and resource. It further distinguishes itself from sibling tools by emphasizing deterministic signals from edge AI and 'Discovering available audience signals before buying inventory,' which positions it uniquely among many get_* 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 'WHEN TO USE' section provides three explicit use cases: discovering signals before buying, evaluating audience composition, and building targeting segments. It contrasts deterministic vs probabilistic data, giving context, though it does not name specific alternative tools for when-not-to-use.

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

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

With no annotations, the description carries full burden. It explains the data source (AttentionGraphBuilder on CTV edge devices), the meaning of key metrics (SAF, cascade depth), and the return payload structure. It does not explicitly mention read-only/safety, but the verb 'Query' and operation semantics imply non-destructive use. It lacks rate-limit or auth details, which would push it to a 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?

The description is well-organized into clear sections (purpose, when to use, returns, examples). Each section adds meaningful information without fluff. The examples are concise and illustrative. It is longer than average but earns its length through density and structure.

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

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

With no output schema, the description thoroughly details the return payload, including nested socialAttention metrics and metadata. It also covers the data provenance and typical use cases, making it self-contained. The provided examples cover common query patterns. This is a complete description for an agent to use the tool effectively.

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

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

Schema covers all 5 parameters with descriptions (100% coverage), so baseline is 3. The description adds value through two representative examples showing how to combine min_saf, venue_type, and time_range, and clarifies that the metadata includes min_saf_filter. It avoids redundant repetition of schema fields.

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

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

The description explicitly states the tool 'Query social attention contagion metrics from the observation stream' and specifies the core criterion (SAF > 1). It distinguishes itself from sibling tools like get_attention_metrics and get_social_contagion_summary by focusing on contagion/cascade behavior rather than general attention or aggregate summaries.

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 'WHEN TO USE' section lists four concrete use cases, clearly indicating appropriate contexts. However, it does not explicitly mention when not to use the tool or name alternative siblings (e.g., get_social_contagion_summary for summary stats), so exclusion guidance is missing.

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 that the tool queries observation_stream, aggregates by dimension, computes specific metrics (average SAF, cascade depth, viral attention score), sorts results by avg SAF descending, and returns suggested_next_queries. It also notes default time ranges. This is substantial transparency, though it doesn't discuss error handling or auth requirements.

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

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

The description is well-structured with clear sections: purpose, when to use, returns, and example. It is front-loaded with a concise overview, then provides necessary detail. Every section serves a purpose without irrelevant fluff.

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

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

Because there is no output schema, the description thoroughly explains the return structure, including the array of rows with fields like avg_saf and event_count, plus metadata. It also provides two example calls covering different group_by values. This gives the agent everything needed to invoke the tool correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description's examples ('get_social_contagion_summary({ group_by: "venue", time_range: { start: "2026-03-09", end: "2026-03-16" } })') reinforce the parameter usage but don't add meaning 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 clearly states the tool's function: 'Aggregate social attention metrics across screens and time periods' and 'Shows which venues and dayparts have the highest social amplification.' This is a specific verb+resource that distinguishes it from sibling tools like get_social_attention, which likely returns raw data rather than aggregates.

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 'WHEN TO USE' section provides clear scenarios such as 'Understanding which venues generate the most social amplification' and 'Comparing daypart effectiveness for social contagion.' However, it doesn't explicitly mention when not to use this tool or name alternatives, so it falls short of 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 bears full responsibility for behavioral disclosure. It discloses that tasks complete in-process ('already completed by the time you hold its id'), that include_history has no effect, and that responses are intentionally identical for not-found IDs to prevent probing. Security and scope behaviors are thoroughly explained.

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 purpose sentence and uses clear section headers (TASK SCOPE, NOT RECORDED) to organize extra information. It is longer than a typical tool description, but every sentence adds valuable context about behavior and security. The length is justified given the protocol-specific details.

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?

Without an output schema, the description should explain return semantics. It explains the terminal state and completion payload, and the not-found response pattern. However, it does not enumerate possible status values (e.g., completed, failed, pending) or describe the shape of the completion payload. This is a minor gap for a polling tool with a simple return contract.

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 descriptions cover task_id, include_result, and include_history, but the description adds meaningful context: it explains the effect of include_result ('with include_result: true, its completion payload') and explicitly states include_history is accepted but has no effect. It does not add anything for the generic account or context parameters, though these are common cross-tool fields. The description compensates for the 60% schema coverage.

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

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

The description opens with a specific verb and resource: 'Get the status of a previously issued AdCP task.' It further clarifies the polling behavior ('Poll that id here to read the task's terminal state'), making the tool's function unmistakable. It also distinguishes itself from read-only protocol calls listed under NOT RECORDED, though it doesn't explicitly reference the tasks_get/tasks_list 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?

The description explicitly states when to use this tool: 'this tool exists so a buyer that polls does not hang, and so an async arm has somewhere to report from when one lands.' It also provides exclusions by naming read-only calls that are NOT RECORDED as tasks, and warns that all not-found cases return identically, guiding safe usage expectations.

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 the response content (free tier consumption, paid usage, total cost) and scopes to the current billing period. While it doesn't explicitly state read-only behavior or authentication needs, the 'get' verb and lack of side effects make it reasonably 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?

The description is two efficient sentences. The first states the primary purpose and scope, the second adds output details. No redundant or extraneous 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 tool has no parameters and no output schema, the description sufficiently outlines the response categories. It doesn't explicitly differentiate from get_billing_status or mention data freshness, but for a simple summary tool it offers enough context for correct selection.

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

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

The tool has zero parameters, so the baseline is 4. The description adds meaning by explaining the output categories, which is useful given the empty input 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 a billing period usage summary, with explicit mention of per-product breakdown and costs. This distinguishes it from other billing-related tools like get_billing_status, which likely handles broader account 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 provides clear context for use—retrieving current billing period usage details—but does not explicitly exclude alternatives or mention when not to use this tool. This implies usage rather than offering explicit guidance against 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?

With no annotations, the description carries the full burden. It discloses the return structure in detail (deliveries array with fields, total, success_rate) and provides an example, which goes beyond schema to explain behavior. It does not mention side effects (likely none) or auth requirements, but for a read-only tool this is adequate.

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

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

The description is well-organized into a one-line summary, WHEN TO USE, RETURNS, and an EXAMPLE. Each section adds value without redundancy and it is appropriately sized for the tool's complexity.

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 output schema or annotations, the description compensates by thoroughly explaining return values, usage context, and providing an example. It covers the essential operational details an agent needs to invoke the tool effectively.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds an example with realistic values but does not significantly expand on parameter meaning beyond what schema already provides. Therefore 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 clearly states 'Get delivery history for a webhook' with a specific verb and resource. This distinguishes it from siblings like list_webhooks and test_webhook, which serve different purposes.

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 'WHEN TO USE' section lists concrete scenarios (debugging failed deliveries, auditing activity, checking success rates), providing clear context. It does not explicitly exclude alternatives or mention when not to use, but the context is sufficient for selection.

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

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

With no annotations, the description carries the full burden. It discloses the single-account model, that pagination has_more is always false, and that it returns authorization.allowed_tasks. It also signals that the call is safe to use before account-scoped operations, though it does not explicitly state read-only semantics.

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

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

The description is well-structured with clear sections (WHEN TO USE, RETURNS, EXAMPLE) and front-loads the core statement. Every sentence contributes useful context; 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?

The tool is moderately complex (5 params, nested objects, no output schema), and the description adequately covers return shape and edge behavior (has_more false). It is sufficient for an agent to invoke correctly, though it could mention the 'context' parameter's purpose or explicitly state no side effects.

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

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

Schema description coverage is 60%, and the description adds value through examples (status filter) and the one-account model that explains why results are singular. However, it does not clarify the 'context' parameter or the full behavior of the 'account' nested filter 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 opens with a specific verb and resource: 'List the accounts this credential can transact on.' It further clarifies the one-key-one-account model, making it unmistakably distinct from sibling tools like list_media_buys or sync_accounts. The scope and output are explicitly defined.

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 'WHEN TO USE' section lists three concrete scenarios, such as discovering account_id and checking active status before creating a media buy. It lacks an explicit 'when not to use' or named alternatives, but the context is clear enough to guide an agent.

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