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

With no annotations, the description carries the full behavioral burden and discloses almost nothing: it does not say the deletion is irreversible, whether the registry file must be re-read afterwards (accounts.reload is a sibling), what happens if the profile id is unknown, or what permissions are needed. For a destructive, file-mutating operation this is a significant gap.

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

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

A single front-loaded sentence with no filler; the verb and target come first. It is efficient, though the trailing phrase 'from the accounts registry file' could carry more information than it does.

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

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

For a parameterless-annotation, output-schema-less destructive tool, the definition is too thin: irreversibility, post-delete file state, and interaction with accounts.reload are all unaddressed. The schema covers input but the description does not compensate for the missing behavioral and recovery 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% and the single parameter already documents itself as 'Profile id to delete.', so the baseline is 3. The description adds no format, origin, or lookup hints beyond what the schema 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?

Names a specific verb (Delete) and resource (a project profile in the accounts registry file), which is enough for an agent to distinguish it from accounts.list, accounts.reload and accounts.upsert. It does not explicitly contrast itself with those siblings, but the destructive verb makes the intent unambiguous.

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

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

No when-to-use guidance: nothing says this is the tool for removing a profile versus editing it via accounts.upsert, and no prerequisite or confirmation conditions are stated. The agent must infer usage entirely from 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 idempotentHint=true, so the safety profile is covered. The description adds one useful behavioral fact beyond that – the data comes from a local 'accounts registry file' rather than a remote API – but says nothing about freshness, caching, or whether reload is needed to see new entries.

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 with zero filler; the verb, resource, and source are all packed in without waste. It is appropriately sized for a trivial no-argument listing 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 parameterless read whose output schema documents the return shape and whose annotations cover the safety profile, the definition is essentially complete. The only shortfall is the absence of any relationship to accounts.reload or accounts.upsert, which would matter for agent sequencing.

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 zero parameters, so per the baseline rule this is a 4. The description adds nothing parameter-related, but nothing is needed, and the schema is empty.

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 ('List') and resource ('configured project profiles'), and names the source ('accounts registry file'), which distinguishes it from write-oriented siblings like accounts.upsert or accounts.delete. It does not explicitly contrast itself with accounts.reload, but the read semantics are 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?

Usage is implied rather than stated: an agent can infer this is the discovery step before upsert/delete on accounts. There is no explicit when-to-use or when-not-to-use guidance, nor a pointer to siblings such as accounts.reload for refreshing the registry.

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 behavioral burden. It does disclose the important behavior that server cache state is mutated from the on-disk source, but says nothing about whether the reload replaces or merges existing entries, whether it is idempotent, whether it fails on malformed files, or what permissions are required.

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 the action front-loaded and the side effect parenthetical at the end. No filler, nothing to trim.

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 parameterless reload, the core operation is conveyed, but with no output schema and no annotations the description omits what the call returns (e.g. count of loaded accounts) and how errors surface. These gaps are minor but real for an agent deciding whether to call it.

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 zero parameters (empty object schema), so there is nothing for the description to disambiguate. Baseline for a parameterless tool 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?

States a specific verb (reload) and resource (accounts registry) plus the mechanism (from disk) and side effect (updates server cache). This clearly separates it from siblings accounts.list, accounts.upsert and accounts.delete, 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?

Usage is only implied: reloading 'from disk' suggests the caller should invoke it after the on-disk registry has changed. There is no explicit when-to-use, when-not-to-use, or comparison to accounts.upsert/accounts.list for refreshing state.

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

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

With no annotations, the description carries the full behavioral burden. It says 'create or update' but never states what happens on conflict, whether the write touches the on-disk registry file (implying persistence), whether a reload is required for changes to take effect, or what permissions/auth the write needs. These are meaningful gaps for a mutation tool.

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

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

One short, front-loaded sentence with zero filler and the verb+resource stated immediately. It is arguably too terse for the operation's complexity, but on the conciseness axis it is essentially optimal.

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 annotations and no output schema, the description omits critical context: whether the change persists to the registry file, whether the in-memory registry must be reloaded (a sibling exists), and what the tool returns. An agent could invoke it, but not confidently.

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

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

Schema description coverage is 100%, so every parameter is already documented, including the patch-vs-replace semantics of 'replace' and the meaning of 'account_id'. The description adds no parameter-level detail beyond the schema, 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?

States a specific verb pair (create or update) and resource (project profile in the accounts registry file), which is clear and distinguishable from siblings like accounts.delete and accounts.list. It does not explicitly position itself against accounts.reload or the other accounts tools, 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?

There is no guidance on when to prefer upsert over accounting operations like accounts.reload, nor any note about preconditions such as the registry needing to exist or be reloaded afterward. The only usage signal is the word 'upsert' in the name, which the description merely restates.

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. 'Preview' conveys a non-mutating, read-only operation and the apply flag's 'must be false' reinforces that, but there is no disclosure of auth requirements, rate limits, or what the returned plan contains. Minimal but non-contradictory.

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 sentence with the core purpose front-loaded. The only waste is the 'Human-friendly:' tag, which carries no operational meaning.

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

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

Five parameters, no annotations, and no output schema, yet the description never explains what an activation plan looks like, what targets resolve to, or what the preview returns. For a preview tool whose whole value is the returned plan, this leaves an important gap.

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

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

Schema coverage is 80%, so the schema already documents most parameters (apply, targets, account_id, direct_client_login). The description adds no syntax or semantic detail beyond what the schema provides, 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?

States a clear verb+resource: 'preview Direct activation plan for an Audience segment.' It also distinguishes itself from the apply sibling ('pro-only apply tool is separate'), which helps an agent tell it apart. The 'Human-friendly:' prefix is filler but doesn't obscure the purpose.

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

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

The description signals this is the preview/non-mutating counterpart to a separate apply tool, implying 'use this to preview, use apply to commit.' However it never names the alternative tool (audience.hf.apply_activation_plan) explicitly nor states the condition for choosing one over the other, leaving the routing partly 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?

No annotations, so the description carries the full burden for a mutation tool, yet it says nothing about what the plan actually changes (bids, modifiers, targeting), whether changes are reversible, or that dry_run defaults to true. 'Pro-only' is the only behavioral context provided.

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 with no filler; 'Human-friendly:' framing is mildly wasteful but the operation and gating condition come first.

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 unannotated write operation with six parameters and no output schema, the description omits consequences, permissions beyond 'pro-only', dry-run behavior, and the relationship to the plan-generating sibling. Not enough for an agent to call it safely.

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 only restates apply=true, which the schema already documents verbatim, and says nothing about targets, segment_id, account_id, or direct_client_login. With 67% schema coverage the description adds essentially no param meaning beyond the schema.

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

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

States a specific verb+resource (apply an activation plan for an Audience segment in Direct) and names the gating condition (apply=true). It implicitly contrasts with the sibling audience.hf.activation_plan that produces the plan, though it never names 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 parenthetical '(pro-only, apply=true)' hints at a prerequisite and the schema's 'Must be true to execute' reinforces it, but the description never says when to use this versus generating a plan first or what happens on failure. Usage is implied rather than stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose read-only status, pagination behavior, authentication requirements, or return format beyond the vague word 'catalog.'

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 single sentence is concise and free of fluff, but 'Human-friendly:' is an awkward prefix and the key resource phrase is not front-loaded as clearly as it could be.

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 5-parameter tool with no annotations and no output schema, the description is far too thin. It omits pagination, the include_health flag, account resolution behavior, and what the catalog actually returns.

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 no parameter meaning. With 60% schema description coverage, limit and offset remain undocumented in both schema and description, and no compensation is provided for those gaps.

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 as an audience segments catalog intended for dashboards, but it uses a noun phrase with no clear verb and does not distinguish it from siblings like audience.segments.list or audience.hf.find_segment.

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 hint is 'for dashboards,' which implies a dashboard context but gives no explicit when-to-use, when-not-to-use, or alternative tools to consider.

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

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

