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

No annotations are provided, so the description carries the full burden. It discloses the action (create) and the return value (JSON object with created backlink data). However, it does not mention potential errors, idempotency, or permission requirements, which keeps it slightly below a 5.

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

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

The description is well-organized with Args, Returns, and Examples sections. It is reasonably concise for an 8-parameter tool, with the example adding practical value without excessive verbosity.

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

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

Given the output schema exists, return values are covered. The description fully documents parameters and provides an example. It lacks usage context (e.g., prerequisites like the campaign existing), but is otherwise complete for a create operation.

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

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

Schema description coverage is 0%, but the description explicitly explains every parameter, e.g., 'The campaign to associate the backlink with' and 'Anchor text of the link (optional)'. This adds significant meaning beyond the raw schema, though some explanations are brief (e.g., 'Backlink title').

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 'Create a new backlink in AgencyAnalytics' with a clear verb and resource. It distinguishes from sibling tools like delete_backlink and update_backlink by indicating creation specifically.

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 via the create verb, but does not explicitly state when to use it versus alternatives (e.g., update_backlink for modifying existing backlinks). There is no when/when-not guidance, but the context of creation is clear.

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

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

With no annotations provided, the description carries the full burden. It discloses that it creates a campaign and returns a JSON object, and gives an example. However, it omits behavioral details such as potential errors, idempotency, or authentication requirements. This is adequate but not rich.

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

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

The description is well-structured with a summary line, Args, Returns, and Examples sections. Every sentence provides useful information, and there is no redundancy or fluff. It is appropriately sized for the tool's complexity.

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

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

For a simple create tool with two parameters, the description is nearly complete: it specifies the arguments, return type, and an example. Given that an output schema exists, return details are not needed. The only minor gap is ambiguity around 'campaign (client)' and lack of edge-case handling, but overall it is sufficient.

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

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

The input schema has 0% description coverage, only providing titles 'Url' and 'Company'. The description compensates fully by explaining 'url: The website URL for the campaign' and 'company: The company/client name', and also provides a concrete example. This adds clear meaning beyond the schema.

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

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

The description clearly states 'Create a new campaign (client) in AgencyAnalytics' with a specific verb and resource, distinguishing it from sibling tools like update_campaign, delete_campaign, and get_campaign. The parenthetical '(client)' adds useful context.

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

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

