gapup-mcp

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a non-mutating, open-world tool. The description adds minor context: inputs are validated server-side and the output is 'audited.' However, it does not disclose behavior like async handling (despite an async parameter), return format, or any side effects. This meets the baseline but adds limited value 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?

The description is short (three sentences) and front-loads the tool's name and a branding phrase. The first sentence includes 'Gapup agent-payable C-suite expertise (CMO),' which is promotional and not directly informative. The reference case is specific to one client and may not generalize. The structure is concise but includes extraneous detail that could be replaced with more useful usage instructions.

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 complex tool with eight parameters, nested objects, and no output schema. The description does not describe what the deliverable contains, how to interpret the result, or how to handle the async parameter (which is present in the schema). Given the complexity, the description is insufficient for an agent to invoke the tool correctly without additional guidance.

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

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

Schema description coverage is only 13%, leaving most parameters undocumented. The description does not explain individual fields; it only says 'send the documented case fields' and provides a reference case that hints at targetAccounts, budget, and tiers. The reference case is not mapped to specific schema properties, so the agent is left without semantic guidance for parameters like company, product, salesTeam, icpCriteria, etc.

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

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

The description identifies the tool as an 'Architecte ABM' (ABM Architect) and states it 'Returns a structured, audited deliverable,' which suggests it produces an account-based marketing plan or strategy. However, the verb 'Returns' is generic and the purpose is not clearly differentiated from siblings like abm_lookalike_account_finder or account_expansion_mapper. The reference case provides some context but does not explicitly define the tool's core 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?

No explicit guidance is given on when to use this tool versus alternatives. The description does not mention exclusions, prerequisites, or contrast with sibling tools. It only implies that this tool is for ABM-related deliverables, but without comparative context the agent cannot determine when this is the right choice.

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, openWorld, and idempotent behavior. The description adds value by disclosing concrete behavioral details: it analyzes public web data including robots.txt and OpenGraph metadata and returns a ranked list. This goes beyond the structured hints without contradicting them.

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 three tightly worded sentences that front-load the audience, output count, method, and necessary inputs. Every sentence contributes useful information with no fluff or repetition.

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

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

For a moderately complex tool with nested objects and an async flag, the description adequately covers purpose, data sources, inputs, and output format. The async behavior is not explained in the description, but the schema documents it. The openWorld and readOnly annotations cover the remaining behavioral expectations, making the description sufficiently complete for tool selection and 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 75% and includes clear descriptions for async, tech_stack_keywords, and top_customer_domains. The description reiterates the main inputs but adds little semantic detail beyond the schema. It does help by framing top_customer_domains and firmographic_filters as the core inputs, but does not fully compensate for undocumented nuances.

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

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

The description uses a specific verb ('discover') and clearly identifies the resource and output: 50 lookalike B2B accounts matching top customers' tech stacks and firmographics. It distinguishes the tool's ABM focus from generic account tools and is not a tautology.

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 clear context ('As a CMO', 'targeted ABM campaigns') and states the required inputs (top customer domains, firmographic filters). However, it does not explicitly mention when not to use this tool or name alternatives among the many sibling tools, 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?

The readOnlyHint: true annotation already covers the safety profile. The description adds that inputs are validated server-side and that the deliverable is 'audited', but it does not mention potential latency, async behavior, or other operational traits beyond what annotations provide.

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 relatively short but includes a lengthy reference case ('Notion B2B Enterprise...') that is not directly instructive and may confuse the agent. The structure mixes purpose with promotional content, preventing it from being a crisp, front-loaded directive.

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 should explain what the structured deliverable contains, but it only says 'audited deliverable'. It does not mention the async option, prerequisites, or how the various input fields (focus, knownTriggers) affect the output. The tool is complex enough to warrant more completion.

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

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