With no annotations, the description carries the full behavioral burden, but it discloses almost nothing beyond the read-oriented verb 'find'. It does not state permissions, pagination, whether results are limited by default, or what happens when include_raw is set, so important behavioral context is missing.

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

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

It is a single short sentence that is front-loaded with the action and resource. The 'Human-friendly:' prefix is somewhat expendable, but overall there is little waste.

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 7-parameter tool with no annotations, no output schema, and only 57% schema description coverage, the description is too sparse. It omits usage guidance, parameter semantics for several arguments, and behavioral details an agent needs to call the tool reliably.

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 names the filter fields name/type/status, which correspond to name_contains, types, and statuses. But schema description coverage is only 57%, and the description does not explain value formats, supported type/status values, or the roles of limit, account_id, include_raw, and direct_client_login.

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 ('find Audience segments') and names the filter dimensions (name/type/status), so an agent can understand the operation. However, it does not distinguish this tool from sibling tools like audience.segments.list or audience.segments.get, and the 'Human-friendly' prefix adds little specificity.

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 guidance, no prerequisites, and no explicit contrast with alternatives such as audience.segments.list. It only implies usage through the filter terms, leaving the agent to infer when this wrapper is preferable.

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 burden, yet it discloses almost nothing: it does not state that this is a read-only operation, whether it requires auth or an account_id, response size, or caching/freshness behavior. The only hint is 'Human-friendly' implying a formatted output, which is thin for a tool with zero annotation coverage.

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?

It is a single short sentence with zero padding, so nothing is wasted, but that brevity reflects under-specification rather than economy. Size is appropriate only in the sense that there is nothing to trim.

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 4 parameters, no annotations, and no output schema, the description should explain what the summary contains and when to use it. It provides none of that, leaving the agent without enough context to call it correctly or prefer it over siblings.

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 75%, so the schema already explains account_id, include_raw, and direct_client_login; only the required segment_id lacks a description. The description adds no parameter meaning at all, but with high coverage the schema does the heavy lifting, warranting 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 phrase 'Audience segment summary card' essentially restates the tool name get_segment_summary, and 'Human-friendly ... for UI/LLM' is a vague qualifier rather than a specific verb+resource statement. It does not distinguish this tool from close siblings such as audience.segments.get, audience.hf.segment_health, or audience.hf.segment_perf, so an agent cannot tell which one to pick from this text.

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 prerequisites, and no mention of alternatives. Given the dense sibling cluster of audience/hf segment tools, the absence of any routing signal leaves the agent to guess.

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 behavioral burden. It discloses only that the output is a sparse matrix, without stating whether the operation is read-only, what permissions or account context are needed, how top_k affects results, or what the matrix values represent.

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 definition is a single short sentence and is not verbose, but 'Human-friendly:' is vague filler that does not earn its place. The core information is front-loaded enough to avoid confusion, though the sentence is under-specified rather than efficient.

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

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

With no annotations and no output schema, the description should explain the return shape and key behavioral context. It only hints at a sparse overlap matrix, leaving the output format, authentication/account requirements, and comparison semantics undocumented for a 4-parameter analytical 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 75%, with top_k, account_id, and direct_client_login already documented in the input schema. The description adds only 'for segment ids,' which repeats the required parameter and provides no additional meaning for the remaining parameters or the expected array format.

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 'overlap matrix (sparse) for segment ids' names a resource and input scope, so the general purpose is inferable. However, it lacks a clear verb and does not distinguish this tool from the sibling audience.segments.overlap, leaving ambiguity about what operation is performed.

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 guidance on when to use this tool, when not to use it, or which sibling alternatives exist. The only context is 'for segment ids,' which identifies an input rather than a usage condition.

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 behavioral burden, and it delivers almost nothing: no indication that this is a read-only diagnostic, no statement of what thresholds constitute 'healthy', no mention of how min_size/max_age_days influence the verdict, and no error or rate-limit context. Only the vague 'Human-friendly' hint at output formatting is offered.

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, so it is not bloated, but the 'Human-friendly:' prefix is filler and the sentence is under-specified rather than efficient. Brevity here comes at the cost of usefulness.

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 5-parameter tool with no annotations and no output schema, the description should explain what the health check evaluates and what the agent gets back. It provides neither, leaving the agent unable to predict results or interpret the min_size/max_age_days thresholds.

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 80%, with defaults for min_size and max_age_days and an explanation of account_id/direct_client_login already in the schema, so the baseline of 3 applies. The description adds no parameter meaning and does not compensate for the undocumented required segment_id, which is the one parameter left blank in the schema.

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

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

The description names a resource (audience segment) and an action (health check), so the general domain is clear. However, 'health check' is essentially a restatement of the tool name 'segment_health' and never says what is actually being checked (size, recency, overlap, deliverability?), so an agent cannot distinguish it from siblings like audience.hf.get_segment_summary or audience.hf.segment_perf.

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

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

There is no guidance on when to use this tool versus the many adjacent audience segment tools (get, summary, stats, overlap, perf). No prerequisites, no exclusions, no named alternative — the agent must guess from the name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Best-effort' hints that results may be partial or unreliable and 'Human-friendly' implies a formatted rather than raw output, but auth requirements, rate limits, failure modes, and whether the two data sources are merged or fallback are all undisclosed.

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?

It is a single short sentence with no padding, but it is under-specified rather than concise. The 'Human-friendly:' prefix front-loads a marketing qualifier instead of the operation's defining behavior.

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 9-parameter tool with 3 required args, no output schema, and no annotations, a one-line description is far from complete. It leaves the agent unable to distinguish this tool from the many sibling audience.hf.* reporting tools or to use its parameters 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 a moderate 67%, and the description adds no parameter meaning at all. It gives no hint about grain, goal_ids, include_raw_refs, account_id/counter_id resolution, or the direct_client_login override, so the agent cannot compensate for the undocumented 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 names a resource ('segment performance') and the underlying data sources ('Direct+Metrica'), which is more than a tautology. However, the qualifiers 'Human-friendly' and 'best-effort' are vague, and it does not distinguish this tool from siblings like audience.hf.get_segment_summary or audience.hf.segment_health.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of competing tools (segment_health, get_segment_summary, overlap_matrix). The agent is left to infer whether this is a summary, a time series, or a per-goal breakdown.

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 state that this is a read-only operation, what happens on an invalid/missing id, whether it requires specific scopes, or what the response 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 with zero waste. It is appropriately short, though this brevity comes at the cost of substance rather than being a virtue of information 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?

For a 2-parameter retrieval tool with no annotations, no output schema, and 0% parameter coverage, the definition leaves the agent without the parameter semantics or behavioral context needed to call it confidently.

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%, so the description must explain both parameters. It implies the 'id' lookup key but adds no format/type detail, and the 'fields' parameter (a projection/filter list) is completely unaddressed in both schema and 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 (get) and resource (lookalike) plus the retrieval key ('by id'), which distinguishes it from the sibling audience.lookalikes.list. It is clear what the tool does, though it never explicitly contrasts itself with the list sibling.

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 guidance, no prerequisites, and no mention of the lookalikes.list alternative for enumerating lookalikes. The agent must infer usage entirely from 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?

With no annotations the description carries the full behavioral burden. The parenthetical "(best effort)" is a genuinely useful caveat implying results may be incomplete, but nothing is said about pagination behavior, authentication needs, or result ordering. One hint does not cover a mutation-free but opaque list call.

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?

It is a single, front-loaded clause with no padding, which is structurally fine. The brevity, however, tips into under-specification rather than disciplined 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?

For a 3-parameter list tool with no annotations and no output schema, the description should at minimum explain pagination and what a lookalike record contains. Neither is present, leaving the agent under-informed before invocation.

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

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

Schema description coverage is 0% and the description mentions none of the three parameters. limit, offset, and fields are entirely undocumented in both places, so the agent cannot know that pagination and field projection are even supported. The description fails to compensate for the coverage gap.

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?

