Monitly

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

Annotations already declare non-read-only, idempotent, non-destructive, so the safety profile is covered. The description adds real value beyond that: the side effect (update alerts to the user) and the constraint that the plan's watchlist limit applies — neither is in the structured fields.

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, zero filler, and the core action and its id source are front-loaded. Every sentence earns its place.

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

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

For a one-parameter tool with no output schema and annotations covering the safety profile, the description is nearly sufficient. It could note what happens when the plan limit is exceeded, but that is a minor 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 parameter is already documented as 'Dataset id (main.id) from search_catalog', so the description's id note is largely redundant. Baseline 3 is appropriate when the schema carries the parameter semantics.

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

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

States a specific verb+resource ('Follow a dataset by id') and adds the observable effect ('user gets alerts when it updates'). It implicitly separates itself from the batch sibling add_watchlist_batch, but never names it, 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?

Gives useful context by pointing to search_catalog as the source of the id, which tells the agent when the tool is applicable. However, it names no alternatives (list_watchlist, remove_from_watchlist, add_watchlist_batch) and gives no when-not 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?

Annotations already declare the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the bar is lower, yet the description still adds real behavior: the 100-item cap, duplicate skipping, hard stop at the plan limit, and the skipped_limit report field. It does not explain consequences of hitting the cap or whether the call partially succeeds, which keeps it from 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?

Two tight sentences with no filler; the batch scope and cap are front-loaded and the duplicate/limit behavior follows immediately. Every clause carries information 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?

With no output schema, the description helpfully names the skipped_limit signal and covers the cap and duplicate handling. Minor gaps remain on failure/partial-success semantics and plan-limit preconditions, but the core calling contract is 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?

One parameter with 100% schema description coverage, so the schema already documents dataset_ids. The description's 100-item cap loosely bounds the array, but it adds no syntax or format detail beyond what the schema provides; 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 with batch scope: add up to 100 datasets to the watchlist in one call. The batch framing implicitly separates it from the single-item sibling add_to_watchlist, but it never names that sibling, 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?

The phrase 'in one call' plus the 100-item cap implies this is the bulk path versus add_to_watchlist, but there is no explicit when-to-use statement, no guidance on when to prefer the single-item tool, and no prerequisite/plan-limit context beyond 'stops at plan limit'.

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

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

Annotations cover the safety profile (readOnly=false, idempotent=false, destructive=false), and the description adds two genuinely useful behavioral facts: the raw key is shown only once and per-plan key limits (3 Essential / 10 Pro). It does not cover what happens on duplicate names or whether the quota is per-account or per-workspace, so it falls short of exhaustive.

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, each carrying distinct information (what it creates, the one-time return, the quota). The most decision-relevant facts are front-loaded with zero 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 one-parameter creation tool with no output schema, the description covers the key behaviors an agent needs: the returned value is ephemeral and quota limits exist. Auth requirements and the omission/default behavior of 'name' are the only notable 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% for the single 'name' parameter, so the schema already documents it fully. The description adds nothing about the name parameter (uniqueness, defaults when omitted, required-ness), 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 (Create) and resource (REST API key) plus scope ('for /api endpoints') and the key prefix format ('mon_…'). This implicitly separates it from the sibling create_mcp_key, so an agent can route without opening either 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?

The '/api endpoints' qualifier implies the usage context, but the description never explicitly says when to choose this over create_mcp_key, nor any prerequisite (e.g., plan, permissions, whether existing keys block creation). Usage is inferable but not stated.

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

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

Annotations cover the safety profile (not read-only, not idempotent, not destructive). The description adds the crucial behavioral fact that the raw key is returned only once, which is not derivable from annotations and directly affects how the agent must handle the result. It does not mention auth requirements 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?

Two short sentences with zero filler; the core action and the one-time-return caveat are both front-loaded. 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 creation tool with no output schema, the description covers the essential return behavior (raw key shown once). It is slightly thin on the fact that the key can later be identified via list_mcp_keys, but nothing needed to invoke 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 coverage is 100% and the single name parameter is fully documented in the schema, so baseline 3 applies. The description adds only a faint hint (naming for a second client) and no format or constraint details beyond the schema.

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

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