Schema description coverage is only 20%, and the description does not compensate. It merely says 'send the documented case fields' without explaining the semantics of key fields like company.arrTotalEur, accounts.usageScore, or ownership.averageQuotaPerAeEur. This is insufficient for a complex nested 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 identifies the tool as mapping account expansion ('Mapping d'expansion comptes') and mentions its output as a structured, audited deliverable. However, it does not explicitly distinguish it from sibling tools like upsell_hunter or cross_sell_reco, and the reference case adds some ambiguity.

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 a C-suite/strategic context ('CRO expertise') and notes server-side validation, but it does not state when to use this tool over alternatives such as churn_defender or renewal_optimizer, nor does it give exclusions.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds that inputs are validated server-side and provides a reference case, but doesn't disclose return format (beyond 'structured deliverable'), pagination, or authentication needs. It doesn't contradict 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?

The description is three sentences, but includes marketing fluff ('Gapup agent-payable C-suite expertise') and repeats the title. The reference case and validation note are useful. It could be more concise by removing the tagline.

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 has 8 parameters including nested objects, and no output schema. The description offers only a vague 'structured, audited deliverable' and a single reference case, without specifying required fields, how to use the async parameter, or what the deliverable contains. This is inadequate for a tool of this complexity.

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

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

Schema description coverage is only 13% (only the async parameter has a description). The description says 'send the documented case fields' but does not explain any specific parameters, such as company, ambitions, availableResources, or horizon. With low coverage, the description fails to compensate.

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

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

The description starts with the title 'Plan d\'action ESG' and states it returns a structured, audited deliverable, with a reference case of an ESG plan. However, it lacks a clear verb like 'create' or 'generate' and doesn't explicitly differentiate from sibling ESG tools. The purpose is inferable but vague.

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

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

The description provides no guidance on when to use this tool versus alternatives like sustainability_report or esg_audit_multi. It doesn't mention any prerequisites, use cases, or exclusions. The only context is a marketing tagline and validation note.

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, open-world, and idempotent behavior, lowering the burden. The description adds meaningful behavioral context: the async requirement to avoid timeouts, the fact that it returns status/warnings/source references, and that it is a risk assessment tool. No contradictions with annotations, and the added details enhance transparency beyond 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?

The description is three sentences with no filler. The first sentence states the core purpose, the second adds audience and outputs, and the third gives a critical operational requirement. Every sentence earns its place, and the structure is front-loaded with the primary function.

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 presence of an output schema and strong annotations, the description does not need to explain every return value, but it still mentions status, warnings, and source references, which is helpful. It covers the tool's purpose, target audience, inputs, async behavior, and output highlights. It could be slightly more explicit about how to use the results or edge cases, but it is largely complete for its complexity.

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

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

Schema description coverage is 100%, so parameters are already well-documented. The description adds value by explaining that the tool 'accepts model outputs or decision boundaries' (clarifying modelOutput) and explicitly notes the async requirement, which gives pragmatic meaning to the async parameter. This exceeds the baseline but does not fully elaborate on edge-case 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 a specific verb+resource: 'evaluates AI model resilience against adversarial inputs' and further distinguishes itself by referencing NIST AI RMF red-teaming protocols, structured risk scores, failure modes, and adversarial examples. It effectively differentiates from sibling tools like jailbreak_attempt_detector or model_behavior_drift_monitor by emphasizing proactive stress-testing and risk assessment.

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 for use: it is designed for security and compliance personas and accepts model outputs or decision boundaries, implying when to invoke it. It also gives a concrete operational guideline ('Requires async:true to avoid timeout errors'). However, it does not explicitly name alternatives or state when not to use it, so it stops short of exhaustive 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 and idempotentHint, so no contradiction exists. The description adds useful context about the data source (Common Crawl) and expected outputs, but does not disclose potential latency, why async might be needed, or error handling behavior. With annotations covering the read-only and idempotency aspects, 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 concise, with three front-loaded sentences covering purpose, audience, inputs, and outputs. The appended keyword list is slightly redundant but not harmful. It is well-structured and within a reasonable length.

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 moderately complex tool with an output schema, the description covers purpose, data source, inputs, and outputs. It lacks guidance on when to use the async parameter, but that is documented in the schema. Overall it gives enough context to select and begin using the tool without major 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 75%, and the schema already documents threshold, async, date_range, and affiliate_network. The description restates that inputs are 'affiliate network name and date range' but adds no additional meaning for threshold or async. It meets the baseline but does not compensate for the remaining 25% gap.

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

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

The description uses a specific verb ('Analyzes') plus a specific resource ('affiliate clickstream data from Common Crawl') and a clear purpose ('flag potential fraud patterns'). It lists concrete patterns (duplicate IPs, rapid clicks, device spoofing) and distinguishes itself from generic siblings like fraud_detector or x402_payment_fraud_detector by specifying the affiliate domain and data source.

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 establishes when to use it: for CMOs to validate affiliate traffic quality and prevent budget waste. This provides strong contextual guidance. However, it does not explicitly name exclusions or alternatives, 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?

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds meaningful behavioral context: external data sources (WITS/UNCTAD), structured output content (risk assessment, compliance gaps, recommendations), and timeout/asynchronous behavior ('Pass async:true to avoid timeout'). This goes well beyond the structured 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?

Four sentences, each earning its place: persona/action/scope, inputs/outputs, return value details, and async guidance. Front-loaded with the core purpose and no filler or redundancy.

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

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

The description is strong overall, covering purpose, data sources, inputs, output categories, and timeout behavior; the output schema fills in detailed return structure. Minor gap: it does not clarify that hs_code is optional (only origin/destination are required) and leaves async job polling details to the 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?

Schema description coverage is 100%, so the schema already documents all five parameters. The description mostly reiterates 'origin/destination countries and product HS codes' and 'Pass async:true to avoid timeout,' adding little beyond the schema. It does not clarify optionality of hs_code, so baseline 3 is appropriate.

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

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

The description opens with a specific verb 'analyze' and precise resource: 'non-tariff trade barriers (NTBs) across African trade corridors' using WITS and UNCTAD STAT data. The 'non-tariff' qualifier distinguishes it from tariff- and preference-focused sibling tools like africa_trade_preference_optimizer and tariff_arbitrage_finder. It also clearly lists inputs and expected outputs.

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 establishes clear usage context: use when analyzing NTBs for African corridors with origin/destination countries and HS codes. It does not explicitly name alternatives or exclusions, but the scope is unambiguous enough to differentiate from sibling tools, and the async guidance adds practical invocation context.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, and the description adds complementary context by mentioning data sources (WITS, CDP) and the output breakdown. The async:true guidance to avoid timeout is a valuable behavioral detail not present in annotations. No contradictions found.

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 at three sentences, covering purpose, input, use case, and async tip without redundancy. The opening 'As a COO' is minor but not distracting, and the structure is front-loaded with the core function.

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 rater with an output schema and rich annotations, the description covers the essential aspects: data sources, output dimensions, use cases, and performance guidance. It doesn't explicitly state the geographic scope boundary, but that is implied by the tool name and target audience.

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 the baseline is 3. The description adds practical meaning for institutionName ('name or identifier') and explains async's purpose ('avoid timeout'), going slightly beyond the schema. Year and countryCode are clear from the schema alone, so the description doesn't need to repeat them.

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 specifies the tool's function: evaluating ESG compliance of African trade finance providers using WITS and CDP data, and returning a breakdown across environmental, social, and governance dimensions. This distinguishes it from sibling ESG tools by focusing on a specific target (African trade finance) and methodology.

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: 'Ideal for due diligence on trade partners or portfolio risk assessment.' It does not explicitly name alternative tools or exclusion criteria, but the use case is specific enough for an agent to make an informed choice.

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 tool read-only, open-world, and idempotent. The description adds valuable context: data sources (WITS/OECD), structured output components, and a critical warning that async:true is required to avoid x402 timeout. This goes beyond the annotation hints and warns about a real failure mode.

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 three sentences plus a brief async warning, all of which contribute meaning. It front-loads the core purpose and lists concrete outputs. No redundant or filler content.

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

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

Given that an output schema exists and the annotations provide safety semantics, the description covers purpose, data sources, output types, and a critical operational requirement. It is sufficient for an agent to select and invoke the tool correctly. The only minor gap is sibling differentiation, which is assessed in purpose/usage dimensions.

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 100% parameter description coverage, so the baseline is 3. The description does not add meaning to individual parameters beyond what the schema already provides; it only references async in the operational note. Thus, no significant extra 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 clearly identifies the tool's function: analyzing AGOA and EBA trade preference arbitrage opportunities. It specifies the target user (COOs), data sources (WITS/OECD), and output categories (duty savings, market access, compliance). However, it does not explicitly mention how it differs from closely related siblings like africa_trade_preference_optimizer or agoa_eba_intelligence.

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 export strategy evaluation by COOs, but does not state when to choose this over alternatives. There is no explicit 'use this when' or 'for that, use X instead' guidance. The async note provides operational usage, but not comparative 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, openWorldHint, and idempotentHint. The description adds value by disclosing data sources (UN Comtrade, WCO tariff schedules, AU trade rules) and output types, providing useful context on expected results and scope. It doesn't mention side effects or limitations, but with strong annotations, this is sufficient.

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 front-loaded: first sentence states purpose, second describes inputs/outputs, third cites data sources, fourth lists use cases, followed by keywords. Every sentence serves a clear function with no fluff or redundancy.

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

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

The description covers purpose, inputs, outputs, data sources, and target use cases. The presence of an output schema and thorough parameter descriptions offsets the need for return-value details. Minor omissions like async behavior are already addressed in the schema, so the description is sufficiently complete for tool selection.

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 detailed descriptions for all six parameters, including examples for hsCode and country codes. The description's mention of 'origin country, destination country, and HS code' merely echoes the schema without adding syntax, constraints, or behavior. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly identifies the tool as an analyzer of AGOA/EBA duty savings with HS code-level trade route optimization, specifying distinct outputs (duty savings estimates, optimal trade routes, preference utilization recommendations). This specific combination differentiates it from siblings like 'tariff_arbitrage_finder' or 'agoa_eba_intelligence' by emphasizing route optimization and actionable recommendations.

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 states 'Ideal for export market evaluation, supply chain optimization, and trade agreement compliance analysis,' giving clear use context. However, it does not explicitly mention when not to use this tool or name any alternatives, which keeps it from a perfect score.

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 tool read-only and open-world. The description adds valuable behavioral context by listing data sources (AGOA.info, EU EBA, etc.) and emphasizing the tool's encoded country coverage, which informs the agent about data provenance and scope. No contradictions with 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?

The description is three sentences long, front-loaded with the primary purpose, and includes only high-value information: the four modes, coverage differentiator, and data sources. Every sentence earns its place, with 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 multi-mode tool with five parameters and no output schema, the description is thorough. It covers all modes, indicates the Africa→US/EU scope, highlights unique country coverage, and cites sources. The schema handles parameter requirements, so the description is complete enough for an agent to select and invoke the tool 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 input schema provides 100% coverage with descriptions and examples for all five parameters, including enum options and required conditions. The description itself does not add significant parameter-level details beyond reiterating the tool's functionalities, so the baseline of 3 is appropriate.

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

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

The description uses specific verbs (vérifie, identifie, fournit) and clearly defines the tool's resource: AGOA/EBA/GSP preferential trade intelligence for Africa–US/EU trade. It distinguishes itself from siblings by its unique coverage of 39 AGOA countries and 47 EBA LDCs, making the purpose 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 description provides clear usage context by enumerating four modes (country eligibility, product eligibility, trade opportunities, compliance) and the geographic scope. It does not explicitly name alternative tools or state when not to use it, but the context is strong enough for an agent to infer appropriate use cases.

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?

Adds critical behavioral detail beyond the annotations by noting that async:true is REQUIRED to avoid x402 timeout, and by describing the structured outputs. The annotations already declare readOnly, openWorld, and idempotent hints, so the description complements rather than repeats them. No contradiction is present.

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 front-loads the purpose, then inputs/outputs, then operational note and keywords. The keywords section is slightly extraneous but the core sentences are efficient and non-repetitive.

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 presence of an output schema, the description adequately covers purpose, inputs, outputs, and the critical async timeout behavior. It could mention interactions with sibling tools or more specific severity thresholds, but it is sufficient for an agent to select and invoke the tool correctly in most scenarios.

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

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

Schema description coverage is only 17%, so the description must compensate, but it only lists a subset of inputs (severity, ai_system_type, affected_stakeholders) and omits the required incident_type. It explains the async parameter but provides no additional context for the parameter meanings beyond their names, leaving a significant gap for a required parameter.

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

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

The description clearly states the tool generates EU AI Act incident response playbooks with regulator notification templates, specifying the verb, resource, and target audience. It distinguishes itself from sibling tools like incident_response_evidence_collector and ai_act_sandbox by focusing specifically on playbook generation for formal EU notification.

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 an explicit use case: 'Essential for high-risk AI system breaches requiring formal EU notification.' Also gives operational guidance to pass async:true to avoid timeout. However, it does not explicitly name alternatives or when not to use the tool, so it misses the 'when-not/alternatives' component for 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=true, idempotentHint=true, and openWorldHint=true. The description adds useful behavioral context beyond annotations by specifying the data sources (EUR-Lex, OECD) and the nature of the return (warnings, citations, recommendations). It does not detail any side effects, but for a read-only simulator this is sufficient.

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

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

The description is two sentences, front-loaded with the core purpose, and every sentence adds value. It avoids redundancy with the schema and 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?

The tool has an output schema (per context signals), so return values are already structured. The description fully covers the tool's purpose, inputs, outputs (feedback type), sources, and target audience. Nothing essential is missing for a simulation tool with readOnly and idempotent 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?

Schema description coverage is 100%, so the schema already documents all six parameters with clear descriptions. The description broadly mentions 'AI system descriptions, intended use cases, and technical specifications' which maps to the main parameters but adds no syntax or format details beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states a specific verb ('simulating') and resource ('EU AI Act regulatory sandbox submissions'), and distinguishes itself from sibling tools like ai_act_incident_response and ai_act_training_data_audit by focusing on sandbox submissions. It also names the deliverable (structured feedback on compliance, risk levels, documentation).

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—for simulating regulatory sandbox submissions and obtaining compliance feedback for legal teams and AI developers. However, it does not explicitly state when not to use it or name alternatives, which would warrant 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, openWorldHint, and idempotentHint, so the safety profile is covered. The description adds useful behavioral context by describing the output structure and the async option ('Pass async:true to avoid timeout'), which goes beyond the schema and 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?

The description is three sentences, front-loading the main purpose, then efficiently listing inputs, outputs, use case, and async tip. Every sentence adds value without 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 has an output schema, so return values are covered structurally. The description still provides essential context: inputs, outputs, use case, and async behavior. No critical information is missing for selection and invocation.

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

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

Schema description coverage is 50%, meaning two parameters (risk_threshold and include_bias_metrics) lack schema descriptions. The description mentions 'optional risk thresholds' for risk_threshold and 'dataset identifier (Hugging Face ID or URL)' for dataset_id, but it doesn't explain include_bias_metrics at all. This partially compensates but leaves one parameter semantically undocumented.

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

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

The description clearly states the tool audits AI training datasets for EU AI Act compliance, with bias detection and regulatory risk assessment. It specifies the primary resource (training datasets) and distinct outputs (compliance score, bias metrics, regulatory warnings, source references), setting it apart from sibling tools like ai_act_incident_response.

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 explicitly notes the tool is 'Ideal for pre-deployment risk evaluation', giving a clear use case. However, it does not mention when not to use it or suggest alternative tools for other compliance tasks, so it lacks direct exclusions/alternatives but provides enough context.

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

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

Beyond annotations (readOnlyHint=true, destructiveHint=false), the description discloses detailed async behavior: returns in <300ms, job_id-based polling, ~90s eta, 7-day cache, and webhook callback support. It also lists the exact report structure (7 deliverables) and includes a disclaimer that it is not a substitute for professional legal advice. This is highly transparent about what the tool does and its limitations.

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 dense and information-rich, using a numbered list for output components and clear, actionable sentences. It is longer than typical but every sentence adds essential operational detail (timing, caching, webhook, disclaimer). Minor redundancy such as 'Faster + lighter' and mixing disclaimer at the end does not significantly detract, but a slightly more structured layout would earn a 5.

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 fully covers the async workflow, including submission, polling, result retrieval, webhook alternative, caching, and expected output format. It also clarifies the legal scope and includes a disclaimer. Given the tool's complexity, this description leaves no critical gaps for an agent to invoke it correctly. The output schema is not needed because the description enumerates the report components.

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 100% description coverage for all 7 parameters, so the schema already provides the needed semantics. The description adds contextual value by mentioning that classification is based on Annex III and Article 5, but it does not elaborate on individual parameter meanings or constraints beyond what the schema already states. With full schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the tool audits the EU AI Act, classifies AI systems into risk tiers, and produces a comprehensive report with seven components. It specifies the exact regulation (Règlement UE 2024/1689) and the classification logic (Annexe III, Article 5). It also distinguishes itself from sibling tools by explicitly naming the polling tool (ai_governance_full_report_result) and webhook management (webhooks_manage), clarifying its role as the async submission endpoint.

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 explicit usage instructions: it returns a job_id immediately, tells the agent to poll with ai_governance_full_report_result(job_id) after eta_seconds (~90s), and offers an alternative to register a webhook via webhooks_manage. It also notes caching for identical inputs ('Cache 7 jours') and states the webhook path is 'Faster + lighter', guiding the agent to choose the best invocation pattern.

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 and idempotent behavior, so the bar is lower. The description goes further by disclosing status lifecycle, 24h TTL for job_id, and a summary of the completed report contents (risk_tier, compliance checklist, ISO 42001 alignment, etc.). This adds meaningful operational context 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?

The description is a single dense sentence but every clause conveys useful information—statuses, TTL, report fields, timing. It is front-loaded with the action ('Poll the result') and avoids filler words. While it could be split into two sentences, it is efficient and well-structured.

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 polling tool, the description covers the full lifecycle: when to call, what each status means, what happens on expiry, and the key output fields. Since an output schema exists, it doesn't need to fully document return types, but the description provides a strong overview of the expected result. The inclusion of deadlines and recommendation priorities shows thorough coverage.

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 description for job_id already includes the prefix (aigfr_) and origin from ai_governance_full_report_async, so coverage is 100%. The tool description adds no additional parameter-level semantics beyond what the schema provides, but that is not required given the high coverage. 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?

The description uses the specific verb 'Poll' and clearly identifies the resource as the result of ai_governance_full_report_async. It explicitly names the sibling async tool, distinguishing it from other result tools like competitive_deep_dive_result. This is a clear, non-tautological statement of 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 explicitly instructs the agent to call this after the eta_seconds hint returned by ai_governance_full_report_async (~90s). It also explains when each status (pending, completed, failed, not_found) appears, giving the agent criteria to decide whether to keep polling or abandon. This is strong usage guidance with a specific timing recommendation.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description is consistent. It adds minor context (server-side validation, audited deliverable) but does not disclose other behavior such as async processing, rate limits, or what 'audited' entails beyond the schema's async parameter.

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

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

Three sentences, but the phrase 'Gapup agent-payable C-suite expertise (RISK)' is cryptic and wastes the agent's attention. The description is not overly long, but not 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?

With nested objects, no output schema, and only 20% schema coverage, the description leaves major gaps: the nature of the deliverable, how inputs map to output, and how this relates to other AI governance tools. It is insufficient for an agent to confidently invoke the 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 only 20% (only the async parameter is described). The description says 'send the documented case fields' but fails to enumerate or explain company, aiUseCases, targetFrameworks, or focus. This does not compensate for the low 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 states it 'Returns a structured, audited deliverable' for AI governance pilotage, but the verb is implicit and the exact nature of the deliverable is vague. It mentions a reference case but does not clearly differentiate from sibling tools like ai_governance_full_report_async.

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

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

No explicit guidance on when to use this tool versus alternatives. The reference case (TalentScope SAS, EU AI Act high-risk) implies a context, but there are no when-to-use or when-not-to-use instructions, and no mention of sibling governance tools.

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

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

The description adds behavioral context beyond the annotations by stating inputs are validated server-side and the output is a 'structured, audited deliverable'. However, it doesn't disclose what happens on validation failure, rate limits, or specific output structure. The readOnlyHint annotation already covers safety, so 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 concise at three sentences and front-loaded with the tool's purpose. The 'Gapup agent-payable C-suite expertise (COO)' phrase is marketing fluff and the Buffer reference case is illustrative but non-essential. Overall, it is efficient without being overly terse.

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

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

For a tool with complex nested inputs and no output schema, the description is incomplete. It mentions a structured deliverable but doesn't describe its contents, how to interpret results, or the required fields beyond a vague reference to 'case fields'. The Buffer case gives a concrete example but doesn't suffice for operational completeness.

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

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

With schema description coverage at only 20%, the description needed to compensate for the many undocumented parameters (company, signals, employees, focus). It merely says 'send the documented case fields' without explaining what fields are expected or how they map to the schema. This adds minimal value 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 states the tool is an 'anti-attrition shield' and references 'detection des at-risk parmi 80 FTEs', clearly indicating it detects employees at risk of leaving. However, the main verb is 'Returns' rather than a direct action verb like 'detect' or 'assess', and it doesn't differentiate from sibling tools like churn_defender or enps_auto.

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

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

No guidance is provided on when to use this tool versus alternatives. The only directive is 'send the documented case fields', which is about input submission, not usage context. There are no exclusions or comparisons to related tools.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds valuable behavioral details: 24h cache, no API key required, and the crucial limitation that most awards are confidential and private awards are inaccessible. These disclosures go beyond what annotations alone provide.

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 longer than minimal but well-structured with clear headers, bullet points, and a note section. Every sentence contributes useful information, including audience, modes, limitations, and operational details. It is front-loaded with purpose and remains readable.

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 complexity (three modes, multiple institutions, date filters, output schema), the description covers the key aspects: modes explained, data sources, confidentiality caveat, cache, and auth. It does not describe pagination or result formats, but an output schema exists and the core usage is clear.

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. The description adds meaning by detailing each mode's expected query behavior (e.g., 'party_lookup — find awards by party name (searches 20 landmark public awards + JusMundi best-effort)') and listing what clause_check audits. This enriches the schema's generic descriptions.

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's purpose: 'Commercial arbitration intelligence' and enumerates three distinct modes (party_lookup, institution_index, clause_check) with specific actions. It names the covered institutions and differentiates itself from potential sibling tools by specifying its unique scope and capabilities.

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 for intended users (litigation lawyers, M&A teams, etc.) and describes each mode explicitly. It also states an important limitation: 'Private awards are not accessible.' However, it does not explicitly name alternative tools or say 'use this instead of X,' 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 readOnly and openWorld. The description adds that returns a structured, audited deliverable and gives reference example, but does not disclose performance characteristics, rate limits, or other behavioral details. With annotations providing safety profile, this is adequate but not exceptional.

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

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

The description is a long, unstructured paragraph with promotional elements like 'Gapup agent-payable C-suite expertise' and a reference case that doesn't aid tool selection. It would benefit from a concise summary and structured capabilities 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?

Without an output schema, the description fails to explain the output structure beyond 'structured, audited deliverable'. It also doesn't clarify the meaning of exclusions/scope_cidrs or the async workflow, making it incomplete for a 6-parameter 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 low (only async has a description). The description implicitly covers domain and include_email_surface via examples, but leaves focus, exclusions, scope_cidrs, and async unexplained. This is insufficient compensation for the low 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 clearly states this tool monitors attack surface of a domain, answering specific security questions (CVEs, exposed services, WAF, subdomains, ports, SSL/TLS, email phishing). It is specific to attack surface monitoring, though it doesn't explicitly distinguish itself from sibling tools like cve_security_lookup or email_domain_health_check.

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?

Example user queries provide clear context for when to use the tool: for ASM assessments, CISO reports, email phishing risk, and M&A due diligence. However, it doesn't mention exclusions or when not to use this tool versus 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?

The annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds a small behavioral note: 'Inputs are validated server-side,' implying invalid inputs are rejected. The reference case gives a concrete example of the output shape (score, findings, checklist), which is useful context. However, it does not describe synchronous/asynchronous behavior beyond the schema's async param, nor does it detail the deliverable's full contents.

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, with the core purpose front-loaded. The reference case is a bit cluttered but adds concrete output examples. It avoids unnecessary filler, though the French-English mix and specific numbers could be clearer. Overall, it earns its place with minimal waste.

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

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

The tool has 6 parameters, 5 required, nested objects, and no output schema, making it moderately complex. The description provides only a fragmentary picture: what it returns (structured deliverable) and a reference case, but fails to explain required input groups (company, financials, audit, etc.), their purpose, or any expected output structure beyond the example. The reference case gives some context but is not a substitute for describing the tool's overall 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?

With only 17% schema description coverage (only async has a description), the description was expected to compensate but does not. It never mentions company, audit, financials, knownIssues, or systems. The phrase 'send the documented case fields' is tautological and offers no parameter-level guidance. The agent must infer all semantics from parameter names and schema constraints, which is inadequate.

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 it is an accounting pre-audit ('Pré-audit comptable') that returns a structured deliverable, which clearly identifies the resource and action. It distinguishes itself from audit-related siblings by its accounting/CFO focus and reference case (Spendesk readiness 74/100, 4 critical findings, 18-doc checklist). However, it lacks an explicit verb like 'assesses readiness' and relies on the name and French jargon.

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

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

There is no explicit guidance on when to use this tool versus alternatives. It mentions 'send the documented case fields' but does not explain use cases, prerequisites, or exclusions. Sibling audit tools exist (e.g., esg_audit_multi, privacy_compliance_audit), but no differentiation is provided. The 'Gapup agent-payable C-suite expertise' hint is too vague to count as context.

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

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

Annotations already indicate read-only, idempotent behavior. The description adds context by explaining it uses data from World Bank and ECB SDW for benchmarks and generates negotiation levers. It does not contradict annotations since it describes analysis without 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 four sentences with a clear front-loaded purpose and a keyword list. It is efficiently written, though the keyword list is somewhat redundant.

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

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

Given the annotations (read-only, idempotent) and the output schema, the description sufficiently explains the tool's inputs, analysis sources, and outcome. It covers the essential context for selecting and invoking the 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?

The input schema provides 100% coverage with descriptions for all parameters, including required fields and units. The description references fee types that map to schema parameters but does not add significant 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 the tool's function: analyzing bank fee structures and providing negotiation recommendations. It identifies specific fee types (account maintenance, wire transfers, credit lines) and output (benchmark comparisons, cost reduction levers), distinguishing it from broader treasury tools.

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

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

The description provides context for use ('CFO-focused', 'Ideal for optimizing treasury operations'), implying it is for negotiating bank fees. However, it does not explicitly mention when not to use it or name alternative tools, so it lacks exclusion guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, establishing safety and flexibility. The description adds some context with 'Inputs are validated server-side' and 'Returns a structured, audited deliverable,' which is useful but minimal beyond what annotations convey.

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 cluttered with marketing-like content ('Gapup agent-payable C-suite expertise' and a case study) that does not aid functional understanding. It repeats the title and lacks a clear, front-loaded purpose, making it inefficient for an agent 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?

This tool has complex nested inputs, no output schema, and low schema coverage, yet the description fails to explain the deliverable's content, required case fields, or expected output format. The generic 'structured, audited deliverable' is insufficient for an agent to use the tool 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?

Only 20% of parameters have schema descriptions (async only), and the description does not compensate. It says 'send the documented case fields' but gives no details on competitor, dealContext, ourOffer, or knownWeaknesses, leaving the agent without essential parameter meaning.

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

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

The description is vague; it repeats the title 'Fiche de combat live' and mentions 'C-suite expertise (CRO)' without a clear verb or resource. The reference case hints at competitive battle cards, but the actual function (e.g., 'generates a battle card') is never explicitly 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?

No guidance is provided on when to use this tool versus sibling tools like battle_plan or competitive_deep_dive. The description only includes a reference case and input validation note, with no context for selection or 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 readOnlyHint and openWorldHint, so the read-only nature is covered. The description adds that inputs are validated server-side and the deliverable is 'structured, audited', which is some behavioral context. However, it does not disclose processing time, cost, or what the audit entails, so it does not go far 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?

The description is concise at three sentences, with no redundant prose. The reference case adds a concrete example but could be considered extraneous. It is well-structured and front-loaded with the purpose, though the French phrasing might reduce clarity for non-French speakers.

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 11 parameters, no output schema, and sparse schema descriptions, the description is far from complete. It does not explain what the deliverable contains, how the inputs are used, or what the return format is. The reference case is helpful but insufficient to guide an agent on invocation and result interpretation.

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

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

Schema description coverage is only 9%, with only the 'async' parameter described. The description does not explain any of the 10 required parameters (e.g., arrCurrent, topChannels, icpDescription). The phrase 'documented case fields' is opaque and does not compensate for the lack of schema descriptions. This is a significant gap for a tool with 11 parameters.

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

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

The description clearly identifies the tool as creating a marketing battle plan deliverable, with a specific audience (CMO) and a reference example. However, it does not explicitly distinguish it from sibling tools like positioning_strategist or growth_path_architect, so purpose is clear but differentiation is weak.

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 versus alternatives. The phrase 'send the documented case fields' is an instruction for invocation, not a usage guideline. There is no mention of exclusions, prerequisites, or suitable scenarios beyond the implied need for a marketing battle plan.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description adds the data source (HuggingFace leaderboard) and input flexibility (model identifiers or output samples) but no additional behavioral traits like side effects or rate limits. It adds some value, consistent with annotations, so 3 is appropriate.

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 well-structured sentences. The first states purpose and method, the second covers audience, specific bias types, inputs, and outputs. Every sentence earns its place with no wasted words.

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 a rich schema (100% coverage, output schema present) and helpful annotations, the description provides enough context: purpose, data source, input types, and output summary. It doesn't include explicit alternatives but that's covered under usage guidelines. Overall sufficient for agent selection and invocation.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add significant parameter-level semantics beyond what's in the schema; it mentions 'accepts model identifiers or output samples' but that's already covered by the schema's param descriptions.

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 ('tracks') and resource ('bias amplification in LLM outputs'), plus the method ('analyzing fairness metrics from HuggingFace's model leaderboard'). It distinguishes from siblings like model_behavior_drift_monitor by focusing on bias amplification 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?

It provides clear context: 'Designed for risk assessment personas to detect and quantify demographic, gender, or racial bias amplification in generated text.' This implies usage for risk assessment, but it doesn't explicitly name alternatives or when-not-to-use, so it's a 4.

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, openWorldHint=true, so the tool's safety profile is clear. The description adds behavioral context by noting it 'analyzes covenant text against regulatory benchmarks' and 'receive structured compliance insights with source references,' which goes beyond the annotations to describe inputs and outputs.

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 three sentences with efficient front-loading: purpose first ('quickly assess'), then details on what it analyzes and delivers, then use cases. No redundant phrases or filler, making it appropriately sized and well-structured.

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 purpose, use cases, and output type ('structured compliance insights with source references'), and an output schema exists to document return values. It does not explicitly address limitations, prerequisites, or differentiation from all overlapping siblings, but overall it is complete enough for a read-only analysis 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 the parameter meanings are fully documented in the schema. The description itself adds little parameter-specific information beyond generic 'Input bond covenant details,' but the baseline of 3 applies because the schema does the heavy lifting.

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

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

The description clearly states the tool's function: 'assess whether your bond covenants meet ESG compliance standards set by BIS and ECB.' It specifies the resource (bond covenants), the action (assess compliance), and distinct focus areas (carbon emissions, governance, social impact), distinguishing it from sibling tools like bond_covenant_monitor or syndicated_loan_covenant_breach_alert.

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 explicitly names use cases: 'pre-issuance due diligence or ongoing monitoring of existing bond portfolios.' It does not mention alternatives or exclusions, but the 'Ideal for' phrasing implies typical contexts without explicitly naming when not to use the tool.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, establishing the safety profile. The description adds valuable context about real-time data usage and output (compliance status, key metrics, SEC filing references) that goes beyond the annotations, without contradicting them.

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 three sentences plus keywords, front-loading the primary purpose in the first sentence. It is efficient and each sentence earns its place, though the 'As a CFO' persona is slightly unnecessary and the keyword list, while helpful for search, could be considered redundant.

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

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

Given the existence of an output schema and annotations, the description sufficiently covers inputs, outputs, and use cases. It explains the input (ticker, optional thresholds), the output (compliance status, metrics, references), and the context (debt management, regulatory compliance), making it complete enough for a tool with moderate complexity.

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

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

Schema has 67% coverage (async and ticker have descriptions, covenantThresholds object lacks a top-level description). The description compensates by explaining the input: 'Input a company's ticker symbol and optional covenant thresholds', and clarifies the purpose of thresholds in assessing compliance. It adds meaning beyond the raw schema for the main functional parameters.

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

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

The description clearly states the tool's function: monitor bond covenant compliance by analyzing leverage and interest coverage ratios with real-time data. It specifies the resource (bond covenants) and the action (monitor/analyze), which distinguishes it from generic financial analysis tools, though it doesn't explicitly name sibling tools like bond_covenant_esg_compliance_checker.

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 clear usage context: 'As a CFO', 'Ideal for proactive debt management and regulatory compliance tracking'. This indicates when to use it (covenant monitoring for financial oversight) but does not explicitly mention alternatives or exclusions, which would raise it to 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=true, so the safety profile is known. The description adds some behavioral context with 'Inputs are validated server-side' and 'Reference case: Stripe Series A 2012,' but it does not disclose output format, cost, or delivery behavior. It provides modest value 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?

The description is short at three sentences, but the phrase 'Gapup agent-payable C-suite expertise (CFO)' is promotional and adds little functional value. The structure is front-loaded but not every sentence carries essential 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?

Given the tool's complexity (nested objects, multiple enums) and lack of output schema, the description is insufficient. It does not explain what the 'structured, audited deliverable' contains, how to handle async responses, or how the Stripe reference applies. The description is too vague for an agent to confidently select and invoke this 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 low (25%), and the description does not compensate. It only says 'send the documented case fields,' without explaining the meaning or expected format of company, raise, keyMetrics, or async. The parameter names are self-explanatory, but the description adds no semantic depth 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 says 'Business Plan narratif' and 'Returns a structured, audited deliverable,' but it never explicitly states that the tool generates a business plan narrative. It restates the tool's name and lacks a clear verb like 'generates' or 'creates,' making it vague and not distinguishing it from sibling tools such as ftg_business_plan.

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

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

The description provides no guidance on when to use this tool versus alternatives. The only operational note is 'Inputs are validated server-side,' which is about call mechanics, not usage context. No exclusions, alternative references, or use-case scenarios are given.

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

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

Annotations already provide readOnlyHint and openWorldHint, and the description adds that it returns an audited deliverable and validates inputs server-side. This adds some context beyond the annotations, but it does not describe return format, async behavior, or error handling. Given the annotations cover the safety profile, a 3 is appropriate.

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 front-loaded with the tool's role. It is two sentences, each providing some value (deliverable type and validation note). However, it is somewhat vague and could be more concrete without becoming verbose.

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 has a complex nested schema with no output schema and low parameter documentation. The description is too brief to guide an agent on how to construct inputs or interpret results. It does not explain the deliverable structure or provide examples, making it inadequate for a tool of this complexity.

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

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

Schema description coverage is very low (only async has a description). The description says 'send the documented case fields' but does not explain the three required nested objects (founder, brand, target) or their properties. It fails to compensate for the lack of schema descriptions, leaving the agent to guess what fields are expected.

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 title 'Architecte de marque' and description 'Returns a structured, audited deliverable' clearly indicate the tool produces a brand strategy/identity deliverable. The reference to Pennylane's brand identity further clarifies the domain. However, the verb is implicit rather than explicit, and it does not distinguish from sibling brand tools like brand_equity_voice_share_calculator.

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

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

The description gives no guidance on when to use this tool versus alternatives. It only mentions server-side validation and 'send the documented case fields,' with no prerequisites, exclusions, or comparison to other brand-related tools. This leaves the agent without clear selection criteria.

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

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

Annotations already declare read-only and idempotent hints, so the burden is lighter. The description adds valuable behavioral details: the scale of data analyzed, the potential for timeout, and the async workaround. No contradiction with 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?

Three well-structured sentences. The main function is front-loaded, and each sentence adds value: data sources, inputs/outputs, use cases, and a practical async tip. No fluff or repetition.

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

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

Given the tool's complexity, the presence of an output schema, and annotations, the description covers the main purpose, inputs, outputs, data sources, and a performance consideration. It lacks explicit when-not-to-use guidance and doesn't mention include_forums, but overall it is sufficiently complete for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is only 20% (only async has a description). The description lists key inputs (brand, competitors, time range) and provides some context for their role in the calculation, but it does not detail include_forums or the exact format of time_range. It partially compensates for low schema coverage but not fully.

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 calculates brand equity voice share, specifies the data sources (500K+ news articles and forums from Common Crawl and Wayback Machine), target audience (CMOs), and outputs. This distinguishes it from sibling tools like sentiment_news_pulse or competitor_intel.

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 identifies ideal use cases: competitive benchmarking and brand visibility tracking. It also advises using async:true to avoid timeouts. It does not mention alternatives or exclusion criteria, 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=true and openWorldHint=true, covering the safety profile. The description adds that it returns a 'structured, audited deliverable' and that inputs are validated server-side, which provides useful behavioral context. However, it does not discuss async behavior (the async parameter exists) or other operational details, so it remains moderate.

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 front-loaded with the core purpose, but it is lengthy and includes promotional language ('Gapup agent-payable C-suite expertise (CFO)') and multiple repetitive example questions. While the examples are useful, the text could be more concise without sacrificing guidance.

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 has nested objects and no output schema, and the description gives a good sense of the deliverable through example questions. However, it does not explain the return format, the async execution path, or the detailed input structure, leaving the agent to rely on the schema alone. It is adequate but not complete.

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

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

Schema description coverage is only 25% (only async has a description). The description offers example prompts that hint at needed information (company, period, budget amounts, categories) but does not explain the structure of entity and budgetContext or map examples to schema fields. The phrase 'documented case fields' is vague and insufficient for correct parameter construction.

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 it performs budget variance analysis ('Analyse d'écart budgétaire') and specifies concrete use cases such as explaining drivers, recommending corrective actions, creating forecast scenarios, and generating board-ready memos. This distinguishes it from generic financial tools and aligns with the CFO-focused positioning.

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 explicit example prompts that illustrate when to use the tool (variance explanation, corrective actions, forecast revision, memo creation, quick wins). This gives clear context for application, though it does not mention alternatives or exclusion cases, so it misses the threshold for a 5.

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

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

With no annotations, the description carries the full transparency burden. It explicitly discloses that it is a deterministic database lookup, not LLM-based, and sub-second. It also gives coverage statistics. This provides solid behavioral expectations, though it does not cover edge cases like missing data or error behavior.

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

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

Two sentences, highly informative, with the main purpose front-loaded and coverage/performance details following. Every sentence contributes value, making it concise and well-structured.

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 purpose, geographic scope, data coverage, and performance, which is sufficient for a moderate-complexity lookup tool. With an output schema present, the lack of return-format details in the description is acceptable. It does not mention prerequisites or error handling, but these are not critical for this simple 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 the baseline is 3. The description does not add additional parameter-level meaning beyond the schema; it only lists output types, not how parameters affect results. This is adequate but not enhanced.

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's function: 'Enrich a location with European building intelligence' and lists specific data types (roof surfaces, parking areas, solar-obligation status, existing installations). This is a specific verb+resource with concrete outputs, differentiating it from generic location or intelligence tools among siblings.

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

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

The description provides clear context on when to use: for European building data across 6 countries, with sub-second deterministic lookups. However, it does not explicitly name alternatives or state when not to use it, so it misses the full 5-level 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=true and destructiveHint=false, but the description adds valuable behavioral context: 'All processing is local -- no external API calls, instant response, privacy-preserving' and the diversity signals caveat with a 'mandatory ethical WARNING.' These go beyond what annotations provide, disclosing privacy and ethical behaviors.

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 appropriately sized for the tool's complexity. It is front-loaded with the core purpose, then logically flows into input/output, criteria details, per-candidate output, ethical warning, and processing characteristics. Every sentence earns its place without redundancy.

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

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

Given the tool's complexity (nested objects, 5 parameters, output schema exists), the description covers all essential aspects: inputs, output structure, criteria definitions, diversity signal limitation, and processing mode. Even though an output schema exists, it goes further to explain score ranges and flags, making it fully complete for selection and invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining what each weighting criterion represents (e.g., skills_match as 'tech stack and soft skills extracted from JD vs resume') and clarifying the candidate limits (1-50), which enriches the parameter understanding.

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: 'AI-powered candidate screening and ranking' and details the exact input (job description + 1-50 resumes) and output (ranked shortlist with score breakdowns). It distinguishes from siblings by covering all five weighted criteria and per-candidate outputs, making its scope clear even without naming alternatives.

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

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

The description provides clear context: it is for recruiters, hiring managers, ATS providers and recruitment AI agents, and explicitly mentions the input range (1-50 resumes). However, it does not explicitly state when to avoid using it or mention alternative sibling tools, so it stops short of full exclusion guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds that inputs are validated server-side and the deliverable is audited, providing some extra context about validation and quality. No contradictions with 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?

Four sentences, compact and front-loaded with the tool's name and purpose. The reference case adds context but may be considered extraneous. Overall, appropriately concise.

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

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

For a tool with 7 parameters, nested objects, and no output schema, the description is insufficient. It fails to explain what specific inputs are needed or the structure of the returned deliverable, relying on an external notion of 'documented case fields.'

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

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

Schema description coverage is only 14%, and the description does not explain any parameter fields beyond saying 'send the documented case fields.' The reference case hints at metrics like FTE, ARR, and department plans but does not map to schema parameters.

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

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

The description states 'Planification capacitaire' and indicates it returns a structured, audited deliverable. The reference case (Gapup Hub — 22→48 FTE, ARR growth) clarifies it's about headcount/capacity planning. However, it does not distinguish itself from sibling planning tools like growth_path_architect or capital_strategy.

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

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

No explicit guidance on when to use this tool over alternatives. The implied use case is capacity planning from the name and description, but no exclusions or alternative suggestions are 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description doesn't need to restate them. It adds that the deliverable is 'audited' and that inputs are 'validated server-side', which provides some behavioral context beyond annotations. However, it doesn't detail the response format, potential costs (Gapup agent-payable), or asynchronous behavior beyond what the schema already mentions for async.

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: two sentences, with the purpose front-loaded in the first sentence. The reference case provides helpful context without excessive length. However, the phrase 'Gapup agent-payable C-suite expertise (CSO)' is somewhat jargon-heavy and could be clearer, slightly detracting from the front-loaded 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?

For a tool with 5 parameters, nested objects, and no output schema, the description is too sparse. It doesn't specify what the 'structured, audited deliverable' will contain, how to interpret it, or how the reference case relates to the expected output. The async parameter is only documented in the schema, not in the description, and there's no mention of error handling or edge cases. This makes the tool hard to invoke correctly without additional information.

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

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

Schema description coverage is only 20% (only async has a description), so the description must compensate. It merely says 'send the documented case fields' without explaining any parameter meanings. The nested object property names (company, growthPlan, financialPosition, founderConstraints) are self-descriptive, but the description adds no semantics or guidance on how to fill them, leaving a significant gap.

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

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

The description states it's a 'Stratégie de financement' that returns a 'structured, audited deliverable', which clearly identifies the tool's function and output type. The reference to a specific case (Alan assurance santé SaaS) and sequence Seed→A→B→C adds specificity. However, it does not explicitly mention how it differs from closely related sibling tools like cap_table_strategist or funding_hunter, so it's not fully differentiated.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The mention of 'send the documented case fields' implies the user should have case data, but it doesn't clarify suitable scenarios, prerequisites, or exclusions. The reference case hints at early-stage funding rounds but stops short of actionable usage instructions.

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, so the safe-read nature is covered. The description adds that inputs are server-side validated and returns a structured, audited deliverable, which is useful. However, it does not disclose operational aspects like latency, result polling (async), or the exact deliverable structure.

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 relatively brief, but includes promotional language ('Gapup agent-payable C-suite expertise') and a reference case that may be useful context. The reference case illustrates output scope but feels somewhat tangential. Overall, it is not optimally front-loaded or concise.

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

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

Given the complex nested schema, low parameter coverage, and no output schema, the description is incomplete. It fails to explain what constitutes a valid case, what the deliverable will contain beyond being 'structured and audited', or how this tool fits with closely related siblings. Users would need to infer too much.

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

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

Schema description coverage is only 17% (only the async parameter is described), and the description does not compensate. It refers to 'documented case fields' without explaining any of the nested input objects (company, currentCapTable, plannedRounds, founderObjectives). Parameter names help somewhat, but the description adds no value.

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 positions the tool as a cap table strategist for fundraising and mentions a structured, audited deliverable with reference to dilution modeling and secondary simulations. However, it lacks a direct action verb (e.g., 'generates', 'analyzes') and does not explicitly differentiate itself from other strategy/finance tools.

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

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

No guidance is given on when to use this tool versus alternatives like capital_strategy or term_sheet_negotiation. The only usage hint is the FUNDRAISING tag and a vague instruction to send documented case fields, which is not sufficient.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true; the description adds meaningful context by specifying the calculation accuracy, Scope 1+2+3 coverage, and a detailed list of returned outputs. It does not mention rate limits or auth requirements, but for a read-only calculator this is sufficient. No contradiction with 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?

The description is front-loaded with the main purpose and organized into clear sections, which is good. However, the final sentence about Émilie is unnecessary, and the second sentence is a long enumeration of outputs, making the description slightly verbose. It is acceptable but not a model of 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?

The description gives strong context for when to use the tool and what outputs to expect, and an output schema exists. However, it does not explain the required input parameters sufficiently, nor does it mention the async option, which is relevant for a potentially slow computation. For a tool with 8 parameters and nested objects, this is a notable 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 only 13%, so the description must compensate for missing parameter documentation. It merely says 'Inputs: the company profile and its activity data,' which is too generic to clarify required parameters like perimeter, scope2Sources, or reductionTargets. This does not add meaningful semantic value over 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 it calculates a company's greenhouse-gas footprint under the GHG Protocol, specifying Scope 1+2+3, tCO2eq, and tier-2 accuracy ±20%. It lists several distinctive outputs (e.g., SBTi-aligned trajectory, CSRD/ESRS readiness) that differentiate it from sibling tools like sustainability_report or carbon_roadmap.

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 includes an explicit 'When to use this tool' section naming three concrete scenarios: CSRD compliance pre-audit, green-finance access, and supplier ESG scorecards. It does not explicitly state when not to use the tool or name alternative tools, so it stops short of a perfect score.

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, so the safety profile is known. The description adds that inputs are validated server-side and the result is 'audited,' which is useful context. However, it omits the async behavior indicated by the async parameter in the schema and does not describe error responses or output structure.

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 short but includes filler like 'Gapup agent-payable C-suite expertise' and 'Reference case: Cas démo.' These lines do not earn their place, and the remaining sentences are too vague to be actionable, making it under-specified rather than concise.

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

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

For a tool with 8 parameters, nested objects, and no output schema, the description is inadequate. It does not clarify what the deliverable contains, how to structure inputs, or when to use the async option. The lack of output schema and related siblings further increases the need for a richer description.

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

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

Schema description coverage is only 13%, and the description provides no parameter-level details. Saying 'send the documented case fields' is circular and does not help the agent understand the complex nested objects (company, perimeter, scope2Sources) or their required subfields.

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

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

The description says 'Roadmap carbone' and 'Returns a structured, audited deliverable,' but it does not specify what a carbon roadmap entails or how it differs from siblings like carbon_footprint_calculator or sustainability_report. The verb 'Returns' is generic, and the reference case 'Cas démo — Roadmap carbone' provides no functional clarity.

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

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

No guidance on when to use this tool versus alternatives. The mention of 'documented case fields' implies prerequisites but they are not explained, and no exclusions, recommended scenarios, or comparisons to sibling tools are 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?

Annotations already declare readOnlyHint=true, so the read-only nature is covered. The description adds that the deliverable is 'structured, audited' and that inputs are validated server-side, but it does not disclose deeper behaviors such as error handling or data sources. This is adequate given 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?

The description is three sentences, front-loaded with purpose, and uses a helpful reference case. The second sentence is a bit dense with the example, but overall it is efficiently structured 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?

The tool has nested parameters and no output schema, so the description should compensate by clarifying inputs and deliverable structure. It only says 'structured, audited deliverable' and provides one example, leaving the agent to guess the full output format and parameter requirements beyond the 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 schema coverage is only 25% (only 'async' has a description). The description's reference to 'documented case fields' indirectly mentions deal/contact/seller inputs, but it does not explain the semantics of knownContacts, sellerContext, or the return structure. It fails to compensate for the low 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 clearly states a mapping action ('Cartographie du champion') and the output ('structured, audited deliverable'), with a concrete reference case. It does not explicitly distinguish itself from sibling deal-related tools, but the champion-specific focus is evident.

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 versus alternatives like deal_coach or meddic_scoring. It only mentions that inputs are validated server-side, which is operational rather than usage direction.

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 openWorldHint, which cover safety aspects. The description adds behavioral context by explaining the data sources (GitHub PR metadata, Snyk vulnerability data) and the nature of outputs (root cause categories with confidence scores). This goes beyond the annotations without contradicting them.

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 three sentences, front-loaded with the primary purpose in the first sentence. It is concise, with no wasted words, and each sentence adds valuable information: what it does, how it does it, and when to use it.

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

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

There is an output schema, so return values are covered elsewhere. The description provides a solid overview and clarifies some parameters, but it leaves gaps for snyk_org_id and time_range_days. Given the low schema coverage, more param detail would improve completeness.

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

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

Schema description coverage is only 20%, leaving most parameters undocumented. The description clarifies pr_url and incident_id by saying 'Inputs include GitHub PR URL or incident ID,' but it does not explain snyk_org_id or time_range_days. It partially compensates for the schema gap but not fully.

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 it classifies root causes of change failures, which is a specific verb and resource. It further distinguishes itself by mentioning the use of GitHub PR metadata and Snyk vulnerability data, and outputs like structured root cause categories with confidence scores. This makes it distinct from sibling tools focused on other incident metrics.

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 by stating it is 'Ideal for post-mortem analysis and change risk assessment.' It also implies the tool is used when inputting a GitHub PR URL or incident ID. However, it does not explicitly name alternatives or when not to use the tool, 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?

Beyond the readOnly/openWorld annotations, the description discloses that live data from certain platforms requires AICI_RESEARCH_PROXY_URL with CN residential routing, and that without it only AliExpress and curated fallback are available. It also specifies input format requirements (platform:id) for seller_profile and price_history, adding valuable behavioral context 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?

The description is long but well-structured: it opens with audience and platforms, then enumerates the five modes in a consistent bullet-like format, followed by a data quality note and input format examples. Each sentence serves a purpose; no fluff or redundancy. It could be slightly more concise, but the organization 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?

Given the tool's complexity (5 parameters, 5 modes, platform-dependent behavior), the description covers all essential context: mode definitions, platform coverage, proxy reliance, and input format specifics. An output schema exists, so the description doesn't need to detail return values. Missing would be auth details or rate limits, but those are not critical for selection and 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 already provides 100% coverage for all parameters with descriptions, so baseline is 3. The tool description adds extra meaning by detailing valid query formats (e.g., 'aliexpress:123456', '1688:87654321') and clarifying mode-specific behavior for platform and region parameters. This extra context about input syntax justifies a score above baseline.

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's purpose: Chinese e-commerce intelligence across major Chinese platforms, with five explicitly named modes (product_search, seller_profile, price_history, brand_monitoring, market_intel). It specifies the target audience and platform coverage, effectively distinguishing it from sibling tools like china_market_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 provides clear use-case context (diaspora, import-export, brand IP enforcement, sourcing entrepreneurs) and explains what each mode does. It also gives critical operational guidance about proxy requirements for live data and fallback options. However, it does not explicitly compare to alternative tools 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?

Beyond the annotations (readOnlyHint=true, destructiveHint=false), the description discloses important behavioral details: data sources (Yahoo Finance always accessible, Eastmoney/HKEX with proxy), and the note that Eastmoney/CSRC/SSE are blocked from datacenter IPs without AICI_RESEARCH_PROXY_URL. It also describes per-mode return contents, which is useful context.

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

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

The description is well-structured and efficient: a brief introductory sentence, bullet-pointed mode definitions, input format list, and data source note. Every section earns its place, and the length is justified by the tool's four-mode complexity. No fluff or redundancy.

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

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

Given the tool's complexity (four modes, multiple input formats, 5 parameters), the description covers all necessary operational context: modes with output fields, accepted ticker/name/sector formats, data source behaviors, and proxy configuration. With an output schema present, return values need no further explanation. The async parameter is covered by schema descriptions, so this is sufficiently complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds significant value by listing accepted input formats with concrete examples (e.g., '600519' for Moutai SSE, '0700.HK' for Tencent, '腾讯'), detailing sector keywords, and explaining the period_days lookback. This enriches the query and sector_overview parameters beyond schema descriptions.

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+resource: 'Chinese capital market intelligence' covering A-Shares, H-Shares, and ADRs across four distinct modes. It distinguishes itself from neighboring tools like india_market_data through explicit geographic scope and enumerates the exact output for each mode.

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 clear context on when to use the tool by enumerating supported markets and input formats. It also gives operational guidance on data source availability and the proxy requirement for full coverage. However, it does not explicitly name alternatives or state when not to use this tool (e.g., for Indian markets).

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 adds 'Inputs are validated server-side' and 'Returns a structured, audited deliverable', which are small extra clarifications beyond the readOnly/openWorld annotations. However, it does not disclose the async option, processing behavior, or what the deliverable contains. The added context is minimal.

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 short but under-specified. The opening phrase 'Gapup agent-payable C-suite expertise (CRO)' is jargon and not effectively front-loaded. The reference case is concrete but does not substitute for a real description of the tool's purpose and functionality.

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

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

For a tool with a complex nested schema (company, accounts) and no output schema, the description is severely incomplete. It fails to explain the purpose, required inputs, expected output, or when to invoke it. The reference case describes a specific scenario rather than general capabilities.

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

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

With schema description coverage at only 20%, the description should compensate by explaining key parameters. 'Send the documented case fields' is unhelpful and tautological. No parameter names, types, or detailed purposes are described beyond the schema itself.

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 mostly restates the tool name ('Bouclier anti-churn') and vague marketing language ('Gapup agent-payable C-suite expertise'). It never clearly states the core function with a specific verb such as 'detect' or 'generate'. The only hint is in the reference case ('détection churn'), which is not a definition.

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

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

No guidance is provided on when to use this tool versus the many sibling churn-related tools (renewal_optimizer, save_plays, champion_mapping). The phrase 'send the documented case fields' addresses input preparation but not selection criteria or 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 readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context: cache duration ('Cache 7j'), SLA ('SLA ≤20s'), keyless access ('keyless'), and the async execution option. No contradiction with 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?

The description is a dense but well-structured paragraph that front-loads the main purpose and follows with scenario, horizon, metric, output, source, and usage details. It avoids filler and each clause adds distinct information, though the length could be slightly reduced without losing 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 complexity (6 parameters, output schema present), the description covers all essential aspects: purpose, scenarios, metrics, outputs, data sources, use cases, performance expectations, and auxiliary parameters like async. The output schema handles return-value details, so the description 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?

Schema has 100% coverage, so baseline is 3. The description goes beyond the schema by elaborating on the meaning of metric values (e.g., 'température (delta vs baseline 1990-2010, jours >35°C, nuits chaudes)') and scenario options, enriching the parameter understanding.

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's function with a specific verb and resource: 'Projections climatiques long terme par scénario IPCC (RCP AR5 + SSP AR6) pour toute localisation.' It also enumerates specific scenarios, horizons, and metrics, which unambiguously distinguishes it from siblings like weather_climate_intel.

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 explicit use cases: 'Usages : TCFD/CSRD physical risk, due diligence actifs long terme, assurance catastrophe, planification infrastructure.' This gives clear context for when to use the tool, though it does not explicitly mention alternatives or when not to use it compared to sibling tools.

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

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

Annotations already provide readOnlyHint=true. The description adds that it returns a 'structured, audited deliverable' and that inputs are 'validated server-side', which is useful context. But it doesn't disclose output structure, pagination, rate limits, or async behavior beyond what the schema hints.

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 contains a promotional tagline ('Gapup agent-payable C-suite expertise (RISK)') and a long reference case. While bulleted, it is not front-loaded and includes sentences that add little value, such as the vague 'RISK' label and the closing validation note.

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

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

For a tool with 8 parameters, no output schema, and only minimal annotations, the description omits key usage details: how to specify the exact focus, what the deliverable contains beyond vague 'GRADE rating', and how async polling works. The reference case helps but is not a substitute for explicit guidance.

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

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

Schema description coverage is only 13%. The description maps some placeholders (e.g., 'drug/intervention', 'indication') but never explains max_studies, date_range_years, intervention_type, or async. It fails to compensate for the sparse schema for most parameters.

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

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

The description clearly states it produces a 'Brief évidence clinique (GRADE)' and enumerates specific question types (efficacy, safety, comparative effectiveness, repurposing, evidence gaps). This is a specific verb+resource with distinct scope, distinguishing it from siblings like clinical_pharma_intel or sci_literature_search.

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

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

The example questions clearly imply when to use the tool (e.g., for GRADE ratings, safety signals, comparative effectiveness). However, it never explicitly names alternatives or exclusion criteria, so it stops short of full when/when-not guidance.

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