"list lookalikes" gives a clear verb+resource, and the "Audience:" prefix anchors it to the audience API family. However, it does nothing to separate it from the sibling audience.lookalikes.get, nor does it clarify what a lookalike entity is in this context.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as audience.lookalikes.get for a single entity. The agent is left to infer that 'list' means enumeration of many lookalikes.

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 burden and delivers almost nothing: no statement that it is read-only, no authentication or permission requirements, no error behavior for a missing/foreign pixel_id. Only the word "get" weakly implies a non-mutating read.

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 resource and lookup key front-loaded and zero filler. It is efficient, though efficiency here partly reflects under-specification rather than deliberate economy.

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 getter with no annotations and no output schema, the description should at least identify what the returned pixel representation contains and how "fields" narrows it. Instead it gives one clause, leaving the agent to guess at the response shape and permission model.

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%, so both parameters are undocumented anywhere. "By id" minimally maps to pixel_id, but the optional "fields" array (a field-selection projection) is never explained, leaving half the parameters opaque.

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?

"Get pixel by id" states a specific verb (get) and resource (pixel) with the lookup key made explicit, so the operation is unambiguous. It does not differentiate itself from the sibling audience.pixels.list, nor explain what a "pixel" is in this product context.

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

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

No when-to-use guidance, no prerequisites, and no routing to the obvious alternative audience.pixels.list when the id is unknown. The agent must infer the single-item vs list distinction purely from 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says nothing about read-only nature, permissions, pagination, rate limits, or return format, leaving the agent with no behavioral context beyond the verb 'list'.

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 single sentence is too short and under-specified rather than appropriately concise. It is front-loaded with nothing useful and does not earn its place as a tool description.

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 three undocumented parameters, no output schema, and no annotations, the description is completely inadequate for an agent to invoke the tool correctly. No usage, parameter, or behavioral information is supplied.

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 3 parameters (limit, fields, offset) with 0% description coverage, and the description does not mention any of them. It fails entirely to compensate for the missing parameter documentation.

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 "Audience: list pixels" essentially restates the tool name audience.pixels.list without adding specificity. It does not distinguish the tool from sibling audience.pixels.get or clarify what a pixel is or what scope of pixels is returned, making it tautological.

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

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

There is no guidance on when to use this tool versus alternatives, prerequisites, or context. The agent must infer that it is a basic list operation from the name alone.

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

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

With no annotations, the description carries the full burden. It discloses the pro-only tier requirement, which is useful, but says nothing about the fact that arbitrary methods (POST/PUT/DELETE) can mutate or destroy data, how errors are surfaced, or any rate limits. For a generic write-capable passthrough this is a serious 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?

A single front-loaded clause with zero waste, and the qualifier is placed immediately after the core purpose. It is arguably too terse for a 4-parameter passthrough, but conciseness itself is not the problem.

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 generic raw-API escape hatch with nested params/payload, no output schema, and no annotations, the description is far too thin. An agent cannot tell what the base URL assumption is beyond the schema hint, what the response looks like, or which subjects are valid.

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 only 50%: path and method are described in-schema, while params and payload (both nested objects) are undocumented anywhere. The description adds no parameter meaning at all, so it fails to compensate for the coverage gap on the two most ambiguous inputs.

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 (Audience) and the operation (raw API call), and the parenthetical 'escape hatch' clarifies the role. It is clear enough to distinguish from audience.segments.* siblings, though it never explicitly contrasts with direct.raw_call or metrica.raw_call which follow the same pattern.

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?

'Escape hatch' implies you use this only when no dedicated typed tool exists, and 'pro-only' signals a tier gate. However, no alternatives are named and no conditions/exclusions are spelled out, so the agent must infer when this is preferred over audience.segments.list and friends.

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 behavioral burden. Beyond the 'pro-only' access note, it says nothing about permissions, side effects, idempotency, or what a successful create returns.

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?

It is a single short phrase with no wasted words, but the brevity reflects under-specification rather than efficient editing. Nothing is front-loaded beyond the bare verb+resource.

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 write tool with a nested undocumented payload, no annotations, and no output schema, the description is drastically incomplete. An agent cannot call this correctly from the given information.

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 required parameter is a nested object with 0% schema description coverage, and the description adds no information about its structure or required fields. An agent must construct this payload completely blind.

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 ('create segment') within the Audience namespace, which lets an agent distinguish it from siblings like segments.list/get/update/delete. The 'Audience:' prefix is boilerplate but the core purpose is unambiguous.

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

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

The only guidance is the '(pro-only)' gating constraint. There is no indication of when to create a segment versus using audience.upload.start or segment-related hf tools, nor any prerequisites for the payload.

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

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

With no annotations, the description carries the full behavioral burden. '(pro-only)' discloses a plan/permission constraint, which is genuine added value. But for a destructive mutation it says nothing about irreversibility, cascading effects on campaigns or lookalikes built on the segment, or success/failure 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?

One short sentence that is front-loaded and waste-free, but the 'Audience:' namespace prefix is redundant given the tool name, and the extreme brevity reflects under-specification rather than economical writing.

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?

A destructive, no-annotation, no-output-schema tool with an undocumented required parameter needs considerably more description than this. An agent has enough to attempt the call but not enough to know the consequences or when it should avoid it.

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?

One required parameter (segment_id) with 0% schema description coverage, and the description adds no meaning about its format, where to obtain it, or behavior on invalid IDs. The description does nothing to compensate for the documentation gap.

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 (delete) and resource (segment), and the 'Audience:' prefix identifies the namespace, so an agent can tell what it does. However it does nothing to distinguish it from siblings like audience.segments.update or audience.segments.create beyond the obvious verb, and no scope or effect is described.

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 signal is '(pro-only)', which is a useful access prerequisite but not a when-to-use criterion. There is no guidance on when deletion is appropriate versus updating or listing, and no warning about irreversibility.

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 behavioral burden. 'get' implies a read, but nothing is said about permissions, errors when the id is missing, or return shape. This is thin for a tool with zero annotation coverage.

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 with no waste. It is concise, though its brevity is also the source of its gaps rather than an intentional trade-off.

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 annotations, no output schema, and two undocumented parameters, the definition leaves the agent guessing about the 'fields' argument and the response. It does the bare minimum for a two-parameter lookup 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 0% and neither parameter is documented in the schema. The description hints that segment_id is the lookup key, but the 'fields' parameter (likely a projection selector) is completely unexplained in both schema and description.

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

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

The description names a specific verb and resource ('get segment by id'), making clear this is a single-segment lookup. It implicitly distinguishes itself from list/overlap/stats siblings by saying 'by id', though it never names 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?

No indication of when to use this versus audience.segments.list, audience.hf.find_segment, or audience.hf.get_segment_summary. The agent must infer the retrieval scenario from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether this is a safe read, not pagination behavior, not rate limits, not result shape. For a tool with no annotation coverage this is a complete 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?

It is short, but the brevity is under-specification rather than conciseness: the single sentence carries no usable content. Front-loading a scope and at least one filtering note would cost little and would actually earn its place.

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

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

With five undocumented parameters, no annotations, and no output schema, the description leaves an agent without enough information to invoke the tool correctly or interpret its results. This is inadequate for the tool's actual 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 0% across five parameters (limit, types, fields, offset, statuses), and the description adds no semantics for any of them. The agent gets no hint about valid values, filtering behavior, or the meaning of limit/offset beyond their names.

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 restates the tool name with the namespace spelled out: 'Audience: list segments.' It confirms a list operation over segments, but adds nothing the name does not already convey and makes no attempt to distinguish this from siblings like audience.segments.get, audience.segments.stats, or audience.segments.overlap.

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 at all. With closely related siblings such as audience.segments.get and audience.segments.overlap available, the description gives no condition, scope, or prerequisite that would tell an agent when listing is the right operation.

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

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

