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

No annotations are provided, so the description carries the full burden. 'Return the ... configuration' signals a read-only reference tool, which is useful, but the description never confirms the call has no side effects and never clarifies that the described publishing steps happen in other tools, not here. That ambiguity is the main risk for a zero-annotation tool.

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

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

A single sentence with the deliverable front-loaded (the AIKI configuration), followed by the workflow outline. It is dense but every clause carries information; the only weakness is that the workflow clause runs long and reads as instruction rather than 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?

With no output schema and no annotations, the description should say more about what the returned configuration/workflow looks like or what the agent should do with it. It names 'dStore' and 'community topic' without mapping them to concrete sibling tools (e.g. the ads_dstore_* or ads_network_* families), leaving the handoff underspecified.

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 there is nothing for the description to disambiguate. Baseline 4 applies; no parameter guidance is needed or missing.

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+object: it returns the AIKI MCP configuration plus the AdsMCP workflow. However, the second half shifts from describing what the tool returns to prescribing a multi-step publishing workflow, which blurs whether the tool performs those steps or merely documents them. It also does not differentiate itself from near-neighbours such as ads_aiki_status or ads_platform_guide.

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 embedded workflow (search topic, check duplicates and rules, then hand off to dStore) implies this is the entry-point/setup reference an agent should consult before publishing. But there is no explicit 'use this when' clause, no exclusions, and no naming of alternative tools for the same need.

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, yet it never says whether this is a read-only informational call, what data it returns, or whether any auth/setup is required. It offers only domain background about AIKI proposals, not tool 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?

Two short sentences with no filler, and the core statement is front-loaded. The brevity comes at the cost of under-specification rather than padding, which is the lesser 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?

With no output schema and no annotations, the description should at least sketch what the response contains (status fields, proposal list, etc.), but it does not. An agent cannot tell what calling this tool will produce.

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 and the schema is empty, so there is nothing for the description to disambiguate. Baseline 4 applies for a no-parameter tool.

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

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

The description says to 'Show the AIKI community source' but never states what the tool actually returns or what 'AIKI status' means operationally. The second sentence explains domain context (proposals are unverified leads) rather than the tool's purpose, and nothing distinguishes it from the sibling ads_aiki_setup_guide.

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, no prerequisites, and no mention of alternatives such as ads_aiki_setup_guide or the dStore status tools. The verification workflow hint ('dStore must verify them before adding a platform') implies context but does not tell the agent when to invoke this tool versus others.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about read-only status, computation cost, permissions, or output format. 'Attribute' hints at an analysis read, but an agent cannot confirm it is a safe non-mutating call from the text alone.

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 core action leads. It is efficient, though the brevity arguably comes at the cost of the missing details noted elsewhere rather than being genuinely tight.

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 no annotations, no output schema, and zero schema description coverage, one sentence is far too thin. An agent lacks enough to call it correctly beyond supplying a model enum value.

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 0% schema description coverage across 6 parameters, the description must compensate but only lightly touches the model parameter and vaguely gestures at from/to via 'conversion events' and 'touchpoints'. It says nothing about date format for from/to, the 0-90 range of lookback_days, or what project_id/campaign_id scope.

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 (attribute) and resources (local conversion events, tracked touchpoints) plus the mechanism (selected attribution model). It reads as an analytics/report operation and is distinguishable from ads_event_ingest, though it does not explicitly contrast with the similar ads_network_conversion_report 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 alternatives such as ads_network_conversion_report or ads_campaign_analytics. The only implicit cue is that a model must be selected, which the schema already enforces as required.

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 supplied, so the description carries the full burden for a mutation tool. It does not say whether the rule fires immediately on creation, whether pause_campaign will actually halt live campaigns (a destructive side effect), what enabled defaults to, 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?

Two short, front-loaded sentences with no filler. The brevity is appropriate in form, though it comes at the cost of substance rather than padding.

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 mutation tool with 5 required fields, no annotations, and no output schema, the description omits the rule's evaluation model, firing behavior, and the effect of the two actions. An agent could not reliably construct a correct rule from this text 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?

Schema description coverage is 0% across 9 parameters. The description only echoes the action enum (pause_campaign/notify), which is already in the schema, and says nothing about metric, operator, threshold, campaign_id, cooldown_minutes, or enabled. With this many undocumented parameters the description fails to compensate.

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

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

The description states a specific verb and resource ("Create a KPI rule") and briefly names the supported action values. "Create" distinguishes it from ads_automation_rule_list and ads_automation_run, though the term "KPI rule" itself is never defined.

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

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

There is no guidance on when to create a rule versus listing or running one, no prerequisites (e.g. a valid campaign_id), and no mention of the cooldown semantics. The agent must infer all usage conditions.

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 full behavioral burden. Beyond implying a read via "List," it says nothing about pagination, ordering, return shape, or permission needs, leaving significant gaps for a list 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 efficient, front-loaded sentence with zero filler. It is appropriately short, though brevity here borders on under-specification addressed in 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?

With no annotations, no output schema, and 0% parameter coverage, the definition is too thin to call this tool confidently. Critical details like the enabled_only filter and return format are absent.

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

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

Schema coverage is 0% for two parameters. The description only alludes to campaign_id ("optionally for one campaign") and entirely omits enabled_only, so it does not compensate for the undocumented 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 (List) and resource (automation rules) with a scoping hint. It doesn't explicitly distinguish from siblings like ads_automation_rule_create or ads_automation_run, but the read/list nature is clear from the wording.

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?

"Optionally for one campaign" hints at scoping but gives no explicit when-to-use, when-not, or alternative routing. Nothing tells the agent when to pass campaign_id or when to prefer another sibling.

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

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

With no annotations, the description carries full behavioral burden. It usefully discloses the dry-run default and the explicit execute=true gate, which is meaningful safety context. But it does not describe what happens when execution occurs, what rules are affected, or any permission or recovery implications.

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

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

The description is two short sentences with no wasted wording, and the dry-run behavior is front-loaded. It is efficient, though arguably too terse given the tool's four parameters and lack of annotations.

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 four-parameter automation tool with no annotations, no output schema, and 0% schema description coverage, the description is not complete enough. It omits what from/to and campaign_id mean and does not explain the effects of execute=true beyond calling it non-dry-run.

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 compensate for all four parameters. It only clarifies the meaning of execute (dry-run vs execution) and leaves the required from/to parameters and campaign_id 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?

The description states a specific verb ("Evaluate") and resource ("automation rules"), making the core action clear. It does not explicitly distinguish this tool from sibling rule-management tools such as ads_automation_rule_create or ads_automation_rule_list, so it falls short of a 5.

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

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

The description gives important usage context for the execute flag: dry-run unless execute=true is explicitly set. However, it does not state when to use this tool versus alternatives like ads_automation_rule_list or rule_create, nor does it describe 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, whether it requires specific permissions, how calculations are performed, whether results are cached, or what the output 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?

The description is a single, front-loaded sentence with no wasted words. However, for a tool with five undocumented parameters and no annotations, it is arguably too terse rather than optimally concise.

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

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

With no annotations, no output schema, and zero schema description coverage, the description is incomplete. An agent would not know how to properly set the date range, source, or project parameters, nor what to expect from the return value.

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 only vaguely covers campaign scope ('one or all campaigns') and KPI types. It does not explain the critical parameters from, to, source, or project_id, leaving most of the five 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?

The description states a specific verb ('Calculate') and resource ('spend, funnel and efficiency KPIs') with scope ('one or all campaigns'). It is clear what the tool does, but it does not differentiate itself from analytics/report siblings such as ads_project_analytics, ads_campaign_timeseries, or ads_attribution_report.

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

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

The description gives no guidance on when to use this tool versus sibling analytics and reporting tools. It implies that it is for campaign KPI calculation, but there are no explicit use cases, prerequisites, or alternatives mentioned.

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 usefully discloses that the campaign 'starts in draft status', which is real behavioral context, but for a 12-param mutation tool it says nothing about permissions, what happens to nested metadata/tracking/targeting, or side effects.

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

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