The description provides an example call and clearly indicates the action (create new campaign), so when to use it is implied. However, it does not explicitly mention alternatives or when not to use it (e.g., for updating existing campaigns use update_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?

There are no annotations, so the description must disclose behavioral traits. It states a return value and provides an example, but it does not mention potential side effects, error conditions, idempotency, or required permissions. For a mutating create operation, this is a significant transparency gap.

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

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

The description is structured with a summary line, Args, Returns, and an Example, with no fluff. Every line adds value, and the summary is front-loaded. It is appropriately sized for a simple two-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 simple two-parameter create tool with an output schema, the description covers the purpose, parameters, return type, and usage example. It lacks usage guidance and behavioral caveats, but the low complexity keeps the gaps modest. The output schema exists, so the return format is sufficiently specified.

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

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

The input schema provides only types and titles with 0% description coverage. The description compensates by explicitly defining campaign_id as 'The campaign ID to add the competitor to' and url as 'The competitor website URL,' along with a concrete example. This adds meaningful semantics beyond the bare schema.

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

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

The description opens with 'Add a competitor to a campaign,' which clearly identifies the action (add) and the resource (competitor to a campaign), distinguishing it from sibling tools like create_backlink or create_tag. The specific verb and resource make the purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives, no exclusions, and no context about prerequisites. It merely states the action and parameters, leaving usage decisions to the agent.

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

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

With no annotations, the description carries the full burden. It discloses key behaviors: creates a one-time URL, no password required, and returns expiration info. It does not mention potential permissions or whether existing tokens are invalidated, but for a token generator this is reasonably transparent.

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

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

The description is well-structured with a summary, args, returns, and example. It is mostly concise, though the Args section largely repeats schema information, making it slightly redundant. Still, the front-loaded summary and example add value.

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

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

Given the tool's simplicity (one parameter) and the presence of an output schema, the description is complete: it explains the purpose, usage context, parameter, return value, and provides an example. No critical information is missing for correct invocation.

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

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

Schema coverage is 0%, so the description must compensate. It states 'user_id: The user ID to generate a login token for', which clarifies the parameter's role but adds little beyond the parameter name. It lacks context on how to obtain a valid user_id or any constraints, so it only partially compensates.

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

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

The description clearly states the specific action ('Generate an SSO login token') and the resource ('for a user'), with a one-line summary that distinguishes it from sibling user management tools. The verb is specific and the scope is unambiguous.

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

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

The description provides clear context on when to use it ('Useful for embedding reports or creating custom login pages'), but does not explicitly state when not to use it or name alternatives. This is sufficient for a unique tool but lacks explicit exclusions.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It only states that a tag is created and a JSON object returned, which is obvious from the operation type. It omits details about error handling, idempotency, or permissions, leaving significant gaps.

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

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

The description is compact, using short sections for Args, Returns, and Examples. Every line provides useful, scan-friendly information with no redundancy or fluff.

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

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

The tool is simple with one required parameter, and the description covers purpose, parameter, and an example. Since an output schema exists, the Returns section is a bonus. The main omission is usage guidance, but for a straightforward create operation, the description is largely sufficient.

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

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

The input schema already defines 'name' as a required string. The description's Args section simply restates 'The tag name' without adding constraints, naming rules, or valid value examples beyond the 'priority' example. This does not compensate for the 0% schema description coverage.

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

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

The description clearly states the action ('Create') and the resource ('a new tag in AgencyAnalytics'), which distinguishes it from sibling tools like create_campaign or create_user. The example reinforces the intended function.

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 this tool is for creating tags when needed but provides no explicit guidance on when to choose it over alternatives or exclusions. The example shows a basic call, but there is no discussion of prerequisites or contexts where it should not be used.

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 explains the creation behavior, defaults for role and campaign_access, and the campaign_id dependency, but it omits potential side effects such as invitation emails, duplicate user checks, or required permissions.

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

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

The description is well-structured with an action statement, Args section, Returns, and Examples. It is compact and free of redundant content, with each element serving a clear purpose for invocation.

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 6 parameters, 3 required, and no annotations, the description covers all parameters, defaults, return type, and usage examples. It is complete enough for an agent to select and invoke the tool correctly, especially given the presence of an output schema.

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

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

The input schema has 0% description coverage, but the description fully compensates by explaining every parameter: email, first_name, last_name, role (with default), campaign_access (allowed values and default), and campaign_id (tied to restricted access). The examples illustrate typical parameter combinations, adding valuable meaning beyond the schema.

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

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

The description opens with 'Create a new user in AgencyAnalytics,' clearly specifying the action and resource. It distinguishes itself from sibling tools like update_user, list_users, and delete_user by using the 'create' verb with the 'user' resource.

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

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

The description implies usage for adding a new user through its examples and parameter details, but it does not explicitly state when to use this tool over alternatives. There are no exclusions or clear 'use this when' guidance, leaving the context partially implicit.

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 mentions that the tool returns a JSON object but does not disclose that deletion is permanent, whether the operation is destructive, or any authorization requirements. For a delete tool, this is a significant transparency gap beyond what the tool name already implies.

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

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

The description is concise and well-structured, with clearly labeled sections for Args, Returns, and Examples. Every sentence contributes useful information without redundancy. The front-loaded main clause immediately communicates the tool's purpose, and the example is particularly helpful for quick understanding.

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

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

For a simple one-parameter delete tool, the description covers the essential invocation details: purpose, argument, return type, and an example. The output schema further documents the return structure. However, it lacks contextual guidance about side effects and safety, which is critical for deletion tools. It is adequate but has clear gaps in operational context.

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

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

With 0% schema description coverage, the description must compensate for the parameter. It restates the parameter name ('the backlink ID to delete') and provides an example (backlink_id=789) that clarifies the expected numeric format. However, it does not explain where the ID comes from or how to validate it, relying on the schema's title 'Backlink Id' for basic comprehension.

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

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

The description starts with 'Delete a backlink from AgencyAnalytics', which clearly specifies the verb, resource, and scope. It distinguishes the tool from siblings like delete_user, update_backlink, and list_backlinks, making the intended action unambiguous.

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

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

The description provides no explicit guidance on when to use this tool compared to alternatives. It does not mention any prerequisites (e.g., obtaining the backlink ID via list_backlinks) or exclusions (e.g., use update_backlink to modify instead). The only implied use case is deletion, which is generic for any delete operation.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only says 'Delete a campaign' and mentions a return value, but fails to warn that deletion is permanent, irreversible, or that it may affect related data. This is a significant gap for a destructive action.

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

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

The description is concise and well-structured with a clear main line, followed by Args, Returns, and Examples sections. Every element serves a purpose with no unnecessary filler.

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

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

For a simple delete operation with one parameter and an output schema, the description is mostly complete, covering what is passed and what is returned. However, it lacks important contextual details about the deletion's permanence or side effects, and it does not differentiate usage from sibling delete tools, making it minimally viable 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 description coverage is 0%, but the description compensates by explaining the single parameter: 'campaign_id: The campaign ID to delete.' It also provides a concrete example (delete_campaign(campaign_id=123)), making the parameter's purpose clear beyond the schema's basic integer type.

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

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

The description clearly states the action: 'Delete a campaign (client) from AgencyAnalytics.' It identifies the specific resource (campaign/client) and the platform, which distinguishes it from sibling delete tools like delete_user and delete_backlink.

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 does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. The usage is implied by the tool's name and straightforward purpose, but no explicit guidance is provided.

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

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

No annotations are provided, so the description must disclose side effects. It only states the deletion action and that a JSON object is returned; it does not mention permanence, required permissions, cascading effects, or reversibility—critical for a destructive operation.

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

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

The description is compact and well-structured with a clear purpose, Args, Returns, and an Example. Every line adds value, and the format makes it easy to parse.

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

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

For a simple deletion tool with an output schema (per context signals), the description is mostly adequate. However, it lacks warnings about destructive consequences or prerequisites, which are important for safe invocation.

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

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

The schema provides only a type and title for user_id, but the description's Args section explains 'The user ID to delete,' adding necessary semantic meaning. The parameter is simple and sufficiently documented.

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

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

The description opens with 'Delete a user from AgencyAnalytics,' clearly specifying the action and resource. It distinguishes from sibling tools like create_user, update_user, list_users, and get_user.

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?

Clear context for use: you call this to delete a user. However, it does not provide explicit exclusionary guidance or mention alternative approaches (e.g., deactivation via update_user), though the purpose is unambiguous.

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

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

With no annotations, the description carries the full burden. It discloses that the tool retrieves detailed information and returns a JSON object, which is helpful. Yet it does not mention error behavior (e.g., missing campaign), permissions, or rate limits. For a simple read operation, this is sufficient but has clear gaps.

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

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

The description is mostly concise and front-loaded, with the key purpose in the first line. The Args/Returns/Examples structure is clean. A minor redundancy exists between the first two sentences ('Get a single campaign' vs 'Retrieves detailed information'), but it's not excessive.

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 nested objects) and the description explains purpose, parameter, return type, and gives an example. Since an output schema exists (though not shown), full return value documentation is not required. The main missing context is error handling and connection to sibling tools, but for its complexity this is nearly complete.

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

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