No annotations are provided, so the description carries the full behavioral burden. '(best effort)' usefully signals approximate/possibly incomplete results, but nothing is said about permission requirements, compute cost, rate limits, whether segment_ids must already exist, or what the response looks like.

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 not padded, so nothing is wasted, but it is a single fragment rather than a front-loaded sentence with the essential scoping information. Being terse here reflects under-specification rather than disciplined 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?

For a 3-parameter analytical tool with no annotations and no output schema, the description is far too thin. It omits the return shape (matrix vs top_pairs output differs by mode), any interpretation guidance for the overlap values, and how large segment_ids lists are handled.

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% with the mode enum values and limit default already documented in the schema, and segment_ids is self-explanatory as an array of IDs. The description adds no meaning beyond the schema, so the baseline 3 applies; it neither compensates nor subtracts.

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 the resource (segments) and the operation family (overlap), so an agent can tell it computes pairwise intersection between audience segments. However it is phrased as a fragment ('Audience: overlap between segments') rather than a clear verb+object, and it does nothing to distinguish itself from the sibling audience.hf.overlap_matrix or audience.segments.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?

No statement of when to use this versus audience.hf.overlap_matrix, audience.segments.stats, or audience.segments.list. The parenthetical '(best effort)' hints the result may be approximate but gives no condition that would steer an agent toward or away from this tool.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only that results are 'best effort' (an unreliability caveat, which is real value), but says nothing about permissions, latency, or return shape for a stats endpoint.

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 fragment of a sentence — this is under-specification rather than conciseness. There is no waste, but also almost no load-bearing 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?

With no annotations, no output schema, and 0% parameter coverage, the description would need to do far more work. A mutation-free read tool in a crowded audience.* family is left almost entirely unspecified.

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 two parameters. The description never mentions segment_id (required) and only loosely hints at field names via 'size/status', leaving the 'fields' array undocumented in both description and 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?

Names the resource (audience segment) and the kind of data returned (size/status), which narrows things somewhat. But 'stats' is not a specific operation and it fails to distinguish itself from close siblings like audience.segments.get, audience.hf.get_segment_summary, or audience.hf.segment_health.

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

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

No guidance on when to call this versus audience.segments.get or audience.hf.segment_health. The '(best effort)' caveat hints the data may be approximate but doesn't tell the agent when that trade-off is acceptable.

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 behavioral burden. It flags the pro-only restriction, which is genuinely useful, but says nothing about whether updates are partial or full-replace, what the payload structure is, whether changes are reversible, or required permissions.

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, front-loaded sentence with no waste, so it is concise. But it is under-specified rather than efficiently informative; brevity here reflects missing content, not tight editing.

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 zero annotations, no output schema, and an undocumented nested payload object, the description is far from complete. Only the pro-only note partially compensates for the missing structured support.

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

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

Schema description coverage is 0% and one of the two parameters is a free-form nested object ('payload'). The description adds no meaning for either segment_id or payload, leaving the agent with no idea what fields to populate.

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 pairs the verb 'update' with the resource 'segment', which minimally distinguishes it from create/delete/get siblings. However, it mostly restates the tool name and gives no indication of what about the segment is updatable, leaving the scope vague.

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 signal is the '(pro-only)' qualifier, which is a gating condition rather than guidance. There is no statement of when to prefer update over create/delete, no prerequisites, and no mention of alternatives.

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

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

With no annotations, the description carries the full behavioral burden. It only discloses the pro-only gating constraint; it says nothing about read-only nature, return shape, or whether errors are paginated/truncated for large uploads.

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 with no waste. Appropriate size for the minimal information conveyed, though that brevity reflects under-specification rather than efficiency.

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

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

For a tool with no annotations, no output schema, and an undocumented required parameter, the description is too thin. It omits return contents, auth/tier details beyond 'pro', and error-format expectations.

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 0% and the single upload_id parameter is undocumented. The description adds no meaning beyond the parameter name—no format, source (from upload.start?), or validity 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?

Names the specific resource (errors for an audience upload job) and clearly distinguishes itself from siblings like audience.upload.start and audience.upload.status by the 'errors' suffix. The action verb (get/list) is implied rather than stated, but the purpose is unambiguous.

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

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

No guidance on when to call this versus audience.upload.status or audience.raw_call. 'pro-only' hints at a prerequisite tier but there is no when-to-use or when-not-to-use context.

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

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

No annotations are provided, so the description carries the full burden. It does add two genuinely useful behavioral facts — pro-only access and possible PII content — which is more than most terse descriptions offer. But it omits whether the operation is async, whether it is idempotent or destructive, what it returns (a job id?), and any 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?

Single sentence with no filler and the key constraint (pro-only/PII) front-loaded, which is good. But for a tool with a nested payload object and zero schema documentation, one sentence is under-sized rather than concise.

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

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

No output schema, no annotations, 0% parameter coverage, and a nested payload object — yet the description says nothing about the upload lifecycle or how to follow up. It is not complete enough for an agent to invoke this correctly without guessing at the payload 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?

Schema description coverage is 0% with two required parameters, one of which is a nested object. The description names neither segment_id nor payload and gives no format, structure, or size expectations for the payload. The only faint signal is 'may include PII', which hints at payload content but documents nothing.

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

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

The description gives a specific verb+resource ('start upload job' under 'Audience'), which is enough to distinguish it from siblings like audience.upload.status and audience.upload.errors. However it never explains that the job targets a segment via segment_id, so the specificity is thin.

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 guidance, no prerequisites beyond the parenthetical pro-only note, and no mention of the obviously related siblings (audience.upload.status, audience.upload.errors) that an agent would need after starting a job. The agent must infer the entire workflow.

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

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

No annotations, so the description carries the full burden and does almost nothing: it notes a pro-only requirement but says nothing about polling behavior, terminal vs in-progress states, expiration of job status, or auth needs. A status endpoint's whole value is knowing what states it reports.

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

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

Five words, fully front-loaded, no filler. It is efficient, though the brevity borders on under-specification rather than true 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?

For a simple one-parameter tool this is thin: no output schema exists, so return values (status codes/fields) are undocumented, and the origin of upload_id is unstated. An agent can guess but cannot call this confidently from the description alone.

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

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

One required parameter with 0% schema coverage, so the description must compensate and does not – it never explains that upload_id is the identifier returned by audience.upload.start or what format it takes. Only the parameter name itself conveys 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?

States a specific resource (upload job) and function (status) that an agent can distinguish from close siblings audience.upload.start and audience.upload.errors. The 'Audience:' prefix is namespace noise, but the core purpose is unambiguous.

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

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

No guidance on when to call this versus polling elsewhere or versus audience.upload.errors, and no indication that upload_id comes from audience.upload.start. Only the '(pro-only)' tag hints at a precondition.

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 it does disclose that this tool validates access, implying a safe read operation with no side effects. It stops short of describing the return payload, permissions required, or any rate limits, so behavioral coverage is only partial.

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 phrase that is front-loaded with the resource and its purpose, with no wasted text. It is arguably terse to the point of under-specification, which caps it just below the top score.

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

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

For a zero-parameter, likely read-only tool this is close to adequate, but with no output schema the description should say what 'user info' actually contains so an agent knows what the validation returns. That gap keeps it at minimum-viable.

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 zero parameters, so the baseline of 4 applies. There is nothing for the description to clarify beyond what the empty schema already communicates.

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 specific resource (audience user info) and hints at a purpose (validate access), but uses no verb and does not say exactly what is retrieved, making it vague. It also fails to distinguish itself from the analogous sibling wordstat.user_info.

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

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

The parenthetical '(validate access)' implies the tool is used to check credentials or permissions, which is a real usage signal. However, there is no explicit when/when-not guidance and no comparison to the many 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?

Annotations only declare readOnlyHint=false and idempotentHint=true; the description adds nothing about the main behavioral traits an agent needs: that it writes files to disk when output_dir is set, that it makes outbound Direct/Metrica/Wordstat calls, or the cost/quota implications of the many optional Wordstat blocks.

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, appropriately front-loaded with the action and artifact. It is efficient but arguably too terse given 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?