Two short sentences, front-loaded with the core action, with zero filler. The terseness is efficient, though arguably too thin for the tool's complexity.

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

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

Given 12 parameters, nested objects, no output schema, and no annotations, the description is far too sparse to guide correct invocation. It omits budget field distinctions, targeting/metadata/tracking structure, and required-field semantics (name, objective).

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 compensates almost not at all. Only project_id is obliquely referenced ('optionally inside a project'); the many fields (daily_budget vs budget_amount, currency, source, starts_at/ends_at, targeting, metadata, tracking, objective enum) are entirely 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 a specific verb (Create) and resource (advertising campaign definition), plus the qualifier 'local' that hints at a distinction from platform-specific siblings. It does not explicitly name or contrast with siblings like ads_yandex_direct_create_campaign or ads_telegram_ads_api_create_ad, so the differentiation is only implicit.

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

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

There is no explicit when-to-use or when-not guidance, and no named alternatives despite many sibling campaign-creation tools existing. 'Local' and 'optionally inside a project' give hints about context but nothing tells an agent when to pick this over ads_telegram_ads_api_create_ad or ads_yandex_direct_create_campaign.

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 only implies a read via the word 'Get'. It says nothing about behavior when the id does not exist, whether an error or empty result is returned, or what the response contains. For a lookup tool this leaves the agent guessing at the failure path.

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

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

A single sentence with no filler, and the resource and keying constraint are front-loaded. Nothing in it is redundant.

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

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

The tool is simple (one required parameter, no nesting, no annotations), so the bar is modest, but with no output schema the description should indicate what a successful lookup yields and what happens on a miss. As written, an agent can call it but cannot predict the result.

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 schema only constrains campaign_id as a non-empty string. The phrase 'local id' usefully signals that this is an internal identifier rather than a platform-side campaign id, which is real added meaning, but format and sourcing of that id remain unspecified.

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 ('Get one campaign') and scopes it to a single record by local id, which implicitly separates it from ads_campaign_list. It stops short of naming the list sibling explicitly, so the differentiation is inferential rather than stated.

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

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

'By its local id' implies the precondition for using this tool (you already have an identifier), but there is no explicit when-to-use guidance and no named alternative such as ads_campaign_list for the case where the id is unknown.

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, yet it only implies a read operation via 'List'. Nothing is said about ordering, pagination behavior, default page size, or whether all campaigns or only the caller's are returned.

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. It is efficient, though brevity here edges into under-specification rather than tightness.

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 four undocumented parameters, the description should carry much more. As written, an agent cannot tell the default page size, the meaning of 'source', or how results are ordered.

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 define all four parameters. It only gestures at two of them (project -> project_id, lifecycle status -> status) and says nothing about 'limit' or 'source', leaving non-obvious fields undocumented in both places.

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 (list local campaigns) and scopes it to 'local', which separates it from the platform-specific campaign tools like ads_yandex_direct_create_campaign or ads_telegram_ads_api_create_ad. It does not explicitly point at the obvious siblings (ads_campaign_get, ads_campaign_create/update), so it stops short of full differentiation.

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

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

The phrase 'optionally filtered by project and lifecycle status' implies the retrieval use case, but there is no statement of when to use this versus ads_campaign_get or ads_campaign_analytics, and no 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?

No annotations are provided, so the description carries the full behavioral burden. It conveys that the operation is a local read and that data is normalized/time-bucketed, but it does not disclose freshness, sync requirements, side effects, limits, or what the local SQLite dependency means operationally.

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

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

The description is a single front-loaded sentence with no filler. It is efficient, but its brevity is also a limitation given the tool's 8-parameter query surface.

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 query tool with no annotations, no output schema, and 0% schema description coverage, one sentence is not enough. It identifies the data source and metric type but omits filtering semantics, defaults, period behavior, and pagination/limit 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 description coverage is 0% across 8 parameters, so the description must compensate but does not. It only hints at period ('time-bucketed'), provider ('provider metrics'), and campaign ('campaign_timeseries'), leaving from, to, limit, source, and project_id 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?

The description states a specific verb and resource: read normalized time-bucketed provider metrics. It also distinguishes the data source as local SQLite, which separates it from live provider report/sync siblings, though it does not explicitly name alternatives.

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

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

The phrase 'saved in local SQLite' implies this tool reads previously stored metrics rather than fetching live provider data. However, it gives no explicit when-to-use guidance, prerequisites such as syncing first, or named alternatives like the provider report tools.

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

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

No annotations are provided, so the description carries the full behavioral burden and mostly fails. It does not state whether this is a partial (PATCH) or full-replace update, whether omitted fields are cleared or preserved, whether status transitions like 'archived' are reversible, or what permissions are required. Only the word 'Update' signals mutation.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though efficiency here comes at the cost of the detail the tool actually needs.

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 14-parameter mutation tool with no annotations, no output schema and zero schema description coverage, one sentence is far too thin. An agent cannot determine update semantics, field-level meaning, or side effects from this definition.

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 14 parameters and 0% schema description coverage, the description must compensate and does not. It gestures at three parameter groups ('metadata', 'lifecycle status', 'project assignment') but never explains formats for dates, currency codes, budget semantics (daily_budget vs budget_amount), the objective/targeting enums, or the meaning of nullable 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?

Specific verb+resource ('Update campaign metadata, lifecycle status or project assignment') that clearly separates it from ads_campaign_create, ads_campaign_get and ads_campaign_list. However, the enumerated scope understates the tool: budget, objective, targeting, currency and schedule fields are not mentioned, so the stated purpose is narrower than reality.

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 ads_campaign_create or the platform-specific writers (ads_yandex_direct_create_campaign, ads_telegram_ads_api_set_ad_paused). No prerequisites, no note on whether the campaign must already exist, and no mention of whether partial updates are allowed.

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 usefully discloses that the change is local-only and never sends or launches the campaign, which is important safety context. However, it does not describe permissions, idempotency, valid transition behavior, failure modes, or what happens after status becomes READY.

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 two short sentences with no wasted wording. The core action is front-loaded, and the safety clarification follows immediately.

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

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

For a two-parameter mutation tool with no annotations and no output schema, the description covers the most important safety property: it does not launch or send anything. It still leaves gaps around draft_id semantics, error/return behavior, and relationship to sibling draft-status tools. It is minimally adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It adds meaning for the status parameter by explaining the DRAFT-to-READY transition context, but it never explains what draft_id represents or how it should be supplied. The result is partial compensation rather than full parameter clarity.

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

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

The description uses a specific verb ('Change') plus resource ('locally stored Click.ru campaign') and names the two allowed states, DRAFT and READY. It also clarifies that this is not a launch action, which distinguishes it from campaign-execution tools. However, it does not explicitly differentiate itself from the similarly named sibling ads_clickru_campaign_drafts_status.

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

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

The description implies usage by saying it changes a locally stored campaign between DRAFT and READY and never sends or launches it. That gives useful context for when this tool applies, but it does not name an alternative tool or state explicit when-not-to-use conditions beyond the non-launching clarification.

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

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

With no annotations, the description must carry behavioral disclosure. It does note the data is 'locally stored' and that nothing is sent or launched, which is genuinely useful side-effect information, but it is silent on auth/setup prerequisites, whether an active campaign may be absent, and 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?

Two compact sentences with the resource and scope front-loaded and the no-side-effect caveat immediately after. No filler.

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

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

For a no-parameter, no-output-schema status tool, the description gives enough: what entity is listed, that statuses and an active campaign are included, and that nothing is launched. Only the absence of edge cases (e.g., no drafts present) keeps it from a 5.

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

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

Zero parameters are defined, so the baseline is 4. There is nothing parameter-related to clarify or omit.

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 ('Show') and resource ('locally stored Click.ru campaign drafts'), plus what is returned: statuses and the active campaign. The sibling ads_clickru_campaign_draft_set_status is implicitly distinguished by the read-only framing, though it is never named.

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 line 'Drafts are not sent or launched' clarifies that this is a passive inspection tool, but it does not say when to reach for it over ads_clickru_campaign_draft_set_status or any other Click.ru tool. Usage is implied rather than prescribed.

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

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