States a specific verb and resource ("Create another MCP key") and even gives the identifier prefix mcpk_, which distinguishes it from the sibling create_api_key. It is clear and concrete, though it never explicitly names the API-key sibling it could be confused 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?

"e.g. for a second client" implies a use case (multiple clients/keys), which is weak but real guidance. There is no explicit when-not condition, no prerequisites, and no pointer to list_mcp_keys or delete_mcp_key as 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?

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered. The description adds a genuine behavioral constraint not in the annotations: the last remaining key cannot be revoked. It stops short of describing whether revocation is immediate or its effect on in-flight requests.

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 zero waste. The core action is front-loaded and the constraint follows immediately, making it easy to scan.

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 single-param delete whose safety profile is fully carried by annotations, this is close to complete, and the last-key caveat covers the main pitfall. It could still note the return/confirmation behavior on success, but nothing essential 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?

With a single parameter at 100% schema description coverage, the schema already documents key_id as a uuid from the list call. The description's 'by id' adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Revoke) and resource (REST API key) scoped by id, which is clear and actionable. The 'REST' qualifier implicitly separates it from the sibling delete_mcp_key, though the description never names that alternative explicitly, so it falls just short of the 5 tier.

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

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

Provides the precondition 'The last remaining key cannot be deleted', which is a useful when-not guardrail. However, it gives no guidance on when to revoke vs. rotate, and does not point to delete_mcp_key for MCP keys, so 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.

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

Annotations already declare destructiveHint=true, idempotentHint=true and readOnlyHint=false, so the safety profile is covered. The description adds a genuine behavioral constraint not in the annotations: the current session's key is protected from revocation. It does not say whether revocation is immediate or what downstream tokens stop working, which keeps it 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?

Two short sentences, zero filler, and the action is front-loaded ahead of the caveat. 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 destructive tool whose annotations already flag destructiveness and idempotency, the description supplies the key missing piece (session-key protection). Residual gaps around immediacy of revocation and any cascading effect on existing sessions are minor.

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

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

There is a single parameter with 100% schema description coverage ('Key id (uuid) from the list call'), so the schema already carries the semantics. The description's 'by id' adds nothing beyond that, making the baseline 3 appropriate.

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

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

The description states a specific verb and resource: 'Revoke an MCP key by id.' The MCP-key qualifier separates it from delete_api_key in the sibling list, though the description never explicitly contrasts the two, 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?

It gives a clear precondition for use with 'The key used for the current session cannot be revoked here,' which tells the agent when this call will fail. It offers no routing guidance toward delete_api_key or create_mcp_key alternatives, so it is context without exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and a closed world, so safety is fully covered. The description adds the table allowlist ('main and data only') beyond that, but says nothing about row limits, cost, timeout, or result shape.

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, and the constraint (read-only, table allowlist) is front-loaded before the workflow hint. Every clause carries information 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 single-parameter, well-annotated tool this is nearly complete: scope, query shape, and the catalog-to-query workflow are all stated. With no output schema present, one more note on result shape or limits would close 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?

Only one parameter, and schema coverage is 100%, so the schema already documents 'query' as a SELECT against main/data. The description reinforces the SELECT/WITH restriction but adds no syntax, dialect, or limit details 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+resource (run a SQL SELECT) and immediately narrows scope to 'read-only SELECT (or WITH … SELECT) against tables main and data only'. No sibling tool competes for this task, and the query shape and target tables are unambiguous.

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

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

Gives clear sequencing: 'Use after search_catalog + inspect_dataset to pull the time series for a known data.id / main_id', which tells the agent the prerequisite tools and when this tool is the right call. It stops short of naming an explicit alternative or a when-not case beyond the read-only restriction.

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, non-destructive and closed-world, so the safety profile is covered. The description adds that the output is a download URL rather than inline data, but says nothing about size limits, async behavior, or link expiry that would matter for an export tool.

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

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