For a 23-parameter tool that produces files and aggregates two data sources plus optional Wordstat/Audience blocks, one sentence is insufficient. An output schema exists so return values need not be explained, but the description should at minimum distinguish this from the pro dashboard sibling and note the file-writing 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 description coverage is 100%, so all 23 parameters (including defaults for output_dir, return_data, include_html, wordstat_* limits) are already documented in the schema. The description contributes no additional parameter semantics beyond naming the data sources, 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?

States a specific verb ('Generate'), the artifact ('simple HTML+JSON dashboard') and the data sources ('Direct+Metrica data'), so the agent knows what it produces. However, '(Option 1)' merely restates the tool name and gives no clue how this differs from the sibling dashboard.generate_pro_html.

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 at all. The parenthetical '(Option 1)' implies an alternative exists, but the description never names dashboard.generate_pro_html or states the condition under which the simple variant is preferred over the pro one.

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

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

No annotations are provided, so the description carries the full burden. It implies a read/generate operation and mentions 'Pro-only', but says nothing about side effects (file writes when output_dir is set), auth/plan requirements behind the Pro gate, or default output location — all of which matter for a 27-parameter generator.

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 dense sentence with the gating constraint ('Pro-only') front-loaded and the content list after it. No filler, though it packs a lot into one line without structure for a 27-param 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 complex 27-parameter generator with no annotations and no output schema, a one-sentence description is thin: it leaves file-writing behavior, response shape (HTML vs JSON vs both), and the distinction from dashboard.generate_option1 unexplained.

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

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

Schema description coverage is 100%, so the schema already documents all 27 parameters (defaults, formats, dependencies). The description adds only the content categories, not syntax or default behavior, so baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb (generate) and a well-scoped resource (enriched HTML+JSON dashboard) and enumerates its contents: search terms, keyword diagnostics, campaign watchlist, bids, tracking gaps. The 'Pro-only' qualifier hints at a tier difference, but it never names or contrasts with the sibling dashboard.generate_option1, so the agent must infer which dashboard 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 explicit when-to-use guidance and no exclusion rules. The presence of dashboard.generate_option1 as a sibling makes the missing routing guidance costly — nothing tells the agent when the Pro variant is the right choice over the base variant.

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 behavioral burden, and it discloses almost nothing: it does not state that this is a write/mutation operation with side effects, whether calls are batch/bulk, what happens on partial failure, or what permissions or account context are required. For a creation tool with nested payloads this is a substantial 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 single sentence is front-loaded, free of filler, and communicates the core action immediately. It is efficient but so short that it does no additional work.

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

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

Given a mutation tool with an array of nested objects, 4 parameters, no annotations, and no output schema, the description should explain item structure expectations, batching behavior, and error/response handling. None of that is present, leaving it under-specified for the tool's 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 every parameter (items, params, account_id, direct_client_login) is already documented in the schema. The description adds no syntax, item-shape, or defaulting information beyond that baseline, so a 3 is appropriate.

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

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

The description states a specific verb and resource ('Create ad groups') in a named system (Yandex Direct), so the operation is unambiguous. However, it offers no differentiation from close siblings such as direct.hf.create_adgroup_simple or the bulk/vs-single distinctions an agent must choose between.

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 direct.hf.create_adgroup_simple, nor any note about prerequisites (campaign must exist), batching expectations, or how it relates to direct.update_adgroups. The agent is left to infer usage entirely from 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, yet it only restates the name. It does not describe permissions, side effects, rate limits, authentication, or any mutation-specific behavior.

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

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

The description is a single short sentence with zero wasted words. It is front-loaded with the core action and resource, though its extreme brevity is a separate issue for other dimensions.

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 four parameters (including nested objects), no annotations, and no output schema, the description is completely inadequate. It provides no behavioral, usage, or parameter context needed 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?

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds no meaning beyond what the schema provides, making the baseline score of 3 appropriate.

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

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

The description states a specific verb ('Create') and resource ('ads') in the context of Yandex Direct, making the core action clear. However, it does not differentiate from siblings such as direct.hf.create_text_ads_bulk or direct.create_adgroups, which also create ads or related entities.

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

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

No guidance is provided on when to use this tool versus alternatives. Numerous sibling tools exist for creating ads (e.g., direct.hf.create_text_ads_bulk) or ad groups, but the description offers no context, prerequisites, or exclusions.

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

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

With no annotations, the description carries the full behavioral burden and discloses very little. It does not say the call is a mutation with side effects, whether creation is atomic or batch-fail-partial, what permissions/Client-Login are needed, or how errors surface for a multi-item array.

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 with zero filler. It is efficient, though the brevity borders on under-specification rather than serving 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?

For a mutation tool with no annotations, no output schema, and a nested object array of campaign payloads, the definition is far too thin. An agent lacks anything about batch semantics, failure behavior, or credential prerequisites needed to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents items, params, account_id, and direct_client_login. The description adds no syntax, format, or constraint detail beyond the schema, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb (create) and resource (campaigns) scoped to Yandex Direct, so the agent knows exactly what operation it performs. It does not differentiate itself from siblings like direct.update_campaigns or direct.create_adgroups, relying on the name to do that work.

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 (credentials, account context), and no routing to alternatives such as direct.hf.clone_campaign or direct.hf.create_adgroup_simple despite a dense sibling set. The agent must infer the entire selection context.

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

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

With no annotations, the description carries the full behavioral burden, and it discloses almost nothing beyond the implied mutation. It does not say what happens on duplicate keywords, whether this needs Client-Login/account scoping, what errors or partial failures look like, or whether the call is idempotent.

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, front-loaded sentence with no filler, which is structurally clean. However, the extreme brevity is under-specification rather than effective conciseness for a mutation tool with a nested object parameter.

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 write tool with no annotations, no output schema, and a nested 'items' array whose inner object shape is left entirely open, the description is far too thin. It leaves insertion context, required parent entities, and success/failure behavior unexplained.

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

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

Schema description coverage is 100%, so every parameter is already documented in the schema (items, params override, account_id, direct_client_login). The description adds no meaning beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Create keywords') scoped to Yandex Direct, so the core operation is unambiguous. It does not differentiate itself from near-identical siblings such as direct.update_keywords, direct.list_keywords, or direct.hf.find_keywords, so an agent must infer the distinction from the names alone.

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 prerequisite (e.g. an existing ad group or campaign must exist first), and no mention of alternative keywords like update_keywords or the bulk/hf equivalents. The agent is left to guess the correct entry point.

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 behavioral burden and falls short. It does not disclose whether this is a read-only polling operation, whether changes are paginated, what the window limit is, or what the response contains, all of which matter for a change-feed 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?

A single short sentence that is front-loaded with the verb and resource, with no wasted words. It is efficient, though the extreme brevity is a symptom of under-specification rather than disciplined concision.

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 five-parameter tool with a nested override object, no annotations, and no output schema, the description is too thin. It does not explain the return shape or the change semantics an agent needs to chain calls 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 each of the five parameters is already documented, including the advanced 'params' override and the Direct Client-Login override. The description only paraphrases the timestamp parameter and adds no meaning beyond the schema, making the baseline 3 appropriate.

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

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

The description states a verb ('Get') and a resource ('changes') with a temporal scope ('since a given timestamp'), so the basic purpose is inferable. But it never says what entity the changes belong to (campaigns, ads, bids?) and offers no differentiation from siblings like direct.hf.plan_changes or direct.list_campaigns, leaving the intent vague.

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 prerequisites, and no mention of alternatives such as plan_changes or list_campaigns. The agent is left to guess the scenario in which polling for changes is appropriate versus a full listing.

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, so the description carries the full behavioral burden. It discloses the pro-only gate and the apply=true requirement, which is useful. But for a mutation tool that commits planned changes it says nothing about reversibility, side effects, permissions, or what actually changes, and 'Human-friendly' adds no behavioral information.

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 sentence with the operation front-loaded after a short label. It is efficient and wastes no words, though the leading 'Human-friendly:' is mild filler rather than substantive 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?