With no annotations, the description carries the burden and usefully discloses that data is locally stored, INNs are masked, the active profile is included, and API tokens are never returned. It does not explicitly state read-only/no side effects, but 'Show' and the token exclusion provide strong behavioral context.

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

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

Two short sentences, front-loaded with the core behavior and followed by the security-relevant constraint. No unnecessary detail.

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

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

For a zero-parameter status tool with no output schema or annotations, the description sufficiently explains the key return content and privacy boundary. It could be slightly richer about response structure, but it is complete enough to invoke correctly.

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

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

The tool has zero parameters, so parameter semantics are inherently minimal and the 100% schema coverage baseline applies. The description does not need to explain parameter formats.

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 ('Show') and resource ('locally stored Click.ru advertiser profiles'), and clarifies the returned fields ('masked INNs and the active profile'). It is clearly distinguishable from sibling Click.ru tools such as campaign draft status tools.

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

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

The phrasing implies this is the status/list-view tool for locally stored Click.ru profiles, but it does not explicitly state when to use it versus alternatives or any prerequisites. No direct sibling alternative is 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 burden and does it: Telegram Premium requirement, a non-blocking read-only unread-human-dialog preflight, a blocking activity preflight (stale exact last-seen, hidden profiles without an avatar), 15-second minimum spacing, opted_out blocking, stop-on-first-error, and per-message recording of successful sends. These are exactly the operational traits an agent cannot infer from the schema.

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

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

Front-loaded with the action and scope, and nearly every clause contributes a distinct operational fact. It is a dense multi-clause run-on, though, which makes the blocking preflight rules harder to parse than a short bulleted structure would.

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

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

For a destructive batch-send tool with no annotations and no output schema, the description covers prerequisites, preflights, rate limiting, and partial-failure behavior (stops on first error, records successes). It does not describe what the caller gets back (sent/failed counts, per-profile results) or whether re-running after a mid-batch failure is safe, which is a meaningful gap for a batch mutation.

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

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

Schema coverage is 80%, so the baseline is 3, but the description adds real meaning: it names the two draft_key values, ties the activity preflight to the last-seen window (max_inactive_days), and restates the 15-second floor that min_delay_seconds enforces. Only profile_ids and the exact stale-last-seen threshold semantics remain underexplained.

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 (send), a specific resource (a saved client-profile draft, firstContact or replyToUnread), and a bounded scope (up to 50 active profiles, one batch confirmation). This clearly separates it from sibling single-message tools like ads_client_profile_message_add or ads_telegram_account_send.

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

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

Gives a hard precondition (the exact saved draft and every variation must have been approved; any change requires fresh approval) and the confirmation requirement, so the agent knows when the tool is legal to call. It never names an alternative sibling or says explicitly when not to use this versus a single-recipient send, so it stops short of a 5.

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

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

With no annotations, the description carries the behavioral burden and adds meaningful context: it uses a local GramJS/TDLib backend, never reads non-public chats, never sends messages, and stores only a bounded result in the client profile. It does not cover authentication, rate limits, or failure behavior, but the safety and side-effect profile is unusually clear.

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

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

The description is two compact sentences, front-loads the core action, and then adds safety and storage behavior. There is no filler or repetition.

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

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

There is no output schema and no annotations, so the description should carry more detail. It explains the privacy boundary and that a bounded review result is stored, but it does not describe the result shape, what happens when no public channel exists, or how partial failures are surfaced.

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 does not compensate by explaining profile_id, queries, or per_query_limit. It indirectly implies profile_id identifies the Telegram user profile and that AI-topic search is performed, but it says nothing about the query list or the per-query result limit.

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?

It states a specific verb and resource: reviewing the public channel linked in a Telegram user's profile and searching it for AI-related topics. This clearly distinguishes it from generic Telegram post-search tools because the target is the channel already linked to a specific profile.

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

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

The description implies the use case, reviewing a profile-linked public channel for AI topics, and notes that non-public chats are never read. However, it does not explicitly say when to use this versus alternatives such as ads_telegram_public_posts_search or ads_telegram_channel_direct_check.

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 that consent defaults to unknown and that no message is sent. It omits behavior an agent would want for a write tool: idempotency, what happens on duplicate telegram_user_id, and what identifier is returned.

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?

Four compact sentences with the core action front-loaded and no filler. The channel/connector detail is dense but each clause maps to a real 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 15-parameter creation tool with no annotations and no output schema, the description leaves major gaps: the required telegram_user_id is unmentioned and the return value (presumably a new profile id) is not described. It reads like parameter footnotes rather than an operating guide.

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 15 parameters, so the description must compensate. It explains only channel, external_user_id, contact_account_id, and the consent default, leaving id, source, status, context, metadata, username, display_name, next_action_at, last_contact_at, dialogue_summary, and the required telegram_user_id 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 a specific verb and resource ("Create a local client profile with per-person context") and clarifies that the profile is a local record. This clearly separates it from the messaging siblings, though it never explicitly contrasts with ads_client_profile_update or ads_client_profile_get.

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 channel-selection guidance ("Telegram remains the default channel; channel and external_user_id can represent Mastodon or another connector") and one useful exclusion ("this tool does not send a message"). However, it never states when to create versus when to update/upsert, nor prerequisites such as a connected account.

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 does little: it does not say what 'recent' means, whether the call fails or returns empty when profile_id is unknown, whether history is truncated by default, or what the response shape is. Only the inclusion of dialogue history is disclosed.

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 well-formed sentence with no filler, and the primary resource is front-loaded before the secondary history payload. Hard to trim further without losing 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 lookup tool with zero annotations, zero parameter descriptions and no output schema, this is thin. An agent still cannot tell the default history window, the not-found behavior, or the returned fields, all of which the description would have to supply.

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 both parameters. The description gestures at dialogue history, which loosely maps to message_limit, but never explains that limit's default, its 500 cap, or the format of profile_id, leaving half the semantics 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 a specific verb and resource ('Get one local client profile') and adds the secondary payload ('its recent dialogue history'). The word 'one' implicitly distinguishes it from ads_client_profile_list, though no sibling is named 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?

There is no explicit when-to-use, when-not-to-use, or named alternative. The agent must infer from 'one' that this is the single-record counterpart to ads_client_profile_list; nothing about prerequisites or fallback behavior is given.

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

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

With no annotations, the description carries the full burden; 'list' implies a safe read, and the dialogue-history exclusion is a genuinely useful disclosure about payload scope. However, it says nothing about permissions, default limits, ordering, or what a profile summary actually contains, which matters given there is no output schema.

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

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

A single front-loaded sentence with no filler; the distinguishing scope detail is placed immediately. It could afford one short clause about available filters without becoming bloated, so it is efficient but slightly under-sized for a four-parameter tool.

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

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

For a tool with four undocumented optional filters, no annotations, and no output schema, the description leaves the agent without enough to call it confidently: no filter semantics, no notion of result shape or pagination. The 'without dialogue histories' note is the only real added 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 description coverage is 0% across four parameters, including two enums (status, consent_status) whose semantics are only bare values. The description never mentions limit, source, status, or consent_status, so filtering behavior and the meaning of 'source' must be guessed entirely from parameter 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?

States a specific verb and resource ('List local client profiles') and adds a scope qualifier ('without loading full dialogue histories') that separates it from the heavier get/message tools. It does not name a sibling outright, but 'list' vs. 'get' and 'client profile' vs. 'network profile' are distinguishable from the name-plus-description pair.

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 'without loading full dialogue histories' clause implies this is the lightweight/browsing entry point before calling ads_client_profile_get, but no alternative is named and no when-not condition is given. An agent can infer the use case for listing profiles but gets no explicit routing guidance among the many profile-related siblings.

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

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

With no annotations, the description carries the full burden, and it delivers the single most important behavioral fact: this is an append-only history write that 'never sends a message.' It does not cover other traits an agent would want for a 7-parameter mutation — whether appends are idempotent, whether the profile must already exist, how telegram_message_id is used for dedupe, or what is returned.

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

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

