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

Annotations already carry the safety profile (destructiveHint=false, idempotentHint=true, openWorldHint=true), yet the description still adds real behavior: a 15,000-domain cap, silent skipping of invalid domains with reporting via `rejected_domains`, and the blast radius ('every order using this filter'). It does not say what happens when the cap is exceeded (error vs. truncation) or how duplicate domains are treated despite the idempotent hint.

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

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

Three short sentences, no filler, with the core action front-loaded and the constraints following in order of operational importance. Every sentence carries distinct 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 mutation tool with no output schema, the description covers the operation, its limit, its partial-failure contract (rejected_domains), and its effect scope. Missing pieces are the outcome when the 15,000 cap is hit and any permission requirements, but nothing essential to calling it correctly is absent.

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 50% – `id` is documented as the filter ID but `domains` is a bare array. The description compensates by defining the per-domain validity rule, the 15,000 limit on the array, and where rejected entries surface, adding genuine meaning beyond the schema's type/minItems constraints.

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

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

States a specific verb and resource: 'Append domains to a domain filter'. The append-versus-create-versus-remove distinction is explicit enough that an agent can separate it from siblings like create_domain_filter and remove_domains_from_filter without reading any schema.

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

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

Usage is implied by the verb 'Append' (mutate an existing filter rather than create one), and the 'Takes effect on every order using this filter' line hints at impact. However, there is no explicit when-to-use, when-not-to-use, or named alternative, so the agent must infer the routing.

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

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

Annotations cover the safety profile: it is a non-read-only, non-destructive, non-idempotent, open-world operation. The description adds useful behavioral detail beyond that by saying invalid domains are skipped and returned in `rejected_domains`, and that attachment happens separately in the dashboard.

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

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

Three short sentences, front-loaded with the core action and followed by the most important behavioral caveat and post-creation step. There is no wasted language.

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

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

For a creation tool with no output schema and only 50% schema description coverage, the description should explain more about required fields and the return shape. It does provide the rejected-domain behavior, but omits meaningful details about naming, optional IP entries, and how the created filter is 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?

Schema coverage is 50%, and the description clarifies list_type values and invalid-domain handling for domains. However, it does not explain the required `name` parameter or the optional `ips` parameter, leaving clear gaps in parameter semantics.

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

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

The description states a specific verb and resource: creating a domain blacklist or whitelist filter. It is clear what the tool does, but it does not explicitly differentiate itself from sibling tools such as add_domains_to_filter or list_domain_filters.

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 only usage-related detail is that the filter must later be attached to an order in the dashboard. It does not explain when to create a new filter versus using add_domains_to_filter, nor does it mention prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description usefully discloses the returned fields, which matters since there is no output schema, but it adds nothing about auth requirements or error 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?

A single compact phrase that front-loads the resource and lists the payload without waste. It is a fragment rather than a sentence, but nothing is padded.

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

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

For a zero-parameter read tool, the description covers what the account object contains, and annotations plus the empty schema cover the rest. Without an output schema, listing the fields is the key contribution, and it does 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?

Zero parameters, so per the rubric the baseline is 4. There is no parameter meaning to add.

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

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

The description names the specific resource (the current TrafficOX account) and enumerates the payload (email, name, balance). It's clear what the tool returns, though the verb is only implied and it doesn't explicitly contrast with siblings like get_balance_stats.

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

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

There is no guidance on when to call this versus get_balance_stats or get_order_stats. The word 'Current' hints at self-scoped account lookup but no explicit condition or alternative is given.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the currency (USD) and the aggregation shape (daily values plus totals plus current balance), but says nothing about range limits, defaults, or pagination. With annotations carrying the safety burden, this is adequate-but-thin.

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

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

A single sentence with zero filler, and the core return content is front-loaded. It is efficient, though its brevity borders on under-specification for a reporting tool with no 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?

With no output schema, the description does the necessary work of naming what comes back: per-day earned/spent, totals, and current balance. Range defaults and limits live in the schema, so the remaining gap is only the missing routing guidance versus sibling stats tools.

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

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