The schema only provides the type (integer) and requirement; the description's Args section explains that campaign_id is 'The AgencyAnalytics campaign ID,' adding semantic meaning. Given the single parameter, this compensates well for the 0% schema description coverage.

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

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

The description clearly states a specific verb ('Get') and resource ('campaign' or 'client') with a scope ('by ID'). It distinguishes from list_campaigns implicitly ('single' vs listing), but does not explicitly contrast with sibling tools, so it doesn't earn 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 implies use when you need one specific campaign by ID, and the example shows direct usage. However, it offers no explicit guidance on when not to use it or mention alternatives like list_campaigns for discovering IDs. Usage context is adequate but not fully articulated.

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

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

With no annotations provided, the description carries the full burden. It discloses the return format, data granularity, and search engines covered, and provides examples. It does not explicitly state that it is read-only or mention authentication/rate limits, but the verb 'get' and narrative imply no 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?

The description is well-structured with a clear summary, Args, Returns, and Examples sections. It is appropriately sized with no filler or redundant content, and every section adds value.

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 retrieval tool with an output schema, the description covers purpose, parameters, return structure, and examples. It lacks explicit time-range behavior, but the schema does not include a time-range parameter, so this is complete for the defined interface.

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. The Args section thoroughly explains campaign_id as required, offset as pagination with default 0, and limit as max results with default 50, adding meaning beyond the raw schema. Examples further illustrate parameter usage.

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

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