Three short sentences with no filler; the core action is front-loaded and the safety constraint anchors the end. Every sentence adds information the agent cannot get from structured fields.

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

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

For a mutation tool with no annotations and no output schema, the definition covers purpose, the write-only safety profile, and one parameter's usage rule. It is not complete enough to cover the semantics of the remaining parameters, error behavior (missing profile, oversized text at maxLength 20000), or what the call 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?

Schema description coverage is 0% across 7 parameters, so the description must compensate and only partly does: it explains the direction values in prose and gives real semantic guidance for contact_account_id (when to supply it and why). profile_id, text, sent_at, telegram_message_id and the nested metadata object are left entirely 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 (append) plus the resource (a note/history entry on a local client profile) and enumerates the three note directions. The closing clause 'stores history only and never sends a message' separates it from send-oriented siblings such as ads_client_profile_batch_send and ads_telegram_account_send without the agent needing to open another schema.

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

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

Gives explicit conditional guidance for contact_account_id ('for external or multi-account contacts, pass contact_account_id so the exact account is recorded') and makes clear the tool is for recording, not delivering. It stops short of naming an alternative tool to use when the agent actually wants to send, leaving that routing 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 safety burden and does much of it: read-only, latest incoming message only, no full history, no mark-as-read, no send. That is exactly the disclosure an agent needs before acting. It doesn't cover auth/permission requirements, per-chat cost, or what a returned record contains, so it stops short of a 5.

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

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

Front-loaded with the capability statement, then what it does not do, then the escalation path — a sensible ordering with little waste. Three sentences is reasonable, though the npm script reference is operational advice that could read as clutter in 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?

No output schema and no annotations exist, so the description must describe returns — it does, at the level of 'latest incoming message only'. For a one-parameter, read-only snapshot tool that is close to sufficient; the shape of the returned fields and any pagination/truncation behavior are the remaining 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 100% and the single 'limit' parameter already documents its default of 50 and maximum of 100. The description adds no extra meaning about how limit interacts with the 'latest message only' semantics, 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 concrete verb and resource ('fast read-only snapshot of unread one-to-one human Telegram chats') and scopes it to human 1:1 chats, which implicitly separates it from the channel, group, and mark-read siblings. It never names an alternative tool outright, so the differentiation stays inferential rather than explicit.

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

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

Gives a clear triggering context ('before drafting a reply') and a fallback path when a person has multiple messages (run the local full-history sync script and review every returned message). What's missing is guidance relative to the sibling tools — e.g., when to pair this with ads_telegram_chat_mark_read or whether to prefer ads_client_profile_channel_review for channel traffic.

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 one meaningful trait — no message is sent as a side effect — but for a 12-parameter mutation it omits whether omitted/null fields clear or preserve existing values, permission or auth requirements, reversibility, and behavior when profile_id is unknown.

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

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

Two tightly written sentences with no filler, and the core operation is front-loaded ahead of the side-effect disclaimer. It is efficient, though the terseness leaves little room for the scoping detail a 12-parameter mutation needs.

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?

Against a mutation tool with 12 parameters, 0% schema description coverage, no annotations and no output schema, the description is too thin. An agent still lacks the patch semantics, validation constraints and error behavior needed to call 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 description coverage is 0% across 12 parameters, so the description must compensate and mostly does not. It names roughly four of them (context, consent_status, next_action_at, contact account) but is silent on profile_id, source, status, metadata, username, display_name, last_contact_at, and dialogue_summary, and gives no guidance on the anyOf/null semantics that dominate this schema.

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

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

The description states a specific verb and resource ("Update one local client profile") and enumerates the main updatable facets — context, consent status, next action, contact account — which map onto real schema properties. The closing sentence carves it out from the sibling messaging tools (ads_client_profile_message_add, ads_client_profile_batch_send), though it does not explicitly distinguish it from ads_client_profile_create or ads_client_profile_get.

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?

One explicit negative condition is given ("does not send a message"), which usefully routes messaging intent to the sibling send tools. Beyond that, usage is only implied: nothing says whether the profile must already exist, when to prefer create over update, or how partial updates are intended to behave.

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 local storage of sensitive OAuth data and that it never performs billing or campaign actions, but it omits lifecycle details such as whether the server blocks, what it returns, or what happens if restart is false and a page is already running.

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 purpose is front-loaded in the first sentence, and the restart guidance is a separate concise sentence. The long list of stored credential types adds useful security context, though it makes the first sentence dense.

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, and 0% parameter coverage, the description covers purpose, local credential storage, and safety boundaries reasonably well. It is still missing port semantics, return behavior, and process lifecycle details that an agent needs to invoke 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 compensate. It explains the meaning of restart=true well but says nothing about the port parameter, leaving one of the two parameters 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?

The description gives a specific verb and resource: 'Start the local AdsMCP settings page on 127.0.0.1.' It implicitly distinguishes itself from campaign/billing siblings by stating it 'never performs billing or campaign actions,' though it does not explicitly differentiate itself from ads_dashbord_stop.

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 one clear conditional: 'Use restart=true only to replace an already-running page.' However, it does not explicitly say when to use this tool versus ads_dashbord_stop or other setup/auth tools, leaving the broader usage context implied.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It usefully clarifies that stopping the settings page does not delete profiles, accounts, or drafts, but it does not describe side effects, permissions, reversibility, or what "stop" does to any running process.

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

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

The description is two concise sentences with the action front-loaded. Every sentence adds useful information: what the tool does and what it does not delete.

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 local lifecycle tool with no output schema, the description is nearly complete: it identifies the action and clarifies an important non-destructive boundary. It could say more about resulting state or side effects, but no major calling detail is missing.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. The description appropriately does not invent parameter guidance, matching the baseline for parameterless tools.

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

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

The description states a specific verb and resource: "Stop the local AdsMCP settings page." It clearly distinguishes the tool from its obvious sibling, ads_dashbord_start, by specifying the stop operation on a local settings page.

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 negative clarification ("does not delete Click.ru profiles, Microsoft OAuth profiles, Mastodon accounts or campaign drafts") helps prevent misuse, but the description does not explicitly state when to use this tool, when not to use it beyond deletion, or name an alternative tool.

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

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

With no annotations provided, the description carries the full burden, and 'viewable' is a genuine behavioral disclosure implying results are permission-filtered to what the bot can see. Beyond that it says nothing about pagination, ordering, rate limits, or whether the bot must already be a guild member.

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 well-formed sentence with the scope constraint front-loaded and zero filler. It is efficient, though its brevity is part of why behavioral and parameter gaps exist.

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

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

For a one-parameter read tool with no output schema and no annotations, the definition omits how to acquire the guild_id and what the result shape or pagination looks like. Adequate to identify the tool, insufficient to call it confidently in edge cases.

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

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

Schema description coverage is 0% for the single required guild_id, and the description only indirectly maps it by saying 'in one Discord server' (guild = server). It adds no format detail (snowflake ID), no guidance on how to obtain a guild_id, and no constraint semantics.

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

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

The description uses a specific verb ('List') plus a resource ('channels') scoped to 'one Discord server', and enumerates the channel types returned (text, announcement, forum, thread). This distinguishes it clearly from write-oriented siblings like ads_discord_channel_send, though it does not name any sibling 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?

Usage is only implied: listing channels in a server is inherently a discovery step (e.g., to obtain a channel before ads_discord_channel_send), but the description never states when to use it, when not to, or which sibling it supersedes. No exclusions or preconditions are given.

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

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

With no annotations, the description carries the full burden and does disclose the key gating behavior: an explicit confirm=true is required and the write is limited to a single plain-text message. It does not state permission/auth requirements, rate limits, whether the send is irreversible, or what happens on failure — notable omissions for an unannotated outbound-messaging 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?