Schema description coverage is 100%, and the schema fully documents both date_start and date_end including formats, defaults, and the 60-day/90-day limits. The description adds no parameter semantics beyond that, so the baseline 3 applies.

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

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

Names a specific resource and return shape: daily earned/spent in USD plus totals and current balance. An agent can tell it apart from list_orders or get_order_stats because the resource is account balance, but the description never explicitly contrasts itself with the sibling stats tools (get_order_stats, get_rtb_stats), so it stops short of full differentiation.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no named alternative. The agent must infer that this is the balance-reporting tool from the description alone; nothing tells it when this tool is preferable to the other stats/report tools in the sibling list.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that the response includes postback settings, which is useful context beyond the annotations, but it omits any mention of permissions, error behavior, or rate limits.

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

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

The description is a single short fragment with no filler. It is front-loaded with the core scope ('one conversion tracker') and immediately appends the notable output detail ('with its postback settings').

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 get-by-id tool with no output schema and a completely undocumented required parameter, the description is too thin. It says what the object is but not how to identify it or what the return shape entails beyond postback settings.

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 0% for the single required 'id' parameter, and the description does not mention it at all. The agent must rely solely on the schema's type and minLength constraints to know that an identifier is required.

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

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

The description identifies the resource (one conversion tracker) and adds that postback settings are included. Combined with the name 'get_conversion_tracker' and the sibling 'list_conversion_trackers', an agent can distinguish this as the single-item fetch. It lacks an explicit verb, but the scope is clear.

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

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

There is no guidance on when to use this tool versus 'list_conversion_trackers' or other siblings. The description only states what is returned, leaving the agent to infer that this is for fetching a single record by ID.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds one useful piece of behavioral context — that the response includes the filter's full domain list, not just filter metadata — but says nothing about size, pagination of that list, or behavior when the id is unknown.

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

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

A single short sentence with no filler, but it is a noun phrase rather than a front-loaded verb statement, and its brevity comes at the cost of under-specification rather than density.

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?

No output schema exists, so the description should carry more of the burden, yet it omits the id parameter's meaning, when to call this instead of the list sibling, and what happens on a missing/invalid id. For a reader tool on a multi-filter API this is thin.

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

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

There is one parameter (id) with 0% schema description coverage, and the description never mentions it — no explanation that it is the filter identifier, what form it takes, or where it comes from (e.g., list_domain_filters). With the schema silent and the description silent, the parameter's meaning is undocumented.

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 fragment 'One domain filter with its full domain list' identifies the resource and implies retrieval of a single filter including its domains, which distinguishes it from the plural sibling list_domain_filters. However, it lacks an explicit verb (get/retrieve) and never states that it is a lookup by identifier, so the purpose is inferable rather than stated.

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

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

No guidance on when to use this versus list_domain_filters (many filters) or get_filter_values. There is no mention of preconditions, required identifiers, or exclusions — the agent must infer that a singular 'one' result implies use when an id is already known.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety and external access are covered. The description adds valuable context by specifying the content categories returned and advising pre-filtering use, though it does not describe the return format or any limitations.

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

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

Two short sentences, front-loaded with the tool's output categories followed by a concise usage recommendation. 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 simple lookup nature, no parameters, and annotations covering safety, the description is nearly complete. It could optionally clarify the return structure (e.g., arrays per category), but the listed categories make the tool's behavior sufficiently clear for correct invocation.

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

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

The tool takes no parameters, so there is nothing for the description to document beyond the schema. Baseline score of 4 applies as no 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 clearly states the tool returns valid values for stats filters, explicitly listing the covered dimensions (countries, categories, OS, browsers, platform). It distinguishes itself from a generic filter getter, though it does not explicitly name a sibling tool for contrast.

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

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

The description gives a clear usage trigger: 'Call this before filtering if unsure of exact spelling.' This tells the agent when to invoke it, but does not state when not to use it or name alternative tools for known values.

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

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