One compact sentence that front-loads the return value (CSV download URL) and appends the optional filters. No filler, nothing restated redundantly.

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 annotations covering safety and a 100%-covered schema, the remaining burden is the return value, which the description handles by naming the CSV download URL. It is nearly complete for this tool, missing only edge details like large-export handling, which the lack of an output schema does not require it to cover.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters with examples, setting a baseline of 3. The description adds meaning above that baseline by tying the dimension keys (dim1…dim8) back to inspect_dataset, telling the agent where the filter vocabulary comes from.

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 ('Return a CSV download URL for a dataset') plus the filtering scope. This cleanly distinguishes it from siblings like get_dataset (fetch data) and inspect_dataset (inspect structure), which a sibling-naming reference to inspect_dataset reinforces.

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 mention of 'dim1…dim8 from inspect_dataset' implies a prerequisite workflow (inspect before exporting) but never says so explicitly. There is no stated when-to-use-vs-alternative against get_dataset or search_datasets, leaving 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?

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely new context by naming the payload fields returned (dimensions, default_view, geos), which matters since there is no output schema, though it says nothing about behavior when the id does not exist.

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

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

One sentence, front-loaded with the action and scope, with the parenthetical payload detail earning its place. 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 one-parameter read tool with annotations and no output schema, the description is nearly sufficient: it names the source table and key return fields. It omits error behavior for unknown ids and any hint of how it relates to inspect_dataset, keeping it out of 5 territory.

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 ('Dataset id (main.id).'), so the schema carries the semantics. The description's 'by id (main.id)' merely restates it; 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?

Specific verb (Get) plus resource (one dataset metadata row) and retrieval key (by id), with the returned payload enumerated (dimensions, default_view, geos). It does not differentiate itself from the sibling inspect_dataset, 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?

Usage is only implied: fetch a single dataset when you already have its id. No explicit when-to-use, when-not-to-use, or routing to alternatives such as search_datasets or inspect_dataset, which is a real ambiguity given the overlapping 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds the useful detail of what the response contains, but says nothing about auth requirements, behavior for keys without an active plan, 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?

A single front-loaded clause names the resource first and then enumerates the payload; there is no filler. It is a fragment rather than a full sentence, but every element carries information and nothing is repeated from the schema.

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

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

With no parameters and no output schema, the description correctly compensates by naming the returned fields, which is the key thing an agent cannot learn from structured data. It is close to complete for a trivial read tool, missing only a note on how it differs from list_plans.

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 a 4 applies. The parenthetical list of limits (API/day, MCP/month, watchlist, API keys) describes returned data rather than inputs, so there is no parameter semantics left to clarify.

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 resource and scope: the current plan of the key owner, plus exactly what is returned (name, status, period end, limits). It is clearly distinguishable in intent from upgrade_plan, but it never explicitly contrasts itself with the sibling list_plans, which a reader could plausibly confuse with it.

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

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

Usage is only implied by the verb 'get' and the word 'current' — an agent can infer this is the single-plan fetch rather than the listing tool. There is no explicit when-to-use statement, no mention of prerequisites, and no routing note pointing to list_plans or upgrade_plan for related needs.

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

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

Annotations already declare this a safe, idempotent, closed-world read, so the safety profile is covered. The description still adds substantive behavioral detail by naming exactly what is measured and over which windows (MCP queries this billing period, REST requests today, watchlist slots), which is meaningful since no output schema exists.

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; each clause maps to a distinct returned metric family. The dash-joined 'used, limit, remaining' tail is compact but slightly cryptic about which metrics carry which 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?

With no parameters and no output schema, the description does the work of describing returns by listing the three measured resource groups and the used/limit/remaining shape. Combined with annotations that fully cover the read-only, idempotent profile, an agent has what it needs to call this 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 takes zero parameters and schema coverage is 100%, so there is nothing for the description to disambiguate. Baseline 4 applies.

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

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