For a no-annotation mutation tool with no output schema and 60% param coverage, the description is too thin. It should state the prerequisite (must plan first), the effect of committing a plan, and whether it is reversible. What exists is accurate but incomplete for the tool's complexity.

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

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

Schema coverage is 60% - plan_id, account_id, and direct_client_login are documented in the schema, while apply and dry_run are not. The description adds meaning by tying apply to 'apply=true,' partially compensating for the undocumented apply param, but dry_run is left unexplained. 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?

States a clear verb+resource: 'apply a previously planned Direct change plan.' It distinguishes itself as the apply step of the planning workflow (vs. direct.hf.plan_changes) and names the operation precisely. It lacks explicit contrast with the other 'apply'-style siblings like audience.hf.apply_activation_plan or bid_sweep_run, but the purpose is unambiguous.

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

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

The phrase 'previously planned' implies you must call direct.hf.plan_changes first, and it flags a pro-only constraint. However it gives no explicit when-to-use vs when-not, no prerequisite statement, and doesn't distinguish the direct.bid_sweep_run path or audience apply tools. Usage is left to inference.

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

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

With no annotations, the description carries the full behavioral burden and largely ignores it. It never mentions that the schema exposes apply, dry_run, and overwrite flags, so an agent cannot tell whether a call mutates live ads, previews, or whether the run defaults to dry-run.

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, front-loaded with the verb and resource, which is structurally efficient but under-specified rather than concise. The trailing '(utm_mode=auto)' fragment refers to a non-existent parameter and clutters rather than clarifies.

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 8-parameter mutation tool with no annotations and no output schema, the description omits the safety-relevant semantics of apply, dry_run, and overwrite, and never states what is modified or returned. Too thin for the complexity it wraps.

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 only 25% (two of eight params documented), so the description should compensate but does not. Worse, it introduces 'utm_mode=auto', which is not an input parameter at all, adding confusion rather than semantics for utm_template, campaign_id, apply, dry_run, or overwrite.

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: apply a UTM template to ads within a campaign. An agent can tell what it does, but it does not distinguish itself from siblings like direct.hf.set_campaign_utm_template or direct.hf.set_adgroup_tracking_params that operate on adjacent objects.

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, when-not-to-use, or prerequisite guidance. 'Human-friendly' hints it is a wrapper over a raw Direct operation but gives no condition under which an agent should prefer it over set_campaign_utm_template or set_campaign_tracking_params.

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

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

No annotations are provided, so the description bears the full disclosure burden for a mutation tool, and it says nothing about reversibility, whether archiving stops delivery immediately, permission requirements, or rate limits. The presence of apply and dry_run parameters makes the omission of whether a call is a preview or a real write especially damaging.

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 the action front-loaded, so it is not bloated. However, the 'Human-friendly:' prefix is dead weight and the overall brevity reflects under-specification rather than efficient communication.

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 7-parameter destructive-state mutation with no annotations, no output schema, and sparse schema coverage, this description leaves critical details (dry-run behavior, required identifiers, scope of the archive) entirely unaddressed. It is substantially inadequate for the tool's 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 only 29, so most of the 7 parameters (apply, dry_run, ad_ids, campaign_id, campaign_name) are undocumented in both schema and description. The description adds zero parameter meaning and does not compensate for the coverage gap.

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 ('archive ads'), which is distinguishable from sibling operations like pause_ads, resume_ads, and unarchive_ads. It does not explicitly name those siblings, keeping it a step below the top score, and the 'Human-friendly:' prefix carries no meaning.

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 indication of when to choose archive_ads over pause_ads, resume_ads, or unarchive_ads, nor any prerequisites such as required permissions or the relationship between the apply and dry_run flags. The agent is left to infer everything about invocation context.

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

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

With no annotations, the description carries the full burden for a mutation tool. It never states whether archiving is reversible, what permissions are needed, or what effect it has on campaign data. Critically, it is silent on the apply/dry_run parameters, which are the primary safety mechanism 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?

One short front-loaded line with no wasted words. It is efficient, though arguably under-specified rather than genuinely concise given 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?

A 6-parameter mutation tool with no annotations and no output schema needs more than a single line. The absence of any explanation of dry_run/apply semantics or reversibility leaves an agent unable to invoke this safely.

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 only 33% (6 parameters, 2 documented). The description usefully clarifies that campaigns can be targeted by id or name, mapping to campaign_ids/campaign_name, but apply, dry_run, and the relationship between them are undocumented in both schema and 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 (archive) and resource (campaigns), and notes the id-or-name selector. It is distinguishable from sibling archive_ads and unarchive_campaigns, though the 'Human-friendly' prefix is filler that adds nothing.

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 guidance. It does not mention how this relates to the sibling unarchive_campaigns or whether archiving is reversible, and nothing tells the agent when a dry run is appropriate.

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

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

No annotations are provided, so the description carries the full behavioral burden and mostly doesn't. It never explains the meaning of the apply and dry_run flags, whether changes are reversible, what happens to callouts already attached, or what auth the account_id/direct_client_login imply. 'Human-friendly' is the only behavioral hint and it is unexplained.

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?

It is a single short sentence with no filler, which is efficient, but for a six-parameter mutation tool with dry-run semantics it is under-specified rather than genuinely concise. Front-loading is fine; substance is missing.

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 six parameters, no annotations, no output schema, and undocumented apply/dry_run behavior, the description does not give an agent enough to invoke this mutation safely or predictably. It should at minimum explain the dry-run/apply contract and the required callout set 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 only 33% (just account_id and direct_client_login are documented). The description ties 'callout (adextension) ids' to callout_ids and 'ads' to ad_ids, but leaves the safety-critical apply and dry_run flags completely unexplained in both schema and description, which is a substantial gap.

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

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

The description gives a specific verb ('attach') and resource ('callouts (adextension ids) to ads'), so an agent knows exactly what operation it performs. It does not, however, name or contrast itself with the close siblings direct.hf.attach_sitelinks_to_ads and direct.hf.attach_vcard_to_ads, so the sibling differentiation is left to 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?

There is no guidance on when to use this versus create_callouts or the other attach_* tools, no statement of prerequisites (e.g. that callout sets must already exist), and no mention of how apply/dry_run interact. The name loosely implies the use case, but nothing is stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a mutation ('attach') but does not state permissions required, whether attaching is idempotent, what happens if the sitelink set is already attached, or how dry_run/apply behave. This is far too thin for a write operation with six parameters.

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

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

The description is a single short sentence and front-loaded, which is structurally good. However, the 'Human-friendly:' prefix is filler that does not earn its place, and the sentence is so sparse that it fails to inform rather than being truly concise.

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

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

For a six-parameter mutation tool with no annotations and no output schema, the description omits critical context: parameter roles, behavioral effects, safety profile, and usage conditions. It is not complete enough for an agent to invoke the tool correctly without additional inference.

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 33%, so the description must compensate for undocumented parameters, but it adds no parameter-level meaning at all. It does not explain apply, ad_ids, dry_run, or sitelink_set_id, leaving four of six parameters semantically opaque.

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 ('attach') and resource ('an existing sitelinks set to ads'), making the core action clear. It does not explicitly differentiate itself from siblings like attach_callouts_to_ads or attach_vcard_to_ads, though the resource name implicitly distinguishes it. The 'Human-friendly:' prefix adds no clarifying value.

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

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

There is no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. An agent must infer usage from the tool name alone. 'Human-friendly' is too vague to count as context.

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

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

No annotations are provided, so the description carries the full burden. It is a mutation tool, yet nothing is disclosed about required permissions/ownership of the vcard, idempotency, what happens to already-attached vcards, or what occurs when the '(if supported)' condition fails.

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, so it is not bloated, but the 'Human-friendly:' filler and the hedging '(if supported)' consume the little space available without adding information the agent can act on.

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?

A write-style tool with no annotations, no output schema, 0 required parameters, and only a third of its parameters documented. The description does not compensate for these gaps and leaves the agent unable to reason about safety or the dry_run/apply workflow.

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

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