Annotations already establish readOnlyHint=true and openWorldHint=true, so safety is covered. The description then adds genuinely non-structured context: the return payload is side-dependent, with buy orders including targeting (order_filter), traffic filter, and domain filter objects. That is useful beyond the schema, though it says nothing about auth, missing-id behavior, or the sell-order payload.

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

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

Two short sentences with no filler, and the core purpose is front-loaded before the side-specific caveat. The opening fragment ('Full order details') is terse but effective; minor tightening is possible but nothing is wasted.

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 bears responsibility for describing what comes back, and it only covers the buy-order case — the sell-order return shape is unspecified. It also omits behavior for invalid ids. Adequate but incomplete for a tool whose whole value is its return payload.

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%, including enum explanations for side and format, so the schema does the heavy lifting and baseline is 3. The description's mention of 'order_filter'/domain filter refers to response contents rather than parameters, so it adds no parameter-level meaning.

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

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

The description states a specific verb-resource pairing ('Full order details') and clarifies that the payload differs by side, with buy orders carrying extra nested structures. It does not, however, differentiate itself from close siblings such as list_orders or get_order_stats, so an agent still has to infer which retrieval tool to pick.

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

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

There is no when-to-use or when-not-to-use guidance and no named alternative. Given siblings like list_orders (bulk) and get_order_stats (metrics), the description should say this is the single-order lookup, but it leaves that routing entirely to inference.

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

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

Annotations only declare readOnlyHint and openWorldHint, so the description carries real added burden and delivers: buy orders cap at 1000 rows, pagination is sell-only, and subdimension produces a nested `sub` object per row. It does not mention rate limits or auth, but the operational constraints it does disclose are 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?

Front-loads the core purpose in one sentence, then packs per-side field lists and constraint clauses with no filler. Every sentence conveys actionable information, including the otherwise-undocumented return fields.

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 21-parameter tool with no output schema, the description compensates well by enumerating the buy/sell return columns and the key constraint interactions. It omits the date-range limits (60 days / 90-day lookback) already in the schema, and does not route to sibling tools, leaving minor gaps.

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

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

With 90% schema coverage the baseline is 3, and the description exceeds it by clarifying cross-parameter behavior the schema cannot express: the sub_id/domain restrictions, the requirement that subdimension differ from group_by, and that from/size/order_field/order_direction are inert for buy orders.

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

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

States a specific verb and resource ('Statistics of one buy or sell order grouped by a dimension') and enumerates the returned fields per side, so the agent knows exactly what the tool produces. It does not explicitly name or differentiate against siblings like get_sub_id_report, get_balance_stats, or get_rtb_stats, so it stops short of a 5.

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

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

Provides concrete conditional rules: group_by=sub_id is sell-only, group_by=domain is unavailable for sticker sell orders, and pagination params apply only to sell orders. These exclusions tell the agent when the tool works, but no alternative tool is named for the excluded cases.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safe-read profile is covered. The description adds only the small detail that feed settings are included in the result; it says nothing about auth requirements, error behavior when the id is unknown, or format-scoped lookup. With annotations carrying the safety burden, this is adequate but thin.

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

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

A single short sentence with zero filler, and the resource is front-loaded. It is efficient, though so terse that it edges toward under-specification rather than crisp conciseness.

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

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

With no output schema, the description should carry some notion of what is returned; 'with its settings' gestures at that but never enumerates or characterizes the payload. For a two-parameter read tool with full schema coverage and annotations, the definition is minimally complete but leaves return-value expectations unset.

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

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

Schema description coverage is 100%, and the schema documents both `id` (hex or numeric) and the `format` enum, so the description need not repeat them. It adds no meaning beyond the schema, which is the expected baseline when the schema is fully documented.

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 phrase 'One RTB demand feed with its settings' identifies the resource (a single RTB feed) and implies retrieval, but it uses no verb and never distinguishes itself from the sibling list_rtb_feeds or get_rtb_stats. An agent can guess the intent but must infer that this is the single-item lookup.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no reference to the obvious alternative list_rtb_feeds. The singular 'One ... feed' is the only hint that this fetches a specific record rather than a collection.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description still adds behavior the annotations do not: implicit row caps (10 rows for terms groupings unless `size` is set) and the nested sub-breakdown shape produced by subdimension. It omits pagination behavior for `from`/`size` and any rate/limit notes.

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

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