Two short sentences, front-loaded with the action and gate, with the scope exclusions packed into the trailing clause. Nothing is redundant and every clause adds usable constraint.

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-param mutation tool with no annotations and no output schema, the description covers the confirm gate, message type, and cardinality limits, which is most of what an agent needs. The missing piece is channel_id sourcing and success/failure behavior, which keeps it below a 5.

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% (only confirm is documented), so the description must compensate; it partially does by clarifying that text is plain-text and channel_id is a single selected channel. However it never explains how to obtain a valid channel_id (sibling ads_discord_channel_list exists) or the 2000-char limit context, leaving a real gap for the two undocumented params.

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 (send), a specific resource (one plain-text message), and a specific target (one selected Discord channel). The negative scope clause ('No bulk sends and no member DMs') cleanly separates it from batch/DM-style siblings such as ads_client_profile_batch_send and ads_mastodon_direct_message.

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

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

Gives a clear precondition ('after explicit confirm=true') and explicit exclusions (no bulk, no DMs), which tells the agent when this tool is not appropriate. It stops short of naming an alternative tool for the excluded cases (e.g. where to go for channel discovery or Telegram equivalents), so it is strong but not complete routing guidance.

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

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

With no annotations at all, the description carries the full disclosure burden. It does add real behavioral context by stating results are limited to bot-installed guilds, which prevents an agent from expecting a global directory. However, it says nothing about pagination despite the limit parameter, ordering, or what a returned guild record contains.

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

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

Two sentences, no filler. The scoping statement comes first and the disambiguation follows immediately, which is exactly the front-loaded structure an agent needs.

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 read-only list operation with no output schema, the definition covers what the tool returns conceptually but leaves out pagination behavior and result shape. Adequate to call, not complete enough to use the limit parameter intelligently.

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 single parameter 'limit' (1-200) is never mentioned in the description. The description does not explain that results are capped, what the default cap is, or how to page through more than 200 guilds, so the only parameter is documented solely by its schema type bounds.

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 ('Discord servers'), scoped to where the configured bot is installed. The second sentence explicitly rules out a broader interpretation ('This is not a global server search'), which separates it from the search-style siblings like ads_discord_member_search and ads_discord_message_search.

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

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

The negative guidance ('not a global server search') implies this is the enumeration path rather than a query path, but the description never says positively when to pick this over ads_discord_channel_list or ads_discord_status, nor what prerequisites exist (e.g., bot must be configured).

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

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

With no annotations, the description carries the burden. 'Search' implies a read-only operation and the note that finding a member doesn't authorize contacting them adds a useful compliance constraint, but it says nothing about permissions, rate limits, pagination, or what a match 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?

Two tight sentences, with the core action and scope front-loaded and the authorization caveat following. No wasted phrasing.

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

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

For a three-parameter search with no output schema and no annotations, the description covers the query semantics but omits the limit parameter, result shape, and permission requirements. Adequate but clearly incomplete.

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

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

Schema coverage is 0%, so the description must compensate. It clarifies that query matches username or nickname and that guild_id refers to one installed Discord server, but it never explains the 'limit' parameter or its 1-1000 range, leaving a real 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 (search), resource (members), and scope (by username or nickname inside one installed Discord server). This distinguishes it from ads_discord_message_search and ads_discord_channel_list, though it doesn't explicitly name those siblings.

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

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

The scoping constraint ('inside one installed Discord server') and the authorization caveat give implicit guidance on when and how to use it. However, there is no explicit when-to-use vs. alternatives (e.g., status/guild_list for discovery) and no exclusions beyond the contacting disclaimer.

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

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

With no annotations, the description carries the burden and does disclose key behavior: it searches only a bounded recent page and does not crawl or persist history. It omits auth/rate-limit details and pagination mechanics, but the non-persistence constraint is meaningful.

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 semicolon clause adds a real behavioral constraint rather than restating the name.

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

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

For a five-parameter search with no annotations, no output schema, and 0% schema descriptions, the definition is too thin. It explains scope but not parameter semantics or return shape, so an agent lacks enough detail to invoke it confidently beyond channel_id.

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 description names no parameters. 'One accessible Discord channel' and 'bounded recent page' loosely hint at channel_id and before/after/limit, but query, limit bounds, timestamp formats, and required channel_id are undocumented.

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

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

The description gives a precise verb (Search), resource (messages), and scope (one accessible Discord channel, bounded recent page). It also rules out crawling/persistence, helping distinguish it from channel list, member search, and send siblings.

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

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

It establishes clear usage context: single channel, recent bounded page, no history crawl. It does not explicitly name alternatives or when-not-to-use cases, but the scope is sufficient to prevent broad-history use.

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

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

With no annotations, the description carries the full burden and does disclose a real behavioral trait: the authentication model (official bot connector only, no user-account tokens or passwords). That is exactly the kind of auth-requirement context annotations would otherwise supply. It omits what a failed check looks like and whether a live network call is made.

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

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

Two sentences, front-loaded with the action and scope, followed immediately by the one constraint an agent most needs to know. No filler.

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

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

For a zero-parameter status check with no output schema and no annotations, the description covers purpose and auth prerequisites adequately. The main residual gap is that it does not characterize the response (e.g., connected vs. not-connected, what 'bot identity' returns), which matters slightly more here because there is no output schema to fall back on.

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 there is little for the description to add or omit. Nothing in the description misrepresents the empty input surface.

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?

Clear verb 'Check' paired with a specific resource set: the Discord bot connector, its credentials, and the current bot identity. This is distinguishable from the other Discord siblings (guild_list, channel_list, message_search, channel_send), which all operate on guild data rather than connector health. It stops short of naming those siblings explicitly, so it is not 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?

Usage is implied rather than stated: an agent infers this is the pre-flight/health check for the Discord integration. The sentence 'Normal user-account tokens and passwords are not supported' functions as a constraint on valid inputs rather than a when-to-use rule, and no alternative tool or exclusion path is 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that the card is public and lists normalized return fields, which is useful, but it omits error behavior, not-found handling, and any auth or rate-limit context.

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

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

The description is two tight sentences with the action and input front-loaded, followed by return information. Every sentence adds useful meaning without repetition.

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

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

For a simple single-parameter read with no output schema, the description is largely complete: it names the input forms and the returned fields. It could be fuller on failure behavior and whether public access has any constraints, but the core is covered.

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 compensate for the single parameter. It does so by explaining that id_or_url accepts either a numeric id or a dStore card URL, though it does not detail URL formatting or validation beyond what is implied.

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: read one public dStore card, with the accepted identifier forms. It implicitly distinguishes itself from list/search siblings by emphasizing 'one' card, but it does not explicitly name or contrast those alternatives.

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

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

The description implies usage when a numeric id or dStore card URL is available, and says it supports catalog discovery. However, it does not explicitly state when to use this instead of ads_dstore_cards_get or ads_dstore_search.

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 supplied, so the description carries the full burden. It usefully discloses partial-failure semantics ('keeps successful cards and reports individual lookup errors'), which is valuable for batch calls, but says nothing about auth requirements, rate limits, or whether any of the fields are unavailable for private cards.

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

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

Two sentences, zero filler, with the capability and the limit front-loaded and the result semantics immediately after. Every clause earns its place.

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

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

For a one-parameter tool with no output schema and no annotations, the description covers input format, batch limit, and result behavior adequately. Only authentication/visibility caveats for 'public' cards are left unstated.

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%, so the schema only reveals an array of 1-500 char strings. The description compensates by naming the accepted key types (id or URL) and the 50-item cap, which is exactly the missing information an agent needs to populate the parameter correctly.

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 (Read) and resource (public dStore cards) plus batch scope ('up to 50') and the lookup key types (id or URL). It does not, however, distinguish itself from the sibling ads_dstore_card_get or ads_dstore_search, which an agent would likely confuse with this tool.

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

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

Batch usage is implied by the 'up to 50' framing, but there is no explicit when-to-use guidance and no pointer to ads_dstore_card_get for single lookups or ads_dstore_search for discovery. The agent must infer the choice from the capability list 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 must carry behavioral weight. It usefully discloses the trust model (results are verified public inventory; AIKI proposals are unverified until dStore checks them), but says nothing about auth requirements, pagination via cursor/limit, default sort, or how results are ranked.

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

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