The description clearly states that the tool retrieves historical ranking trends for a campaign, specifying key details like average positions, distribution buckets, and search engines. This distinguishes it from sibling tools such as get_keyword_rankings by focusing on aggregate campaign-level data.

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

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

The description implies usage for campaign-level historical rankings but never explicitly mentions alternatives like get_keyword_rankings or states when not to use this tool. The context is clear but excludes no alternatives, so guidance is only 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?

The description discloses the return format (JSON array with SERP URLs and search volume) and pagination parameters, adding some behavioral context. However, with no annotations, it does not explicitly state read-only semantics, nor does it explain the 'change tracking' behavior or any potential limitations in detail.

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

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

The description is well-structured with Args, Returns, and Examples sections. It is concise, front-loaded with the main purpose, and every section earns its place, with examples adding practical clarity.

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

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

The description covers the core purpose, all parameters, and return values, and is supported by an output schema. However, it lacks differentiation from similar sibling tools and does not elaborate on the 'change tracking' aspect, which somewhat limits completeness for a tool with no annotations.

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

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

The description provides clear explanations for all three parameters, including the required campaign_id and the pagination semantics for offset and limit. Since the schema has zero description coverage, this compensation is essential and well executed, though the 'default' values simply repeat schema information.

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

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

The description clearly states that the tool retrieves keyword rankings for a campaign, listing specific data types (Google, Google Mobile, Google Places, Bing) and change tracking. However, it does not distinguish itself from the sibling tool get_campaign_rankings, which may serve a similar purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives such as list_keywords or get_campaign_rankings. There are no explicit use cases, preconditions, or exclusions, leaving the agent without context for 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 carries the full burden. It discloses that the tool 'Retrieves detailed information' and describes included fields and a JSON return format. However, it does not mention error handling (e.g., 404 for missing user), authentication requirements, or rate limits, leaving some behavioral gaps.

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

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

The description is well-structured with a lead sentence, explanatory paragraph, Args/Returns sections, and an example. It is concise, though the first two sentences are slightly redundant ('Get a single user by ID' and 'Retrieves detailed information about a specific user').

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

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

This is a simple one-parameter read tool with an output schema available. The description covers purpose, parameter meaning, return format, and an example. It is fully adequate for an agent to decide when to use it and how to call it correctly.

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

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

The schema provides only the parameter name and type (integer), with 0% description coverage. The description's Args section explains 'user_id: The AgencyAnalytics user ID' and provides an example (456), adding the domain meaning that the schema lacks. This effectively compensates for the low coverage.

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

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

The description clearly states 'Get a single user by ID' and elaborates with 'Retrieves detailed information about a specific user including their role, status, and campaign access.' This distinguishes it from sibling tools like list_users (multiple users) and update_user/delete_user (mutations), using a specific verb, resource, and scope.

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

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

The description clearly implies the tool should be used when you have a user ID and need detailed info on that single user. It provides clear context but does not explicitly mention alternatives like list_users or state when not to use this tool, so it lacks explicit exclusions.

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

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

With no annotations, the description carries the full burden. It implies read-only behavior via 'list' and 'retrieves', and describes the return format. However, it does not disclose auth needs, rate limits, or potential side effects, which are not explicitly covered.

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

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

The description is well-structured with a title, summary, args, returns, and examples. Every section is concise and informative, with no redundant or vague language.

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

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

For a straightforward list tool with optional filtering and pagination, the description covers purpose, parameters, return format, and examples. It lacks error handling or edge-case details, but these are not critical for basic invocation.

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

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

The input schema has no parameter descriptions (0% coverage), but the description fully compensates by explaining campaign_id as a filter, offset for pagination, and limit for max results, plus usage examples. This adds meaning beyond the schema's types and defaults.

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

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