The description states a concrete retrieval purpose and enumerates the three metric families returned: MCP queries for the billing period, REST API requests for today, and watchlist slots. That is enough for an agent to distinguish it from siblings such as get_plan or list_watchlist, though it never explicitly names 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?

There is no when-to-use guidance, no prerequisites mention, and no named alternative. One can infer this is for checking quota consumption, but the description never says when to reach for get_usage versus get_plan or list_plans.

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 cover read-only, idempotent, non-destructive, closed-world semantics, so the description owes little there. It adds genuine value by disclosing the indexed main_id lookup mechanism (a performance trait) and, absent an output schema, previewing the return shape.

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 identifier and return preview front-loaded, followed immediately by the operational warning. Dense but every clause carries information; 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?

With no output schema, the description usefully sketches the return contents and the lookup behavior, and annotations handle the safety profile. Minor gaps remain around pagination/limits and the exact form of the returned slice, but nothing blocking for a 2-parameter read tool.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema itself. The description restates 'by main.id' and hints at the country effect ('whether a country is in the series') but adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Peek one dataset by main.id') and enumerates what the peek returns (default slice, country membership, dataId, last values). It implicitly counters the execute_sql sibling by telling the agent not to scan the data table, but it never names an alternative sibling directly, so differentiation is only partial.

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

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

Provides a clear anti-pattern ('do not scan the data table yourself for discovery'), which steers the agent away from execute_sql for exploration. It does not explicitly state the positive trigger (when to prefer this over get_dataset or search_catalog), leaving that to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds genuine context beyond that: only 'Active' keys are returned (revoked ones excluded) and the key prefix format is mon_…, which helps the agent interpret 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?

A single compact sentence with no filler, and the key scope ('Active REST API keys') is front-loaded before the field list. It is slightly telegraphic, but nothing wasted.

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

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

With no parameters, no output schema, and full annotation coverage, the description carries the remaining burden of describing return values, which it does by enumerating id, name, prefix, and created/last-used timestamps. Pagination or ordering behavior is not addressed, a minor gap given the absence of paging parameters.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is nothing to document or mis-document. The description instead spends its words on the shape of the returned records, which is more useful 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?

Names the specific resource (REST API keys) and lists the fields returned, so the agent knows exactly what comes back. The 'REST' qualifier implicitly separates it from the sibling list_mcp_keys, though that contrast is never made 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?

There is no when-to-use guidance and no named alternative. An agent must infer from the sibling list (list_mcp_keys, create_api_key, delete_api_key) which one applies, rather than being routed by the description.

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 cover the safety profile (readOnly, idempotent, non-destructive), so the bar is lower. The description still adds real behavioral context: only active keys are returned, key IDs carry the mcpk_ prefix, and the session's own key is flagged with current=true — none of which is derivable from the annotations.

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

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

Two short sentences, zero filler, with the resource scope stated first and the notable output marker second. 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?

With no output schema and no parameters, the description carries the return-value burden and does partially: it discloses the active-only filter and the current=true marker. It stops short of describing the full shape of a key record, but nothing critical to correct invocation 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 takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a no-param tool is 4. The description correctly avoids inventing parameter semantics.

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

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

The description names the resource precisely ('Active MCP keys') and pins the identifier format (mcpk_…), which distinguishes it from the sibling list_api_keys without opening either schema. It lacks an explicit verb, but the name/title supplies 'List' 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?

No statement of when to call this versus list_api_keys, create_mcp_key, or delete_mcp_key, and no note that only active keys are retrievable here. The usage is inferable from the name but the description offers no 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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive and a closed world, so the safety profile is fully covered by structured data. The description adds content-level information (returned data includes prices and limits), which is modestly useful but not rich 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?

A single sentence, front-loaded with the verb and resource, with every clause earning its place (tiers plus returned fields). No boilerplate or repetition of the title.

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 listing tool, the description is nearly sufficient: it discloses what fields the response contains, which would otherwise be unknown. The remaining omission is routing versus get_plan, which is minor for a trivial catalog call.

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

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