Two compact sentences with the core action front-loaded and the disambiguation second. No filler, though it spends a whole clause on AIKI framing rather than on how to call the 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 an 11-parameter, zero-schema-description, no-output-schema, no-annotation tool, the description is far too thin. It doesn't tell the agent how to narrow results across the many filters, whether q is required, or what a search response contains.

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 11 parameters, and the description mentions none of them. Filters like region, category, platform, pricing_model, currency, lang, format, and cursor pagination are left entirely unexplained, so the agent must guess intent from bare property 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?

States a specific verb and resource: search dStore's verified public advertising inventory. It also implicitly scopes the domain (channels/sites for mutual promotion) and separates itself from the AIKI proposal sibling, though 'inventory' alone is slightly abstract.

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

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

Explicitly says to use this for finding channels or sites for mutual promotion, and explicitly names a related-but-different path (AIKI community proposals) that stays unverified. No exclusion of other sibling search tools (e.g. ads_network_inventory_list, ads_tg_resource_list), which keeps it below 5.

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

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

With no annotations provided, the description carries the full disclosure burden and does so for the most important risk: it states the tool reads public catalog data and neither transmits credentials nor publishes changes, which is solid read-only/side-effect transparency. It stops short of stating auth requirements, rate limits, or whether any configuration state is cached or mutated server-side.

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

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

Two tight sentences with the subject stated first and the safety caveat second; every clause carries information and nothing is repeated from the name or schema.

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

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

No output schema exists, so the description must carry the burden of telling the agent what comes back, and 'the dStore card and advertising-placement adapter configuration' is a rough sketch rather than a description of the returned fields or shape. For a zero-parameter read tool with no annotations, that leaves a real gap in knowing what to expect from the response.

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

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

The input schema has zero properties, so there are no parameters to disambiguate; the baseline for a 0-param tool applies. The description correctly implies a simple parameterless call and adds no misleading parameter talk.

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 verb+resource is concrete: it 'shows' the dStore card and advertising-placement adapter configuration, so an agent knows the subject matter. However, it does not distinguish itself from near-identical siblings such as ads_dstore_cards_get, ads_dstore_card_get, or ads_store_status, leaving overlap for the agent to resolve unaided.

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: the negation clause ('does not send credentials or publish changes') signals this is a safe inspection call rather than a mutation, which effectively narrows its role. There is no explicit when-to-use, no stated prerequisites, and no named alternative among the several dStore/status siblings.

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

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

With no annotations, the description must carry the behavioral burden. It does valuable work by disclosing idempotency semantics ('a stable dedupe_key makes retries safe'), which is real context an agent needs. However, it says nothing about what happens on conflicting non-matching data, auth/permission needs, or what the tool returns on success.

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

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

Two short, front-loaded sentences with no filler; the core action comes first and the idempotency caveat second. It is efficient, though for a 15-parameter ingestion endpoint the brevity edges into under-specification rather than pure 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?

A mutation endpoint with 15 parameters, a nested tracking object, no annotations, and no output schema requires substantially more description than two sentences. The agent is left guessing about event timing, currency pairing with amount, and the meaning of most tracking fields.

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 15 parameters, so the description must compensate and mostly does not. Only dedupe_key gets any explanatory treatment; critical fields like kind (an enum of event types), occurred_at, amount/currency, count, and the nested tracking object are entirely 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?

The description states a specific verb and resource ('Ingest a funnel event or conversion'), which clearly distinguishes this write tool from the read/report siblings such as ads_network_conversion_report and ads_campaign_analytics. It does not explicitly name a sibling it should be preferred over, so it falls short of a 5.

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

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

The clause about a stable dedupe_key genuinely implies a usage pattern (retry-safe ingestion), giving more than nothing. But there is no explicit when-to-use vs alternatives guidance, no mention of when to prefer ads_spend_record for spend, and no stated 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?

No annotations are provided, so the description must carry the behavioral burden. It discloses the local-directory scope and the prerequisite review step, but it does not explain what acceptance records, whether it is persistent or reversible, or what permissions or side effects are involved.

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

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

The description is two short sentences with the action and scope front-loaded, followed by the prerequisite. Every sentence carries useful routing or procedural information.

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

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

The description plus schema is sufficient for an agent to invoke the tool correctly: review the rules first, then call with confirm=true. However, with no annotations and no output schema, it remains thin on what acceptance actually changes or 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?

Schema description coverage is 100%, and the schema already explains that confirm must be true after review and that rules_version is currently 1.0. The description adds no additional parameter meaning, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Accept the current AdsMCP Free Use Rules', and scopes it to 'this local data directory'. It also distinguishes the action from the sibling ads_free_use_rules by explicitly directing the agent to review that tool first.

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 sentence 'Review ads_free_use_rules first' gives an explicit prerequisite and names the sibling tool to use before this one. It effectively tells the agent both when to use this tool and which alternative action must precede it.

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

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

No annotations are provided, so the description carries the full burden. It does disclose two behaviors beyond the name — it reads the rules text and it inspects local acceptance state — and 'Read' implies a non-mutating operation, but it does not state the return shape (rules text vs. a boolean flag), whether the rules are fetched remotely or bundled locally, or any auth requirement.

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 read action front-loaded and the status-check purpose following immediately. No filler and no repetition of the tool name.

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

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

For a zero-parameter, no-output-schema tool this is nearly sufficient: an agent knows what is read and what state is evaluated. The one remaining gap is what the response actually contains, which matters because the only stated purpose is obtaining that status.

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 there is nothing for the description to disambiguate; baseline is 4. The description correctly implies no inputs are needed to perform the check.

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

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

The description uses a specific verb ('Read') plus a named resource ('AdsMCP Free Use Rules') and adds a second concrete outcome: reporting whether this local installation has accepted the current version. That distinguishes the intent from a pure document fetch, though it never names the sibling ads_free_use_accept that performs the acceptance action.

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: an agent can infer this is the check-before-accept step, but the description never says when to call it versus ads_free_use_accept or whether it should precede acceptance. No exclusions or preconditions are stated.

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

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

No annotations are provided, so the description carries the full burden; it does disclose that this is a mutating publish step creating exactly one branch and PR, gated behind confirm=true. It omits permissions/auth needs, whether the branch or PR is created idempotently, what happens on partial failure, and what is returned.

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 that front-loads the prerequisite, then the action, then the gating condition; no filler.

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

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

For a 3-parameter, no-annotation, no-output-schema write tool the description covers the essential workflow and safety gate, though it leaves permission requirements and the meaning of title/body 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 coverage is only 33% — only `confirm` is documented in the schema, while `title` and `body` are bare strings with maxLength limits. The description compensates for neither, never explaining what title/body populate in the PR or how they are derived.

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 one GitHub branch and pull request') and frames the prerequisite sibling ads_github_contribution_status, so it is unmistakable versus status/setup siblings in the same family.

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

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

Explicitly sequences the workflow: review changedFiles from ads_github_contribution_status first, then call this only with confirm=true. It gives clear context but never states exclusions or what to do instead if the review is rejected.

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

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

With no annotations, the description carries the full burden and does meaningful work: it discloses that the tool is optional, that creation is gated behind confirm=true, and that it authenticates via a configured GitHub token (an auth prerequisite). It stops short of stating idempotency, what confirm=false persists, or side effects on existing config.

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

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

Two sentences, front-loaded with the purpose and followed by the one behavioral caveat. No filler or redundancy.

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

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

A three-parameter mutation tool with no annotations and no output schema needs to say more: what result a caller gets (fork URL, saved configuration), what confirm=false does, and whether the fork is created only when none is configured (that detail lives only in the schema). Adequate but with clear gaps.

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

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

Schema coverage is 100%, so all three parameters are already documented, including defaults for create_fork and upstream_repository. The description only restates the confirm=true → fork creation link, adding little syntax or behavior beyond the schema; 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 and resource: prepare an optional GitHub fork for publishing reviewed AdsMCP changes. It is clearly distinguishable from status/create_pr siblings by naming the fork-setup action, though it never explicitly contrasts with ads_github_contribution_status or ads_github_contribution_create_pr.

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?