Three tight sentences, front-loaded with the primary scope decision (account vs. feed) before the secondary grouping behavior. The only friction is the odd phrase 'Terms groupings', which is undefined jargon and costs a little clarity without adding much length.

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

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

For an 18-parameter, no-output-schema analytics tool, it covers the non-obvious axes: grouping dimension, optional feed narrowing, nested subdimension, and default row counts. Filter parameters (countries, browsers, OS, ISPs, date ranges) rely entirely on the 83%-covered schema, which is acceptable, though the date-range limits live only in schema descriptions.

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?

Adds real meaning beyond the schema: it explains that feed_id narrows to a single feed, that subdimension must differ from group_by and injects a nested `sub` block into each row, and that `feed` splits rows per RTB feed. These semantics for subdimension/group_by interaction are not derivable from the enum lists alone.

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

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

States a specific verb+resource (RTB statistics) and precise scope: account-wide, or narrowed to a single feed when feed_id is given. Clearly distinct from sibling readers like get_rtb_feed (single feed details) and get_balance_stats (different metric family), so an agent can select it without opening the schema.

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

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

It conveys scope conditions (whole account vs. one feed via feed_id, terms groupings default to 10 rows), which implies usage context, but never says when to prefer this over alternatives such as get_order_stats, get_rtb_feed, or list_rtb_feeds. No explicit when-not or alternative routing is provided.

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

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

Annotations cover read-only and open-world traits, so the bar is lower, and the description adds a genuinely useful behavior beyond them: cursor pagination with the round-trip instruction 'pass the returned `after` to get the next page'. It also flags the hex-id requirement, but does not mention the 60-day range / 90-day lookback limits (left to the schema).

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

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

A tight two-clause sentence with the core operation front-loaded and no filler. 'Works for any format' is slightly vague and costs a little precision, keeping it short of a 5.

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 15-parameter report tool with no output schema, the description covers the essentials: what is grouped, how pagination works, and the required id. It conveys the shape of the return (earnings by sub-ID level) but omits any note on filter interaction or the date-range caps that constrain calling it correctly.

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

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

Schema description coverage is 93%, so the schema already documents nearly all 15 parameters, including date bounds and the `after` cursor. The description only reinforces the id format and the grouping parameter, adding little syntax or meaning beyond the schema — the baseline 3 applies.

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

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

The description names a concrete resource and scope: 'Sell-order earnings grouped by up to three sub-ID levels (sub_id_1..3)'. That is clearly distinct from siblings like get_order_stats or get_balance_stats, though no sibling is named or contrasted 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?

'Works for any format; needs the hex order id' states a prerequisite but gives no when-to-use guidance versus the other stats/report siblings, and no exclusion conditions. Usage is implied rather than directed.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description usefully adds ordering ('newest first') and that results are paginated, but says nothing about default page size, rate limits, or what a postback record contains.

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

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

A single front-loaded sentence that identifies the resource, ordering, and pagination with no filler. It is efficient, though borderline terse given how much it leaves unexplained.

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 6-parameter filtered list with 33% schema coverage and no output schema, the description should explain the filterable dimensions (status, event_type, visitor) and default paging. Instead it covers only ordering and the bare fact of pagination, leaving the agent under-informed about how to call it correctly.

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

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

Schema description coverage is only 33%: 'id' and 'per_page' are documented in the schema, while page, status, event_type, and visitor_id have no descriptions. The description adds no parameter meaning at all, so it fails to compensate for the coverage gap on a 6-parameter tool.

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

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

States a specific resource ('Conversion postbacks received by a tracker') plus ordering, so the agent knows this lists conversion events scoped to one tracker, which separates it from list_orders or list_conversion_trackers. It stops short of explicitly naming a sibling or restating the verb 'list' outside the tool name.

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

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

