CdpHub

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

Annotations already declare readOnly, idempotent, closed-world, non-destructive behavior, so the safety profile is covered. The description goes further by enumerating what the response contains (CDPs listing all tools, groups by connection type with counts, near-misses by missing tool, and a link), which is genuinely useful given there is no output schema. It omits any error or edge behavior (e.g., unknown tool names), so not a 5.

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

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

Front-loaded with the verb and scope, and each clause describes a distinct part of the output. It is a single dense sentence whose tail ('and a link to the same check on cdphub.com') is arguably low-value for an agent, but nothing is wasted overall.

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 read-only aggregate query with one fully documented parameter and no output schema, the definition tells the agent what goes in, what comes out, and when to reach for it. Nothing an agent needs in order to call it correctly 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?

Schema description coverage is 100% and already states 'two to ten' with an example array. The description's mention of the two-to-ten range and the tool-set nature adds nothing beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Check a stack of two to ten tools against every CDP') with the exact scope and the reference behavior it mirrors (the stack check on cdphub.com). It is clearly distinguishable from siblings like compare_cdps or get_tool, which operate on single or pairwise entities.

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

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

Explicitly says 'Use it for any question about two or more tools together, such as which CDPs fit a company's stack,' which gives a clear selection rule. It does not name the sibling tools it replaces or state when not to use it, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds useful behavioral context by disclosing the exact response contents (shared-only counts, most widely listed tools, category gaps, comparison URL), which matters since there is no output schema. It does not cover edge cases such as an unknown CDP name.

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 purpose leads and the deliverable enumeration follows. The long comma-chained list of outputs is dense but each clause maps to a real result, so nothing is wasted.

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

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

For a two-string read-only tool with full schema coverage and no output schema, the description is nearly complete: it spells out the return contents and where the external link points. The only gap is failure behavior for unrecognized CDP names.

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%, with both required parameters documented and exemplified ('Segment', 'mParticle'). The description only restates that the inputs are two CDPs and adds no semantics beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource: 'Compare two CDPs' integration catalogs ... tool by tool'. It enumerates exactly what the comparison yields, which clearly separates it from single-entity siblings like get_cdp, list_cdps, and get_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?

Usage is implied by the purpose — an agent can infer this is the tool for comparing two vendors. However, there is no explicit guidance on when to pick this over check_stack (also a multi-entity tool) or how to chain it after list_cdps to resolve CDP names, and no exclusions are stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds real value by disclosing what the response contains (tool counts, rank, integration direction, categories, warehouse connections, similar CDPs, page URL) — meaningful given no output schema. No pagination/auth caveats, but this is a single-object lookup so little is missing.

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

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

Front-loaded with the verb and resource, which is good, but the return-facet list becomes one very long run-on sentence that is hard to scan. Every item arguably earns its place since there's no output schema, but the structure could be broken into a scannable list.

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

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

With no output schema, the description compensates well by enumerating the return facets, so an agent knows what to expect. The main gap is absent guidance on when to pick this versus the comparison or stack siblings.

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

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

Single parameter with 100% schema description coverage and an example set (Segment, Braze, Adobe Experience Platform), so the schema fully carries semantics. The description adds nothing beyond the schema for the 'name' argument, which is the baseline expectation here.

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 ('look up') and resource ('one customer data platform'), explicitly singular in contrast to the plural list_cdps sibling. It enumerates the returned facets, so the agent knows exactly what data comes back. It doesn't name alternatives like compare_cdps or get_tool, so differentiation is inferred 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?

Usage is only implied: fetch a single CDP's profile. There is no explicit when-to-use versus list_cdps, compare_cdps, or check_stack, and no stated prerequisites. An agent must infer the selection rule from the singular scope.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds real value by enumerating what the response contains: per-CDP integration counts, sends/reads direction grouping, which CDPs list it or not, deployment mode, doc links and the cdphub page. It omits the failure case (unknown tool name) and whether records are cached or refreshed.

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 core action, and the long enumerative clause is all substance about returned fields rather than filler. It is a single run-on sentence though, and the return-content list could be split or trimmed for scanability.

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 one required parameter, full schema coverage, complete annotations and no output schema, an agent has everything needed: what to pass, what comes back, and how the data is grouped. The description carries the return-shape burden that the absent output schema would otherwise leave undefined.

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

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

Only one parameter and schema coverage is 100%, with the schema already documenting 'name' and giving examples. The description's examples ('Snowflake, Braze, Google Ads or The Trade Desk') reinforce what counts as a valid name, but add little 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 ('look up') and a specific resource ('one marketing or data tool in CdpHub's directory'), with concrete examples. It is clearly separable from get_cdp (a CDP, not a tool) and list_cdps/search_directory, which operate on sets rather than a single named entity.

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?

'Use it for any question about one tool' gives a clear selection rule, and the emphasis on a single named tool implicitly rules out the list/search siblings. It never explicitly names get_cdp or search_directory as the alternative when the target is a CDP or a fuzzy query, so the routing is inferable rather than stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so safety is covered. The description adds genuinely new behavioral detail: each entry includes tool/listing counts and a cdphub.com page URL, results are sorted by catalog size, and directory totals are returned. It does not mention result size, paging, or cost, which is a minor remaining gap.

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

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

A single sentence with no filler, and the verb and scope are front-loaded. It is slightly dense in the middle ('with its number of tools and listings and its page on cdphub.com'), but every clause carries information.

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

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

For a zero-parameter, read-only listing tool with no output schema, the description covers return content and ordering, which is what an agent needs. Only result volume/pagination behavior is left unstated, a small gap given the tool's simplicity.

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-level confusion is possible.

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 plus resource ('List every customer data platform') with explicit scope ('every ... in CdpHub's directory') and ordering ('largest catalog first'). This contrasts clearly with get_cdp (single item) and search_directory (filtered lookup) without needing to name them.

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

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

The word 'every' implies this is the full-enumeration tool, so usage is inferable, but there is no explicit when-to-use statement, no exclusion, and no named alternative (e.g., 'use search_directory to filter'). Guidance is implied rather than stated.

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

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

Annotations already declare readOnly, idempotent, and non-destructive, so the safety profile is covered. The description adds genuinely useful behavior the annotations do not carry: it returns exact totals, only the first results (implying a bounded page with no pagination control), and a deep link to the same search on cdphub.com. Missing detail on how 'first results' is capped or whether an empty invocation is valid.

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

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

Three short sentences, front-loaded with the verb, resource, and facets, then the return shape, then the sibling routing. Nothing is redundant with the schema or 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 7-parameter, all-optional, read-only search tool with no output schema, the description supplies precisely what is missing elsewhere: what is returned (totals, first results, external link) and which sibling to use instead. An agent has enough to call it correctly and interpret 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?

Schema description coverage is 100%, so each of the 7 parameters, including enum values for runs, sort, group, and directions, is already documented. The description's mention of the searchable facets adds marginal framing but no 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 (search) and resource (CdpHub's directory of CDP integrations) and enumerates the facets it searches on: keyword, CDP, category, direction, and run model. An agent can distinguish it from get_tool and check_stack without opening any schema.

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

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

Explicitly names the alternatives and the condition that selects them: get_tool for a single named tool, check_stack for a set. It does not address the other siblings (list_cdps, get_cdp, compare_cdps) or state when a plain browse without a query is appropriate, so routing is clear but not exhaustive.

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