"Optional" and "confirm=true may create the fork" imply this is a preparatory step used before publishing contributions, but there is no explicit when-to-use/when-not, no ordering relative to ads_github_contribution_status or ads_github_contribution_create_pr, and no stated prerequisites.

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

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

No annotations are provided, so the description carries the burden. It does disclose an important safety trait: it shows status "without publishing anything." It does not cover permissions, whether local Git state is modified, rate limits, or what the response contains beyond a high-level description.

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

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

The description is a single efficient sentence with the key scope and safety constraint front-loaded. Every phrase adds useful information: what is shown, context (local Git and fork setup), and the no-publish guarantee.

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 no-parameter status tool with no output schema, the description gives enough high-level context about what is inspected and confirms it does not publish. It could say more about the return shape or whether it is purely read-only, but the essential behavior is covered.

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

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

The tool has zero parameters and an empty schema, so there is no parameter semantics burden. The baseline for a 0-parameter tool is 4, and the description does not need to compensate for 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 uses a specific verb ("Show") and names the resource clearly: local Git changes and GitHub fork setup. It implicitly distinguishes itself from the sibling setup/create-PR tools by framing the action as status-only and explicitly "without publishing anything," though it does not name those alternatives.

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

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

Usage is implied: the tool is for inspecting current Git/fork state before taking action, and the phrase "without publishing anything" signals a read-only check. However, it does not explicitly say when to use this instead of ads_github_contribution_setup or ads_github_contribution_create_pr.

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

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

With no annotations, the description carries the burden well: it discloses the safe-swap ordering ('New images are linked first'), what is not touched (square images, logos, text), and a confirmation gate. It stops short of stating whether the old landscape/portrait images are unlinked or deleted, and mentions no permission or rate-limit constraints.

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

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

Three sentences, mutation behavior first, preservation guarantees second, prerequisite last. Nothing is redundant and nothing could be removed without losing 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 destructive-ish mutation with no annotations and no output schema, the behavioral story is solid, but the missing guidance on customer_id/login_customer_id and on the fate of replaced images leaves real gaps an agent needs before calling it correctly.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate and largely does not. It covers the asset group, the asset payload, and confirm=true, but leaves customer_id vs login_customer_id, file_path format, label, and the per-item field_type semantics unexplained beyond the self-evident enum.

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

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

States a specific verb (Replace) on a precise resource (landscape and portrait marketing images in a Performance Max asset group). The scope is bounded to 'enabled' images, so an agent knows exactly what this touches without opening the schema, and no sibling tool competes for this operation.

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

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

The description delimits usage by scope ('enabled landscape and portrait marketing images') and adds a hard prerequisite ('Requires explicit confirm=true'), but never explicitly says when to prefer this over other flows or what happens when an asset group has no such images. Usage is implied rather than spelled out.

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 deliver two real facts: reads go through a pre-configured service-account adapter (an auth dependency the caller must know about) and the tool 'never writes to Google Ads'. It says nothing about rate limits, pagination, empty-result behavior, or what defaults apply when from/to are omitted.

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

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

Two tight sentences that lead with the capability and follow with the safety guarantee; nothing is padded. Slight under-specification rather than wordiness is the issue here.

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 annotations, no output schema, and 0% parameter documentation mean the description must do more than two sentences. A caller cannot determine the date format for from/to, whether customer_id is mandatory in practice, what fields the report returns, or how it relates to ads_google_ads_sync.

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 never mentions a single parameter. The four params (from, to, customer_id, login_customer_id) carry names and regex patterns only; an agent gets no explanation that from/to are a date window, their expected format, what happens if omitted, or that login_customer_id is a manager-account header. 'Daily' is the only faint hint.

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: 'Read daily Google Ads campaign metrics', with the source adapter named. The platform qualifier ('Google Ads') implicitly separates it from ads_microsoft_ads_report and ads_yandex_direct_report, but it never explicitly contrasts with ads_google_ads_sync, the closest sibling a caller might confuse it with.

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 ads_google_ads_sync (which presumably also touches Google Ads) or the other per-platform report tools. The word 'daily' hints at granularity but there is no guidance on required date ranges, prerequisites, or coverage/exclusion conditions.

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 critical safety fact that it never writes to Google Ads, which is genuinely useful. But it says nothing about whether local rows are upserted or replaced, permission/auth requirements for customer_id, rate limits, or what happens on partial failure.

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

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

Two tight sentences with the read/persist distinction front-loaded and the safety caveat second; no filler whatsoever.

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, zero-coverage, no-annotation, no-output-schema sync tool, the description is far too thin — it leaves date-window semantics, project scoping, overwrite behavior, and required account identifiers entirely 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 0% and five parameters (from, to, project_id, customer_id, login_customer_id) are completely undocumented. The description adds no meaning to any of them — not the date format or default window for from/to, not what project_id scopes, not the manager-account role of login_customer_id.

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

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

States a concrete verb-pair and resource: read Google Ads metrics, then persist normalized campaign/spend/conversion data into local SQLite. This distinguishes it from the pure-read sibling ads_google_ads_report by naming the persistence side effect, though it never names that sibling directly.

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 — an agent can infer it should run sync before querying local analytics, but the description never says when to prefer this over ads_google_ads_report or the parallel ads_microsoft_ads_sync / ads_yandex_direct_sync tools, nor any prerequisites.

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

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

No annotations are provided, so the description must carry the behavioral burden. It implies a read-only listing but does not disclose whether configuration values are sensitive, whether output is paginated, or what authentication or 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?

The definition is a single front-loaded sentence with no filler. It immediately states the operation and the objects being listed.

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 zero-parameter list tool, the description is adequate to understand the broad purpose. However, with no output schema and no annotations, it could say more about what the returned items contain, especially 'configuration status' and whether sensitive information is included.

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

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

The tool has zero parameters, so there is no parameter semantics to document. The baseline for zero-parameter tools is 4, and the description neither contradicts nor complicates that.

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 ('List') and resource ('registered integrations and built-in adapter capabilities/configuration status'). It is clear enough to distinguish from write-oriented siblings like ads_integration_register, though it does not explicitly name an alternative.

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

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

The description implies you would call it to inspect integrations and adapter status, but it provides no explicit when-to-use or when-not-to-use guidance. With many sibling tools around integrations, planning, and platform configuration, this leaves routing 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 behavioral burden. "Show" implies a read-only informational tool, but the description does not explicitly state that it is non-mutating, what permissions are required, or how results are scoped by provider.

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 efficient sentence with the primary purpose front-loaded. The phrase "safe next actions" is slightly vague but still earns its place as an output category.

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 must carry more weight. It names the main output categories (readiness, env keys, next actions) but leaves the structure of "adapter readiness" and the format of required keys underspecified for a planning tool.

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

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

Schema coverage is 0% and the single provider parameter has no schema description. The description compensates partially by clarifying that the parameter selects one provider or all when omitted, but it does not specify accepted provider values or 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?

States a specific verb (Show) and specific content (adapter readiness, required environment keys, safe next actions), with scope for one or all providers. It is clear but does not explicitly distinguish itself from siblings like ads_integration_list or ads_module_plan.

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

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

The phrase "for one or all providers" implies usage scope, and "safe next actions" hints at setup planning. However, it gives no explicit when-to-use guidance or alternatives to sibling tools such as ads_integration_list or ads_platform_guide.

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 one meaningful trait: secrets are not stored, so credentials are referenced indirectly. However, it omits duplicate-handling/idempotency, required permissions, and what config/status do, leaving significant behavioral 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?

A single tight sentence with the key constraint ('without storing secrets') front-loaded. Efficient, though the size is 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 6-parameter mutation tool with a nested config object, an enum, no annotations, and no output schema, the one-sentence description is thin. An agent cannot confidently fill parameters or predict behavior from 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?

Schema description coverage is 0% across 6 parameters, so the description must compensate but largely doesn't. It hints at the provider (integration type) and secret handling (secret_env), but leaves id, name, config (nested object), and the status enum 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 a specific verb (Register) and resource (external advertising, CRM or webhook integration), which is clear and distinguishable from read-only siblings like ads_integration_list. It does not explicitly contrast with ads_integration_plan, so it stops short of full sibling differentiation.

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

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