The description clearly states the tool lists backlinks from AgencyAnalytics, using the specific verb 'list' and resource 'backlinks'. It distinguishes from sibling tools like list_keywords, list_campaigns, and list_users by naming the resource 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?

The description provides clear usage context through examples for no filter, campaign filter, and pagination. It does not explicitly mention alternatives or when not to use, but the resource-specific naming and examples make usage intuitive.

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

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

With no annotations, the description carries the transparency burden. It discloses pagination behavior, default offset/limit values, and the notable API/UI naming difference. It also states the return format as a JSON array, exceeding what a minimal list description would offer, though it omits details like error handling or rate limits.

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

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

The description is well-structured with sections for purpose, note, args, returns, and examples. Every section adds value, though the examples are somewhat redundant with the parameter definitions. It is efficient and clear, but not as ultra-terse as a two-sentence description.

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

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

Given that an output schema exists and the tool has only two parameters, the description covers everything needed: the operation, pagination semantics, defaults, and examples. It leaves no significant conceptual gaps, making it fully complete for this tool's complexity.

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

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

The input schema provides no descriptions for limit and offset, so the description's Args section is essential. It clearly defines both parameters with defaults and provides usage examples, fully compensating for the 0% schema coverage.

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

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

The description opens with 'List campaigns (clients) from AgencyAnalytics,' providing a specific verb and resource, and clarifies the API/UI naming difference (Campaign = Client). This distinctly positions it against sibling tools like get_campaign, create_campaign, and delete_campaign.

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 through the 'List' verb and pagination examples, but it does not explicitly state when to use list_campaigns versus get_campaign or other alternatives. No exclusions or comparative guidance is provided, so it remains at the 'implied usage' level.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does state a key constraint (one campaign at a time) and mentions pagination defaults, but it does not disclose whether the operation is read-only (though 'List' implies it), error behavior for invalid campaign IDs, or any authentication/rate-limit details. This is adequate but not comprehensive.

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

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

The description is well-structured with a brief purpose statement, an Args section, a Returns line, and Examples. Every section adds value, the examples are concise, and there is no redundant filler.

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

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

Given the tool's simplicity (3 params, 1 required) and the existence of an output schema, the description is quite complete. It covers purpose, parameter meanings, a usage constraint, and examples. Minor gaps remain regarding error handling and explicit safety assurances, but these are not critical for a simple list operation.

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

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

Schema description coverage is 0% because the schema lacks property descriptions. The description compensates by providing semantic meaning for each parameter: campaign_id as 'The campaign ID (required)', offset as 'Pagination offset (default: 0)', and limit as 'Maximum number of results (default: 50)'. This goes beyond the schema's structural info (types, defaults, required) and includes a practical example.

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 the specific verb 'List' with the resource 'keywords for a campaign', clearly distinguishing it from sibling tools like list_campaigns, list_users, and list_backlinks. It also states the scope ('for a campaign') and the constraint of one campaign at a time, making the purpose unambiguous.

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

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

The description provides clear context on when to use the tool ('List keywords for a campaign', 'Keywords can only be queried one campaign at a time') and includes examples showing typical usage. However, it does not explicitly mention alternatives or when not to use this tool, though the sibling tool names imply distinctions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains pagination via offset and limit, and notes the return type (JSON array with metadata). It does not disclose permissions, rate limits, or any filtering constraints, which are relevant but not critical for a simple read operation.

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

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

The description is well-structured: a one-line summary, a clarifying sentence, then Args, Returns, and Examples. Each section serves a purpose and is front-loaded with the main functionality. No superfluous text.

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

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

For a straightforward list tool with two pagination parameters, the description covers purpose, parameter semantics, return type, and usage examples. The existence of an output schema reduces the need to detail return structure, and the description provides enough context for correct invocation.

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

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

The schema has zero descriptions for parameters, so the description compensates by clearly explaining offset as 'Pagination offset' and limit as 'Maximum number of results,' including defaults and example calls. This adds concrete meaning beyond the bare schema properties.

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

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