The description gives no when-to-use or when-not-to-use guidance. With close siblings like list_conversion_trackers and get_conversion_tracker in the toolset, an agent gets no explicit rule for choosing this tool, only an implicit read of its purpose.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds only 'of the account' as scope context and says nothing about pagination, result limits, or how the optional status filter affects results, so it contributes very little behaviorally.

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?

At six words it is short, but this is under-specification rather than conciseness: it is a sentence fragment with no actionable content front-loaded beyond the resource name. Every word earns little because no real information is conveyed.

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 low-complexity list tool with no output schema, the description still omits the one parameter's purpose, expected return shape, and relationship to sibling tools. An agent would have to guess what a 'conversion tracker' is and whether filtering is needed.

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 single parameter (status, enum active/paused) has 0% schema description coverage, so the description carries the burden of explaining it — but the status filter is never mentioned. The description adds no meaning beyond the schema's enum values.

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 the resource (S2S conversion trackers) and scopes it to the account, but it is a bare noun phrase with no verb and the 'S2S' jargon is never expanded. The verb 'list' must be inferred from the tool name, and nothing distinguishes it from the sibling get_conversion_tracker or list_conversion_events beyond plurality.

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

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

There is no guidance on when to use this list tool versus get_conversion_tracker (single) or list_conversion_events, nor any mention of prerequisites or context. Usage is only implied by the name.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The '20 per page' note hints at pagination behavior but merely mirrors the schema's length maximum of 20, adding little beyond the structured data.

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?

Very short and front-loaded, but it is a bare noun phrase rather than a structured sentence, and its brevity comes at the cost of missing information rather than earning its place through density.

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

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

With no output schema and half the parameters undocumented, the description should carry more of the burden – at minimum what each list entry contains and how paging works. For a read-only list endpoint with four params, this is under-specified.

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

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

Schema description coverage is 50%: 'page' and 'list_type' are undocumented in both schema and description. The description only echoes the 20-per-page limit already encoded in the length parameter and says nothing about paging or filtering by list_type/search.

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

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

The description names the resource precisely – domain blacklists/whitelists belonging to the account – so an agent knows what the tool returns. It lacks an explicit verb and never distinguishes itself from the sibling get_domain_filter (singular), relying on the tool name to imply listing versus fetching.

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

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

No when-to-use or when-not-to-use guidance is given, and no alternatives are named. Nothing tells the agent whether to call this versus get_domain_filter or get_filter_values when it wants filter data.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds no behavioral detail beyond that — no pagination, ordering, result caps, or volume expectations — and the buy/sell semantics it restates are already in the schema.

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

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

A single tight sentence with the key qualifiers (buy vs sell, one format, this account) front-loaded. It earns its place, though the parenthetical glosses duplicate schema enum text rather than adding 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 two-parameter list tool with no output schema, the description covers what the tool operates on but omits anything about the return shape or result size. Combined with annotations covering the read-only profile, it is minimally viable rather than complete.

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

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

Schema description coverage is 100% and both parameters have enums with their own descriptions, so the baseline is 3. The phrase 'for one ad format' echoes the format parameter but adds no syntax or value detail beyond the schema.

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

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

The description names the resource (orders) and distinguishes both modes (buy orders = campaigns, sell orders = placements) and the scoping (one ad format, this account). It is clear what the tool returns, though it does not explicitly contrast itself with the singular sibling get_order.

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

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

There is no guidance on when to use this list tool versus get_order, get_order_stats, or the set_* state tools. The agent must infer from the name that this is the enumeration tool; no conditions or exclusions are stated.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description's only added behavioral signal is 'with state', hinting that returned feeds carry a state field, which is modest value beyond the annotations; no pagination, volume, or ordering context is given.

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?

One short sentence with no filler, and the resource is front-loaded before the scoping qualifier. Nothing is repeated and nothing extraneous is included.

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 one-parameter, read-only list tool with fully documented schema and no output schema, the description covers resource, scope, and the hint that state is included. It is essentially complete; only the relationship to sibling feed tools is left implicit.

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

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