The tool takes zero parameters, so the schema baseline is 4 and there is nothing for the description to compensate for. Schema description coverage is also 100%, leaving no parameter ambiguity.

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 ("Monitly plans") and even enumerates the plan tiers (Essential, Pro, Enterprise), so an agent knows exactly what comes back. It does not explicitly distinguish itself from the sibling get_plan (single plan) or upgrade_plan, which is the only gap.

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

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

There is no when-to-use guidance and no mention of the alternative get_plan for retrieving a single plan's details. Usage is only inferable from the verb "List" and the enumeration of tiers, which is the same implied-usage level as descriptions that score 2.

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 fully covered. The description adds useful context by naming the fields returned (source, latest period, alert status), but says nothing about ordering, total counts, or behavior on an empty watchlist.

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 what is returned, followed by the operational note. No filler; 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 two-parameter read-only list with no output schema, the description covers the payload fields and pagination, which is what an agent needs. Minor gaps remain on ordering and result shape, but nothing misleading is present.

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

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

Schema description coverage is 100% and both parameters already document defaults and bounds, so the schema carries the semantics. 'Paginate with limit/offset' merely restates the schema without adding format or ordering detail.

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

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

States the specific resource ('Datasets the user follows (watchlist)') and even names the returned fields (source, latest period, alert status), which is more specific than the tool name. It does not explicitly contrast itself with add_to_watchlist/remove_from_watchlist, but the 'list' framing makes the distinction 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?

Usage is only implied by the read-style wording; there is no statement of when to call this versus search_catalog/search_datasets or the watchlist mutation siblings. The pagination hint ('Paginate with limit/offset') is operational guidance, not selection 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?

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is fully carried by structured data. The description adds nothing beyond that — it does not say whether the removal is reversible, whether it affects notifications or batch entries, or what happens if the id is not watched.

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

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

One short, front-loaded sentence with no filler or repetition. It is efficient, though its brevity edges toward under-specification rather than optimal conciseness.

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

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

For a single-parameter tool with full schema coverage and a strong annotation set, the description is minimally sufficient. It omits side effects of a destructive unfollow (notification changes, reversibility) that would require more than the annotations provide.

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

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

Schema description coverage is 100% and the single parameter documents its own origin ('Dataset id (main.id) from search_catalog'). 'By id' in the description merely restates what the schema already says, 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 ('Unfollow a dataset') and identifies the key by which removal happens. It does not, however, distinguish itself from the closely related siblings add_to_watchlist, add_watchlist_batch, or list_watchlist.

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 purpose implies when the tool applies (removing a dataset the user no longer wants to track), but there is no explicit when-to-use statement, no prerequisites, and no routing to alternatives such as list_watchlist for verification before removal.

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

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

Annotations already establish read-only, idempotent, non-destructive, closed-world behavior, and the description adds real value beyond them: the search is hybrid (name/code plus embeddings), and critically it returns compact cards rather than series values. It does not disclose pagination or result-shape details, but the safety profile is fully 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?

Three dense sentences, front-loaded with what the tool does, then the mechanism, then the filter affordances, closing with the key distinction from SQL. No filler and nothing 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?

With no output schema, the description compensates by stating the return is compact cards, not series values, which is the key expectation to set. It omits ranking/pagination behavior and any relationship to the search_datasets sibling, leaving a small but real 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 description coverage is 100%, so all four parameters are already documented in the schema. The description restates the optional country and source_name filters without adding syntax, format, or interaction detail beyond the schema, so 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 (Find) and resource (statistical datasets in the catalog) and enumerates the coverage (Eurostat, World Bank, OECD), plus names the SQL anti-pattern it replaces. It does not, however, distinguish itself from the sibling search_datasets, which an agent would reasonably 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?