Schema description coverage is only 33% (account_id and direct_client_login). The description names vcard_id and ads implicitly but says nothing about the apply and dry_run flags or the ad_ids array, leaving the two parameters that control whether the write actually happens completely unexplained.

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 (attach) and resource (vcard id) and target (ads), which cleanly distinguishes it from the sibling attach_sitelinks_to_ads and attach_callouts_to_ads. The odd 'Human-friendly:' prefix adds no meaning, but the core operation is unambiguous.

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

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

The only conditional cue is the parenthetical '(if supported)', which hints at a capability gate but never tells the agent when to choose this tool over attach_sitelinks_to_ads/attach_callouts_to_ads. No prerequisites, no mention of which ads qualify, no exclusion guidance.

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

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

With no annotations, the description carries the full burden. It does disclose the key trait — read-only — and the underlying data source, which is useful. However, it says nothing about output format, cost/rate limits, or how the report is scoped, which are relevant for an analysis step.

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?

Single compact sentence with the verb and data source front-loaded. The 'Human-friendly:' prefix adds little and slightly dilutes the lead, but overall it is efficient.

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

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

For a 6-parameter tool with two complex required params, no annotations, and no output schema, the description is thin. It is not required to explain return values, but it omits any guidance on the plan_id/windows inputs or the analysis workflow, leaving the definition only minimally viable.

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%, so baseline is 3. The four documented params (max_rows, account_id, direct_client_login, include_per_keyword) are explained in the schema, and the description adds nothing for the undocumented plan_id and windows array, leaving their structure and intent to inference.

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 (analyze), a specific resource (bid sweep plan), and the data source (Direct keyword performance report). This distinguishes it from siblings like bid_sweep_plan and bid_sweep_run, though it never explicitly names what it does relative to them.

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

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

No when-to-use guidance and no routing to alternatives. With close siblings bid_sweep_plan and bid_sweep_run in the same namespace, the description gives no signal about which stage of the sweep workflow this tool serves.

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 provided, so the description carries the full burden. It discloses pro-only and sandbox-only execution, which is useful. However, it doesn't state what the plan contains, whether it mutates state, whether it requires specific permissions beyond pro, or what the output looks like. For a tool involved in experiment planning (potentially sensitive), this is insufficient.

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?

Single, front-loaded sentence with zero waste. Every word earns its place.

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

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

The description is minimal for a tool with 12 parameters, no annotations, no output schema, and incomplete parameter documentation. It leaves the agent with significant gaps about usage context, parameter semantics, and return expectations. Not adequate 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?

Schema description coverage is 50% (12 params, only 5 have descriptions). The description adds no parameter information. With low coverage, the description should compensate by explaining key parameters like bid_steps_rub, account_id, campaign_id, etc. It does not, leaving half the parameters 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?

States the action (build a bid sweep experiment plan) and scope (pro-only, sandbox execution), which is more specific than the name alone. However, it's terse and doesn't distinguish from siblings bid_sweep_run or bid_sweep_analyze. An agent can infer the difference (plan = generate, run = execute), but the description doesn't explicitly differentiate.

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

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

No explicit when-to-use guidance, no mention of prerequisites, no alternatives. The description notes it's pro-only and sandbox-only execution, which hints at context, but doesn't say when to choose this over bid_sweep_run or whether it's a prerequisite. No exclusions or alternatives named.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the tool is pro-only and sandbox-only and requires apply=true, which covers authorization and safety scope. However, it doesn't explain what gets modified, whether changes are reversible, or rate/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?

The description is a single, front-loaded sentence with dense constraint information. The only questionable element is the 'Human-friendly:' prefix, which is vague and slightly reduces efficiency.

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 annotations, no output schema, and 6 parameters, the description is quite terse. It does disclose critical safety constraints (sandbox-only, pro-only), but it omits side effects, prerequisites beyond the schema's plan_id link, and 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?

Schema description coverage is 67%, so the schema documents most parameters. The description adds meaning for the apply parameter by requiring 'apply=true', but it does not mention dry_run, and provides no additional semantics beyond 'one step' for step_index.

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 ('apply') and resource ('one bid sweep step'), so the core action is clear. However, it does not explicitly differentiate itself from siblings like direct.hf.bid_sweep_plan or direct.hf.apply_plan, and the 'Human-friendly' prefix is vague.

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 gives explicit conditions for use: 'pro-only, apply=true, sandbox-only'. This tells the agent when the tool is applicable and when it is not, but it does not name alternatives or explicitly say to use it after bid_sweep_plan.

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 behavioral burden. It states deletion but does not disclose destructive permanence, required permissions, dry_run/apply semantics, or reversibility.

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

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

The description is a single front-loaded sentence with little fluff, but 'Human-friendly:' is vague and the extreme brevity leaves key behavior unspecified for a six-parameter destructive operation.

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

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

Given no annotations, no output schema, six parameters, and 33% schema coverage, the description is incomplete for a destructive mutation tool. It omits critical guardrail details such as dry_run/apply behavior, authentication needs, and expected 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 only 33%, with account_id and direct_client_login documented. The description maps 'campaign/type' but leaves apply, dry_run, and campaign_id semantics unstated, insufficient compensation for the low 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?

States a specific verb (delete) and resource (bid modifiers) with scoping by campaign/type. It clearly distinguishes itself from sibling set/list bid-modifier tools, though it does not name an alternative sibling.

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 no when-to-use guidance, prerequisites, or alternatives. The phrase 'by campaign/type' hints at scope but gives no conditions for choosing this tool over set_bid_modifier_* or list_bidmodifiers.

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 disclosure burden. It does add two useful traits - the result is a 'draft' (not a live campaign) and the operation is '(best effort)' (partial results possible) - but it never explains the apply/dry_run preview-versus-commit semantics, what happens to assets/keywords that fail, or whether an existing campaign is modified.

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 that front-loads the action and outcome, with no wasted clauses. The 'Human-friendly:' prefix is mildly decorative but does signal this is a high-level wrapper over direct.raw_call, which is real 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 7-parameter mutation tool with no annotations and no output schema, this is under-specified: the draft-state and best-effort caveats are the only behavior communicated, and the clone scope (what exactly gets copied - adgroups, ads, keywords, bids?) is left undefined.

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?

Seven parameters with only 29% schema description coverage, and the description contributes zero parameter-level information. The undocumented apply, dry_run, new_name, campaign_id and campaign_name fields - the ones an agent most needs to understand for a clone operation - are explained nowhere in either the description or 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 gives a specific verb (clone) and resource (campaign structure) and states the output is a new draft campaign, which distinguishes it from direct.create_campaigns and the many other direct.* mutation tools by name and intent. It stops short of explicitly contrasting itself with those siblings, so it is clear but not fully differentiated.

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

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

There is no guidance about when to clone versus building a campaign from scratch, nor any mention of prerequisites or the apply/dry_run workflow that the schema exposes. The only hint is the parenthetical '(best effort)', which tells the agent nothing about when to choose this tool.

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

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

No annotations are provided, so the description carries the full behavioral burden for what is clearly a write operation. It only implies "create"; it says nothing about the dry_run/apply flags, reversibility, required auth (Direct Client-Login), or what occurs on partial input, leaving the mutation's side effects undisclosed.

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?

It is a single front-loaded sentence with no filler, and "Human-friendly" is the only differentiation cue so it earns its place. The trade-off is that conciseness here shades into under-specification rather than tight completeness.

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 8-parameter write tool with no annotations and no output schema, the description is far too thin. It conveys basic purpose but omits required inputs, the safe dry_run/apply pattern, and any return or failure behavior an agent would need 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 25% across 8 parameters (name, apply, dry_run, region_ids, campaign_id, campaign_name are undocumented), and the description adds no field-level meaning. The phrase "under a campaign" faintly implies campaign_id/campaign_name linkage despite both being marked optional, but this is too implicit to compensate for the coverage gap.

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

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