Schema description coverage is 100% and the single 'format' parameter already has an enum of popunder/sticker plus a description, so the schema carries the load. The description only restates that exactly one format scopes the listing, adding no format semantics or defaults.

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

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

States a specific resource ('RTB demand feeds (DSP endpoints) of the account') with the scoping qualifier 'for one format, with state', so an agent can tell it lists feeds rather than fetching one. It does not explicitly name sibling get_rtb_feed or set_rtb_feed_state, so it stops short of a 5.

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

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

The phrase 'of the account for one format' implies this is the enumeration entry point and that the caller must pick a format, but there is no explicit when-to-use statement or pointer to get_rtb_feed for a single feed or set_rtb_feed_state for mutation. Usage is inferable but not stated.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful behavioral context beyond that: the removal cascades to 'every order using this filter', which tells the agent the blast radius of the mutation.

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

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

Two tight sentences with no filler; the action is front-loaded and the impact note follows immediately. Every sentence earns its place.

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

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

For a destructive mutation the annotations carry the safety profile and the cascade effect is disclosed, so the core is covered. Missing are the return/error behavior and what happens on partial or non-matching removals, which an agent would want before calling.

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 only 50% (id is documented, the domains array is not). The description names 'domains' and 'domain filter' but adds no detail such as matching behavior, duplicate handling, or what happens if a domain is absent from the filter.

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

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

States a specific verb (remove) and resource (domains from a domain filter), which cleanly distinguishes it from its sibling add_domains_to_filter. It stops short of naming that sibling or otherwise anchoring itself in the family, so it is clear but not maximally differentiating.

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

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

There is no explicit when-to-use, when-not-to-use, or prerequisite guidance (e.g. that the filter must exist, or that add_domains_to_filter is the counterpart operation). Usage is only inferable from the verb and the sibling list.

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

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

Annotations already declare this as destructive, idempotent, and open-world, but the description adds important business context: starting the order resumes buying traffic and spending balance. This clarifies the financial consequence beyond what the safety annotations alone convey.

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

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

Two sentences, front-loaded with the core action and followed by a high-value consequence. Every sentence earns its place and there is no wasted text.

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

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

For a two-parameter mutation tool with annotations covering safety and idempotency, the description supplies the key operational effect of starting an order. It does not explain the return value, but no output schema exists, and the remaining omission—explicit pause behavior—is strongly implied.

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 50%, with id documented in the schema but state enum values lacking descriptions. The description compensates by mapping active to start and paused to pause, but it adds no meaning for the id 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 states a specific verb and resource: start or pause a popunder buy order. It distinguishes itself from sibling state setter set_rtb_feed_state by scoping to buy orders, and clearly maps active to start and paused to pause.

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

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

The description implies usage by naming the two states and noting that starting resumes buying traffic and spending balance. However, it gives no explicit when-to-use guidance, no conditions for choosing start versus pause, and no alternatives 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?

Annotations already declare destructive=true, idempotent=true and openWorld=true, so the description adds genuinely new context: bidding changes propagate within ~10 seconds and account managers are notified. That latency and human-notification side effect are exactly what an agent needs before flipping a live feed off.

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

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

A single front-loaded sentence: action, resource, then the state mapping, then the two consequences. Nothing is redundant and nothing is buried.

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 three-parameter mutation with no output schema and full annotation coverage, the description supplies the propagation delay, the side-effect notification, and the state mapping. An agent has enough to call it correctly and anticipate the effect.

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 67% and the id/format fields are already documented, but the description supplies the missing semantics for `state` by equating active with start and paused with pause. That closes the main gap for a required enum parameter with no schema description.

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

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

States a specific verb pair (start/pause) and resource (RTB demand feed), and maps each enum value to its effect. It is clearly a state mutation, distinguishable from read siblings like list_rtb_feeds and get_rtb_feed, though it never names an alternative outright.

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

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

The scope (RTB feeds, not other entities) is implied by the wording, and the analogous set_buy_order_state sibling is not referenced to route the agent. There is no explicit statement of when to use this versus pausing bids another way, nor any prerequisite or exclusion.

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