The description clearly states the tool 'List users from AgencyAnalytics' and elaborates with 'Retrieves all platform users with their details and roles.' It uses a specific verb (list/retrieves) and resource (users), and differentiates from sibling tools like get_user by indicating the scope (all users vs. presumably a single user).

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

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

The description provides clear context that this tool is for listing all users, with examples showing default and custom usage. However, it does not explicitly mention when not to use it or name alternative tools like get_user, so it lacks explicit exclusions/alternatives.

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

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

No annotations are provided, so the description carries the full burden. It only says 'Update an existing backlink' and lists fields, without disclosing side effects, error behavior, whether unspecified fields are preserved, or what the 'update result' contains. This is a significant gap for a mutation tool.

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

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

The description is efficiently structured with a one-sentence purpose, a bulleted Args list, a Returns line, and two practical examples. Every element adds utility and there is no wasted text.

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

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

Given that an output schema exists, the description adequately covers the operation's scope, key parameters, and usage examples. It lacks some behavioral details (error handling, partial update behavior) but is sufficient for a straightforward update tool with optional 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?

The schema provides zero description coverage, but the description's Args section adds meaningful semantics for each parameter (e.g., 'New title', 'New page URL', 'New status'). This compensates well, though the explanations are terse and example coverage is limited.

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

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

The description opens with 'Update an existing backlink', using a specific verb and resource that clearly distinguishes it from siblings like create_backlink and delete_backlink. The title and description align, making the tool's purpose immediately obvious.

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 clearly implies use for modifying existing backlinks, and the optional field list supports partial updates. However, it does not explicitly state when not to use it or mention alternatives like create_backlink for new entries, so it stops short of a 5.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only mentions that it returns a JSON object with update result. As a mutation tool, it does not disclose potential side effects, required permissions, or reversibility of changes. This is a significant transparency gap.

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

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

The description is concise and well-structured, with a brief purpose statement followed by Args, Returns, and Examples sections. Every sentence earns its place, and the format is front-loaded and efficient.

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

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

Despite missing usage guidelines and behavioral details, the description provides purpose, parameter semantics, and examples for a simple 3-parameter update tool. The output schema exists, so the return value note is sufficient. Overall, it is fairly complete for the tool's complexity.

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

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

The schema has 0% description coverage, so the description carries the burden of parameter semantics. The Args section clearly explains campaign_id as the ID to update, url as the new website URL, and company as the new company name, adding meaningful context beyond the raw 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 starts with 'Update an existing campaign (client),' which clearly states the action (update) and the resource (campaign). It also distinguishes from sibling tools like create_campaign and delete_campaign by specifying 'existing,' leaving no ambiguity about what this tool does.

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

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

The description implies usage through the word 'existing' and the nature of the tool, but it does not explicitly state when to use this tool vs alternatives. It lacks any reference to sibling tools such as get_campaign, create_campaign, or delete_campaign, so the guidance is only implicit.

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 mentions that a JSON object with update result is returned, but it does not disclose whether the update is partial (only specified fields), what happens if the user does not exist, permission requirements, or any side effects. This is a significant transparency gap for a mutation tool.

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

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

The description is well-structured with a clear heading, Args list, Returns line, and Examples. It is concise—no redundant prose—and every section earns its place. The examples are practical and illustrative without unnecessary verbosity.

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 an output schema exists, the tool does not need to explain return structure in deep detail, and it does mention the return type. However, with six parameters, zero schema descriptions, and no annotations, the description should provide more context on error handling, partial update semantics, and valid enumerations. It is a minimum viable description 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?

The schema has 0% description coverage, so the description is the only source of parameter meaning. It lists all six parameters with brief explanations (e.g., 'New email address (optional)'), which adds some value beyond the raw schema. However, it lacks details such as valid role values, format for campaign_access, or constraints, making the semantics only minimally useful.

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

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

The description clearly states 'Update an existing user.' with a specific verb and resource. It lists the fields that can be updated, distinguishing it from sibling tools like create_user, delete_user, and get_user. The purpose is unmistakable.

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

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

The phrase 'existing user' implies the tool is for modifying already-created users, providing some implicit guidance. However, there is no explicit mention of when to use this versus alternatives (e.g., create_user for new users, update_campaign for campaigns), nor any exclusions or prerequisites.

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