There is no explicit when-to-use or when-not guidance, and no mention of the relevant alternatives (ads_integration_plan, ads_integration_list) despite their existence. The verb implies 'create a new integration', but the agent must infer this.

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 the safety profile (read-only, no contact side effects), which is the most important behavioral fact here. It says nothing about ordering, pagination beyond the implicit limit, default scoping (project_id defaults to 'neron'), or what a returned record contains — material for a 9-parameter 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?

Two short sentences, front-loaded with the purpose and followed by the safety constraint; neither sentence is filler. It is perhaps over-compressed for a nine-parameter tool, but there is no padding or redundancy.

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

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

Given nine optional parameters, five enums, no annotations and no output schema, two sentences leave the agent without filter semantics, default project scoping, or any sense of the result shape. The safety note is valuable but the definition is substantially under-specified for this surface area.

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 9 parameters, so the description must compensate and it explains none of them. Nothing clarifies that status/channel/category/contact_type/consent_status/outreach_eligibility act as filters, what 'channel' is a free-form name of, or what limit caps — the agent must reverse-engineer semantics from bare enum values.

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

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

States a specific verb and resource ('List public discovery candidates from the local interest registry'), which tells an agent this is a read of a curated candidate pool rather than a research/contact tool. It does not explicitly distinguish itself from near-neighbours such as ads_interest_research_post_list or ads_interest_research_stats_list, so the differentiation is only implicit.

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

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

'This is read-only and never contacts anyone' sets a clear boundary and implies this is the inspection tool rather than the outreach one (contrast ads_interest_contact_upsert). However, it names no alternative and gives no condition for choosing this over the sibling interest/research listing tools, leaving selection 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 disclosure burden. It usefully states that consent remains unknown by default and clarifies non-actions (no profile creation, no follow, no message), but omits auth requirements, idempotency/merge behavior on update, rate limits, and return expectations for a 19-parameter mutation.

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

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

Two tightly written sentences with no wasted words. The core purpose is front-loaded, and the safety exclusions and consent default follow immediately.

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 19-parameter upsert with no annotations, no output schema, and 0% schema description coverage, the description is not complete enough to call safely. It establishes intent and key exclusions but leaves most parameter semantics, auth expectations, and update behavior undocumented.

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 19 parameters, so the description must compensate but mostly does not. The only parameter-adjacent hint is that 'consent remains unknown by default,' which relates to consent_status but does not explain channel, external_user_id, status, category, or the other 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 states a specific verb (save or update) and resource (one public discovery candidate in the local interest registry), which is clear. It distinguishes itself from client-profile creation, following, and messaging, but does not explicitly name sibling tools like ads_interest_contact_list.

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 useful when-not guidance by saying it does not create a client profile, follow anyone, or send a message, helping the agent avoid those incorrect tools. It stops short of naming concrete alternatives or describing positive when-to-use criteria.

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

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

No annotations are provided, so the description carries the full load. It does add real behavioral context — 'Read-only; it never contacts authors' rules out side effects and outreach, which is genuinely useful. However it says nothing about ordering, pagination, default result size, or what 'bounded' means, leaving meaningful gaps.

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

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

Two short sentences, front-loaded with the operation and its scope, and zero filler. It is arguably too terse given the six undocumented filters, but no sentence wastes space.

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

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

No annotations, no output schema, and six undescribed filters: the definition gives an agent almost nothing to construct a correct query or interpret results. A user would have to open the schema and guess at the semantics of status, channel, and the 'bounded' scope.

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?

Six parameters with 0% schema description coverage means the description must compensate, and it does not: status, channel, contact_id, project_id, and external_post_id are never mentioned. The only hint is the vague word 'bounded,' which loosely gestures at the limit parameter.

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?

Specific verb+resource: 'List ... public research posts collected during discovery' tells the agent this is a read of previously-discovered posts, which distinguishes it from the sibling ads_interest_research_post_upsert. The adjective 'bounded' is unexplained and the sibling is not named explicitly, 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?

'Collected during discovery' implies a context but gives no when-to-use / when-not-to guidance. Nothing routes the agent between this tool and ads_interest_research_stats_list or ads_interest_research_post_upsert, and no prerequisites or filter-before-call advice is offered.

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 usefully discloses the key behavioral fact: this is local-only storage with no outbound publishing or contacting, and the record is 'bounded' (one post). It stops short of explaining upsert conflict behavior — what identifies an existing post, what fields get overwritten on a re-store, or what is returned.

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

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

Two short sentences: purpose first, safety constraint second. Nothing is redundant and the most important caveat is front-loaded.

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

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

For a 16-parameter mutation with no annotations and no output schema, the description omits required-field expectations, the upsert identity semantics, and any indication of the response. It covers intent and safety, but not enough for reliable 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% across 16 parameters, and the description adds no parameter meaning at all — the four required fields (channel, external_post_id, post_url, author_external_user_id) and the identifier semantics of the upsert key are never mentioned. Names alone carry the load for fields like signal_type, relevance_score, and metadata.

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: store one bounded public research post linked to an interest contact. It is distinguishable from ads_interest_research_post_list, but the name says 'upsert' while the description says 'Store one', leaving the insert-vs-update identity key (presumably channel + external_post_id) unexplained.

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 call this versus ads_interest_contact_upsert or when to list vs record. The only boundary given is an effect boundary ('never publishes or contacts anyone'), which is about safety, not about tool selection.

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

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

With no annotations, the description does carry real weight by disclosing that this is analytics-only and sends no messages, which is the key safety fact. It omits other behavioral traits an agent needs: whether the snapshot is persisted/overwritten, the window semantics, and whether repeated calls are 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?

Two sentences, no waste, with the resource and its measured dimensions front-loaded and the safety caveat second. Nothing could be removed without losing information.

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

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

The description effectively serves as the missing output summary by listing post volume, unique authors, contacts, relevance and tags, which is valuable given there is no output schema. It falls short only on the input side, where three parameters with defaults and bounds go 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 0% for all three parameters, so the description must compensate. It only gestures at time-windowing via "time-window" and says nothing about the range/bounds of `days`, what `channel` values are valid (mastodon default, max 80 chars), or what `project_id` scopes.

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 ("Build") and a specific resource ("a local time-window snapshot of research demand") and enumerates the metrics it captures. It does not explicitly differentiate itself from the close sibling ads_interest_research_stats_list, leaving the build-vs-read distinction to be inferred from the names.

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?

"This is analytics only and never contacts anyone" usefully rules out the outreach/contact siblings, but it never states the positive trigger (e.g. call this before ads_interest_research_stats_list, or after ingesting posts) nor names the alternative for retrieving existing snapshots.

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

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

No annotations are provided, so the description carries the burden, and it does add valuable context: it is read-only analytics and never contacts people, which reassures an agent about side effects. However, it omits pagination behavior, the meaning of the limit cap (1000), and the defaults (channel=mastodon, project_id=neron) that materially affect results.

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

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

Two short sentences, front-loaded with the purpose and followed by the safety qualifier; every clause carries information and nothing is padded.

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

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

With no annotations, no output schema, and six completely undocumented parameters, the description should do much more. It leaves the agent without guidance on defaults, filtering semantics (period_start/period_end format, channel values), or result 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% across six parameters, so the description must compensate, but it gives no parameter-level meaning. At best, 'snapshots and tag popularity metrics' loosely hints at the stat_kind enum (summary vs tag) and the period fields, which is far short of the six undocumented parameters.

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

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

The description names a specific verb (list) and resources (saved research demand snapshots, tag popularity metrics), which an agent can map onto the tool name. It does not explicitly distinguish itself from the closely related sibling ads_interest_research_stats_build (the producer of these snapshots), but the read/list framing is clear.

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

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

The read-only, never-contacts-anyone framing implies this is safe for inspection-style use, but there is no explicit statement of when to choose this tool over ads_interest_research_stats_build, ads_interest_research_tag_list, or other interest-research siblings. Usage is only implied.

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