The description gives a clear verb and resource ("create ... ad group") plus scope ("under a campaign"). However, "simple" and "Human-friendly" are vague qualifiers and do not explicitly distinguish this tool from the raw sibling direct.create_adgroups or from direct.hf.find_adgroups, so the agent must infer the difference from the tool name rather than the description.

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 statement of when to prefer this over direct.create_adgroups, and no named alternatives or preconditions. The description never mentions the apply/dry_run workflow or what happens without a campaign identifier, leaving selection and sequencing 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?

No annotations are provided, so the description carries the full burden, yet it discloses nothing about the mutation being performed. It never states whether this hits the live account, what apply/dry_run actually control, or whether permissions are required — a significant gap for a write 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?

It is a single short sentence with no waste, which is good structure, but it is under-specified rather than genuinely concise — the brevity comes at the cost of substance.

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 annotations, no output schema, and partial parameter documentation, the description does far too little. It omits the apply/dry_run execution model, the meaning of texts, and any return/confirmation 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?

Five parameters with only 40% schema coverage, and the description covers none of them. The two undocumented execution-control params (apply, dry_run) and texts carry no explanation anywhere, so the description fails to compensate for the coverage gap.

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

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

The description gives a specific verb+resource (create callouts) and names the underlying entity (AdExtensions CALLOUT), which distinguishes it from attach_callouts_to_ads. However, 'Human-friendly' is filler and it does not clarify the relationship to create_sitelinks_set or attach_callouts_to_ads beyond the raw API type.

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 at all: nothing explains when to create a callout set versus attaching existing callouts to ads, nor what apply/dry_run imply for execution. The agent is left to infer the workflow from the parameter names alone.

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

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

No annotations provided, so the description carries full behavioral burden — and it says almost nothing. It doesn't disclose that apply/dry_run control whether changes are actually committed, doesn't state permission requirements, doesn't say whether an existing set is overwritten or a new one is created, and doesn't explain the return. For a mutation tool with zero annotation coverage, this is a major 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 one sentence is short and front-loads the verb, which is good. But 'Human-friendly:' is a wasted qualifier that occupies half the text without informing the agent; trimming it would leave a cleaner imperative.

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?

A 5-parameter mutation tool with no annotations, no output schema, and only 40% schema coverage. The description should explain the apply/dry_run workflow and what sitelinks shape it expects, but instead provides a single sentence. This is inadequate for safe invocation.

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

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

Schema coverage is 40%, leaving apply, dry_run, and sitelinks undocumented in both schema and description. The description lists no parameters at all, so it fails to compensate for the three bare booleans/arrays — notably the apply/dry_run pair, whose semantics are essential for correct 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?

States a specific verb (create) and resource (sitelinks set), so the action is identifiable. But 'Human-friendly:' is filler that adds nothing, and the description doesn't differentiate from siblings like direct.list_sitelinks, direct.hf.attach_sitelinks_to_ads, or direct.hf.create_callouts — all of which touch the same asset ecosystem.

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 direct.list_sitelinks, attach_sitelinks_to_ads, or raw_call. No preconditions stated. The presence of apply/dry_run booleans in the schema suggests a plan-then-apply workflow, but the description never mentions it.

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

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

No annotations are provided, so the description carries the full disclosure burden and falls short. It does not explain that this is a mutation, what apply/dry_run actually control (preview vs commit), whether it requires Direct Client-Login permissions, or what happens on partial failure across a batch. The presence of apply and dry_run flags in the schema suggests meaningful behavior the description never addresses.

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?

It is a single front-loaded sentence with no wasted words, which is good. However, at this level of brevity it becomes under-specification rather than conciseness for a six-parameter batch mutation, so it cannot score higher.

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 six-parameter bulk-write tool with no annotations, no output schema, and 33% schema coverage, the description is far too thin. It does not tell the agent how to build the ads payload, how dry_run/apply interact, or what a successful batch response looks like.

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%, and the description compensates for none of it. It hints at an ad group and multiple ads, loosely mapping to adgroup_id and the ads array, but says nothing about the shape of the ads objects, apply/dry_run semantics, or account_id vs direct_client_login. The undocumented parameters remain fully opaque.

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 concrete verb and resource: create multiple TextAds, scoped to an ad group. That distinguishes it from sibling create_ads and update_ads_text_bulk by the bulk-create intent, though it never names those siblings explicitly. The 'Human-friendly' prefix is filler that adds no distinguishing information.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the alternatives (direct.create_ads, direct.hf.update_ads_text_bulk). 'Human-friendly' vaguely implies a higher-level wrapper over a raw API call, but the agent gets no condition for choosing this tool.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation ('ensure', 'attach') but does not disclose permissions, idempotency, overwrite semantics, dry-run/apply behavior, or whether missing assets are created. This leaves critical safety and side-effect context undocumented.

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

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

The description is a single front-loaded sentence with little waste, though the 'Human-friendly:' prefix adds no operational value. For a 9-parameter mutation tool, it is concise to the point of under-specification.

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 9 parameters, no required fields, no annotations, no output schema, and only 22% schema description coverage, the description is not complete enough for reliable invocation. It omits the meaning of key flags and does not explain how the composite ensure/attach behavior interacts with existing assets.

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 22%, so the description must compensate, but it adds almost no parameter meaning. It names sitelinks, callouts, and campaign, yet critical controls like apply, dry_run, overwrite, campaign_id vs campaign_name, and account_id are not explained beyond what little 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 states a specific composite action: ensure sitelinks and callouts exist and attach them to ads in a campaign. It is clear enough to distinguish from single-purpose siblings like attach_sitelinks_to_ads or attach_callouts_to_ads, though it does not explicitly route the agent among them.

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

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

There is no explicit guidance on when to use this composite tool versus the separate attach/create siblings. The implied use case is 'when you want both sitelinks and callouts ensured and attached', but the description does not state prerequisites, 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 readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds essentially nothing behavioral beyond that, saying only 'Human-friendly' with no mention of pagination, limit behavior, or how the campaign/name filters combine.

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, front-loaded sentence with no filler or restated name. It is efficient, though arguably too terse given the six parameters and the crowded sibling set.

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

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

An output schema exists, so return values need not be explained. For a read-only find tool the description is minimally complete, but it omits routing guidance against the raw list tools and leaves four of six parameters unexplained.

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 schema description coverage at 33%, the description must compensate, and it partially does by naming the campaign and name filters, which maps to campaign_id/campaign_name and name_contains. It leaves limit and the id-vs-name distinction undocumented in both places, so the help is partial.

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 (find) and resource (ad groups) plus the filter dimensions (campaign and name), so the agent knows what it returns. It does not explicitly distinguish itself from the sibling direct.list_adgroups or direct.report_adgroups; the 'Human-friendly' prefix only hints at the 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?

No when-to-use, when-not, or alternative-routing guidance is given. The description implies it is the friendly lookup variant, but with direct.list_adgroups and direct.hf.find_campaigns/find_ads/find_keywords in the sibling set, the agent gets no explicit rule for choosing among them.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds only the 'human-friendly' framing and filter capability, with no mention of pagination, limit defaults, or result-count behavior. Adequate but not rich given the lower bar set by annotations.

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

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

A single front-loaded sentence with no wasted words. It is efficient, though the brevity contributes to the parameter gaps.

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

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

An output schema exists so return values need no explanation, and annotations cover the safety profile. However, for a 10-parameter tool with 20% schema coverage, the description omits too many filter and override parameters to be fully actionable.

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?

Only 20% of the 10 parameters carry schema descriptions, so the description must compensate, yet it only gestures at campaign/adgroup and title/href filters. It never clarifies limit, statuses, name-vs-id precedence, or the direct_client_login override, leaving most parameters undocumented in either place.

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 ('find ads') with the filter dimensions it operates on (campaign/adgroup, title/href). It is distinguishable in spirit from siblings like find_campaigns and find_adgroups, though it never names them explicitly to route the agent.