Gives clear use-context by explicitly routing the agent away from 'SELECT … FROM main ILIKE' toward this tool, and notes the optional filters. It stops short of naming a sibling alternative such as search_datasets or stating when filters should be omitted.

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 the safety profile is fully covered structurally. The description's only added behavioral fact is that it is an alias of search_catalog, meaning identical semantics to that tool; it says nothing about result format, ranking, or limits beyond the annotations.

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

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

Two short sentences, front-loaded with the most decision-relevant fact (the alias relationship) followed by the operation and filters. No padding, no 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?

For a simple 4-parameter search tool with no output schema and full annotation coverage, the description is nearly sufficient. The only gap is return-shape context — the schema mentions 'cards' and a default of 8 with a max of 16, but the description never says what comes back or that results are card-shaped.

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 query, country, source_name and limit are all documented in the schema with examples, making 3 the baseline. The description merely restates three of the four parameters and omits 'limit' entirely, adding no syntax or filtering semantics beyond the schema.

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

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

States a specific verb and resource ('Find statistical datasets') plus the optional filters, and explicitly declares itself an alias of the sibling search_catalog, which tells an agent the two are interchangeable. It stops short of 5 only because it never clarifies how selection between the alias and search_catalog should differ.

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 query-plus-filters framing, so an agent knows this is the keyword-search entry point for datasets. However, there is no explicit when-to-use vs when-not, and no stated relationship (e.g. prefer this over search_catalog) despite a sibling that behaves identically.

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=false, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds mode-level behavior (which fields each action touches) but says nothing about permissions, whether set overwrites existing values, or the Slack webhook prerequisite. Adequate but not rich beyond annotations.

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

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

Two tight sentences, front-loaded with the get/set distinction and then the two set variants. Every clause carries distinct information; nothing is redundant with the schema descriptions.

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

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

With no output schema, the description does sketch what 'get' returns (e-mail/Slack alert settings) and covers both modes plus the dataset-scoped variant. It stops short of detailing the returned structure or the Slack webhook setup requirement, but is sufficient 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?

Schema coverage is 100%, so baseline is 3, but the description adds a genuine relationship not in the schema: dataset_id and dataset_notifications must be combined to toggle alerts for one followed dataset, while email/slack_notifications are account-wide. That pairing constraint is the key invocation detail.

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 specific verbs and resources for both modes: 'get' returns e-mail/Slack alert settings, 'set' changes them. The name says only 'set', but the description immediately disambiguates the dual read/write nature. No sibling tool overlaps with notification settings, so differentiation is not needed.

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 routes the agent between the two modes ('get' returns, 'set' changes) and spells out the two distinct set behaviors (global email/slack toggles vs. per-dataset toggle). No when-not-to-use guidance or prerequisites are given, but the mode-selection context 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?

Annotations already cover the safety profile (non-readOnly, openWorld, non-idempotent, non-destructive). The description adds real operational context beyond them: this call only initiates a checkout session and hands off to the browser, so the agent learns the payment is not completed server-side. It still doesn't warn that repeated calls spawn multiple sessions or what happens to an existing subscription.

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, front-loaded with the action and the returned artifact. Every clause earns its place, including the browser handoff instruction.

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 mutation with no output schema, the description supplies the key return value (checkout_url) and the follow-up step, and annotations cover the safety profile. Minor gaps remain around idempotency/duplicate subscriptions and auth prerequisites.

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 there is a single enum-constrained parameter, so the schema carries the meaning. The description's mention of 'the Pro plan' loosely maps to the plan_id enum, but adds no format, default, or constraint detail beyond the schema — baseline 3.

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

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

States a concrete verb and outcome ('Create a Stripe Checkout session for the Pro plan and return checkout_url'), so an agent knows exactly what this tool produces. It doesn't explicitly contrast itself with siblings like get_plan, list_plans, or get_usage, which is the only thing keeping it from 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?

'Open it in the browser for the user to pay' gives an implied post-call workflow, which is useful. However, it never states when to choose this over get_plan/list_plans or what preconditions (e.g., already on Pro, signed in) make it appropriate, so 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.