Analytics Legends — SAP Analytics Intelligence

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

The description discloses that 'value: null' is a real bucket and is served rather than hidden, which is not obvious and could lead to misunderstanding. It also explains that every bucket corresponds to a stored directory value, not a computed bin. Since annotations already declare readOnlyHint and idempotentHint, the description adds valuable behavioral context about output semantics.

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 composed of three dense sentences: the first defines the purpose, the second explains why to use it over the alternative, and the third clarifies null bucket behavior. Every sentence earns its place without redundancy or filler.

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

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

For a read-only aggregation tool with an output schema and robust annotations, the description covers the main decision points: what it does, when to use it, and a non-obvious behavioral characteristic. The output format is not described, but that is appropriately left to the output schema, so no meaningful gaps remain.

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 documents all five parameters with descriptions and enums, achieving 100% coverage. The description only reiterates that filters are shared with search_firms and mentions that combining `kind` with `by:"kind"` is legal, but this is also present in the schema. No new parameter-level meaning is added.

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 counts organizations in the firm directory by country, kind, SAP module, or SAP signal band. It explicitly uses the verb 'Answer a COUNTING question' and names the resource 'published firm directory', distinguishing it from search_firms, which is a sibling tool for listing rows.

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?

Directly instructs users to 'Use this instead of paging search_firms and tallying rows' and quantifies the cost of the alternative in calls and data volume. It also notes that the same filters as search_firms apply, so users can apply known filtering logic. This clearly states when to use the tool versus the most relevant sibling.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is known. The description adds valuable behavioral context: pagination mechanics, the non-filterable `status`/`is_preview` flags measured on 2026-08-16, and the fact that the cursor is refused if filters change. This goes beyond annotations with actionable runtime details.

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 every sentence provides value—disambiguation, scope, pagination, flags—with no filler. It is longer than a typical tool description, but given the tool's 5 params, sibling confusion, and non-obvious flags, the length is justified. The all-caps warnings help structure important caveats.

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 params, output schema exists, two confusing sibling tools), the description is exceptionally complete: it covers purpose, return fields, differentiation from list_sap_modules, subscriber-only body via get_academy_module, pagination, measured flag counts, and meta usage. The only minor omission is explicit auth requirements for this search call, but the readOnlyHint and lack of a subscriber mention imply public access; the description is still thorough enough for reliable 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% with detailed parameter descriptions, so the baseline is 3. The description adds marginal value by reinforcing the need to consult `_meta.available_tracks`/`available_levels` and explicitly stating `status`/`is_preview` are served but not filterable, which affects how parameters are used. It doesn't add new syntax or format, but it clarifies behavioral expectations around the schema.

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

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

The description opens with 'Search the Analytics Legends Academy — the 303 written training modules...' which is a specific verb+resource with clearly enumerated subjects (SAP Datasphere, Business Data Cloud, etc.). It explicitly contrasts with list_sap_modules ('DO NOT CONFUSE IT WITH...') and defines the catalogue scope, leaving no ambiguity about what the tool does.

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

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

The description provides explicit when-to-use guidance: it says 'CATALOGUE ONLY' and directs to get_academy_module for body content, and names list_sap_modules as a different population with a different purpose. It also gives operational instructions for pagination ('pass `_meta.next_cursor` back as `cursor`...') and advises reading `_meta.available_tracks`/`available_levels` before assuming facet values.

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

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

The description discloses far more than the annotations already signal: the near-disjoint nature of the two feed legs, date-sensitive invariants, gated fields (source_url null, application_link 'members_only'), the meaning of rate_band as an editorial benchmark, and the exact behavior of country/remote_mode/employment_type filters on each leg. This is exemplary behavioral transparency.

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?

Every sentence contains valuable information, but the description is a dense wall of text with all-caps emphasis and no paragraph breaks, making it hard to scan. It is not concise by any measure, though none of the content is fluff. The structure could be improved with bullets or sections.

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

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

The tool is complex (two data legs, nuanced rate semantics, gated fields, pagination caveats) and the description covers all these facets with concrete guidance on reading _meta fields. Since an output schema exists, it need not enumerate return values, but it even references the relevant _meta fields the agent will encounter. This is complete 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?

Although schema coverage is 100%, the description adds crucial semantics beyond the schema: for employment_type it explains the radar is mostly permanent and that the promoted leg is dropped by predicate; for remote_mode it clarifies that undeclared rows are set aside, not classified; for country it explains how the promoted leg's null country_code causes rows to be dropped. These are meaningful additions that help an agent use parameters correctly.

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

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

The description explicitly states the tool searches 'every SAP contract and permanent-role posting Analytics Legends publishes' and identifies the two public legs it merges. This is a specific verb+resource+scope, and it clearly differentiates this tool from sibling search tools by focusing on job/contract postings rather than firms, concepts, or news.

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 extensive context for correct usage: warnings to read employment_type before calling it a contract market, instructions to read _meta.tranche_total_row_count for the live split, and guidance on how to interpret rate_band vs daily_rate fields. However, it does not explicitly name alternative tools or state when to prefer them, so it stops short of a full 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?

Even with annotations declaring read-only and non-destructive, the description adds rich behavioral context: the dataset is 'locked away from the public surface,' verification status is 'SERVED, never silently filtered,' and product filtering is detection-based with no negative counterpart. These details go far beyond the annotations and clarify important data interpretation nuances.

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 paragraph, but every sentence delivers unique value: definition, access, verification behavior, and product semantics. There is no padding or repetition of schema details. The structure is front-loaded with the most critical context and flows logically.

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, annotations), the description covers all key caveats: dataset nature, access restrictions, verification semantics, and filter interpretation. The output schema handles return values, and the schema descriptions cover the remaining parameters, so no critical information is missing.

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

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

Schema description coverage is 100%, establishing a baseline of 3. The description adds extra semantic value by explaining the `product` parameter's detection-based behavior and linking it to the `uses_*` columns, which is not fully captured in the schema. It does not extensively cover other parameters, but the schema already handles 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 opens with a clear, specific verb and resource: 'Search the SAP END-CUSTOMER corpus.' It immediately distinguishes from sibling search_firms by specifying 'the companies that RUN SAP, not the firms that sell services.' This makes the tool's purpose unambiguous and sets it apart from 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 explicit usage context: it is for finding SAP end-customers in a paid dataset, requires 'subscriber API key, Legend tier or above,' and points to search_firms as the alternative for service-provider searches. It also explains when verification status is directly served, guiding the agent on when to use this tool versus others.

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

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

Goes well beyond the readOnly/idempotent annotations by disclosing auth requirements, refusal behavior, case-insensitive id/slug matching, and even response size characteristics ('longest body measured is 17 865 characters'). This gives the agent deeper expectations about what will happen when the tool is invoked.

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 long sentences, but each is information-dense and front-loaded: purpose in the first sentence, auth/alternatives in the second, input formats and call-size rationale in the third. No filler, though it could be tightened slightly 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?

Covers what is returned (full module content, languages), who can use it (tier, API key), how the input maps to other tools, and why it is safe to return everything in one call. With a single parameter and rich annotations, this leaves no meaningful questions unanswered.

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 fully describes the single `id` parameter with examples and provenance from find_academy_modules. The description adds the case-insensitivity detail and reinforces that both id and slug are accepted, which is semantically useful but not a major shift given the schema's high coverage.

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

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

The description opens with a specific verb and resource: 'Read one Academy training module in full', listing contents (body, learning objectives, summary, EN/FR). It further distinguishes from siblings by referencing find_academy_modules and query_knowledge_graph, and contrasting with get_study, making the tool's unique role 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?

Explicitly states prerequisites ('Requires a subscriber API key... Consultant tier or above') and the consequence of lacking them ('without one this tool refuses and find_academy_modules keeps serving the catalogue'). It also advises when to use this over get_study ('Unlike get_study, the whole module is served in one call') and links to the catalogue and graph 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 annotations already declare read-only, idempotent, non-destructive behavior. The description adds valuable context beyond annotations: the content is human-written (not generated), and specific fields are subscriber-only and intentionally omitted. This explains behavior that annotations cannot convey and sets correct expectations.

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

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

Two sentences, no wasted words. The first sentence leads with the action and key fields; the second clarifies exclusions and provides a next step (citation_url). Every clause adds value.

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

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

For a single-parameter read tool with an output schema present, the description is complete: it specifies what is returned, what is omitted, and where to get more content. No gaps remain for the agent to misuse 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 coverage is 100% and the single parameter 'slug' is already described as 'Concept slug from search_concepts.' The tool description repeats this and adds no new semantic detail about the parameter itself. Baseline 3 is appropriate since schema fully covers the 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 fetches one concept entry by slug, listing specific fields returned (title, category, level, tags, editor's summary) and explicitly distinguishes from sibling tools by noting what is not returned. The verb 'Fetch' and resource 'concept entry' are specific and unambiguous.

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

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

The description implies usage context: use for retrieving a concept summary, and if you need subscriber content, follow the citation_url. It does not explicitly name an alternative tool like get_concept_card, but the clear scoping of what is included and excluded serves as guidance. The reference to 'slug from search_concepts' also directs the user on how to obtain the parameter.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds valuable context about the authorization requirement, the refusal behavior without a valid key, and the fallback to the public metadata tool. This goes beyond the annotations without contradicting them, though it doesn't detail rate limits or error formats.

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: the first front-loads the purpose and content, the second conveys the critical auth requirement and fallback, the third gives slug discovery guidance. Every sentence contributes value with no redundant wording.

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 single parameter fully described in the schema, an output schema present, and annotations covering safety, the description supplies all remaining operational context: authentication, fallback to get_concept, card content, and slug discovery. It is complete for a read-only retrieval 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 has 100% coverage, describing the slug parameter as 'verbatim from search_concepts.rows[].slug' and noting it's required. The description adds a pointer to search_concepts for slug discovery, which is useful but does not substantially alter parameter understanding. Baseline 3 is appropriate given the schema already carries the full burden.

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 retrieves the full concept card with specific content (body, why-it-matters, key points, etc.) in EN and FR. It explicitly distinguishes this from the sibling get_concept tool, which serves public metadata. The verb+resource+scope is precise.

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 when-to-use guidance (requires a subscriber API key and Consultant tier or above) and when-not-to-use (without it, the tool refuses and get_concept serves public metadata). It also directs users to search_concepts for finding slugs. This clearly differentiates the tool from alternatives and covers prerequisites.

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

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

Beyond the readOnlyHint annotation, the description discloses crucial behavioral traits: the aggregate is small (11 rows), rows are secondary sources, sample_size is null on 8 rows, there is no paid counterpart, community views are empty, and unsupported codes return 0 rows plus available codes. It also explains the GB special case and the availability of _meta 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 front-loaded with the core definition and contains essential caveats, but it is overly verbose and repetitive, using ALL CAPS and lengthy emphatic sections. While each sentence adds information, the overall length may hinder readability; a more condensed structure would be preferable.

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 fully complete given the tool's complexity: it covers purpose, data provenance, limitation examples, relationship to find_opportunities, parameter semantics, runtime metadata, and behavior on empty results. It leaves no ambiguity for an agent, making it self-contained.

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?

Even though the schema already describes all three parameters with 100% coverage, the description adds significant semantics, especially for the specialisation parameter. It lists live codes (analytics_all, bw, bw4hana, sac, datasphere), notes uneven distribution (DE holds analytics_all only), and clarifies behavior for unsupported codes (returns 0 rows and available codes). This far exceeds schema-level documentation.

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

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

The description clearly identifies the tool as 'The PUBLIC day-rate aggregate for SAP analytics freelance work' and specifies the data returned (min/max daily rate by country, specialisation and seniority). It also distinguishes this tool from the sibling tool find_opportunities, making its purpose unambiguous.

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

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

The description explicitly instructs when to use this tool vs find_opportunities, noting the aggregate is 'the thinner one' and directing users to consult the radar band when the aggregate holds no row. It names the alternative tool and even provides concrete examples (Senior Datasphere DACH, Senior BDC DACH) where the alternative is preferred.

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 (readOnly, idempotent, destructiveHint false), the description adds critical behavioral context: it explains that `partnerships_declared` being 0 means none declared, not that the firm has no partners, and provides measured frequency data. It also notes that a refused slug does not mean the firm is absent, because the published tranche is an editorial subset. This is valuable nuance not captured in 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 efficiently structured: an action sentence, a return-semantics sentence, and an exclusions sentence. It is slightly dense due to the parenthetical measurement detail ('re-measured 2026-08-14... 96,8 %'), but every clause contributes to understanding. It is front-loaded and appropriately sized for a tool with this nuance.

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 annotations, the description is complete. It explains the key return field's semantics and the potential misinterpretation, while the schema covers slug handling in depth. No important behavioral or usage aspects are left undocumented for the tool's complexity.

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

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

With schema description coverage at 100%, the baseline is 3. The tool description merely recaps the slug source ('rows[].slug from search_firms') already fully detailed in the schema, adding no new parameter semantics. The schema itself contains extensive guidance on numeric slugs and refusal behavior, but that belongs to the schema, not the tool description.

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

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

The description clearly states the action ('Fetch one organisation from the published directory') and the specific resource ('published profile'), using the verb 'Fetch' with a precise scope. It distinguishes from siblings by noting it returns public fields and does not return the paid firm-intelligence profile or contacts, making its purpose unambiguous.

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

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

The description implies when to use the tool (when a single firm's published profile is needed) and tells the user to source the slug from search_firms, noting that the slug is taken verbatim. It also states exclusions (no paid profile, contacts, or persons), which hints at alternatives, but it does not explicitly name tools like get_firm_intel or search_firms for those needs.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description adds critical behavioral context: requires a subscriber API key and Legend tier, explains that LinkedIn follower counts are null on the entire corpus and absence is a data gap not a signal, and reveals that person-shaped fields are never served even though they might be expected. This goes well 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 a single dense paragraph but every sentence earns its place: purpose, data caveat, authentication requirement, explicit exclusion of fields, and search guidance. It is front-loaded with the core purpose and efficiently packs caveats without redundancy. No filler or repeated schema 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 the tool's complexity (6 params, output schema, annotations), the description is complete: it explains what the profile includes and excludes, notes data completeness caveats, specifies tier/auth requirements, and points to the correct alternative for excluded data. It fully equips an agent to decide when and how to invoke this endpoint.

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 coverage is 100% with detailed parameter descriptions (e.g., mode enums, cursor semantics, delivers flags). The tool description itself does not re-explain any individual parameter, so it adds no additional parameter-level meaning. The baseline of 3 applies because the schema already carries the full burden.

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 ('get') with a concrete resource ('firm intelligence profile'), enumerating exactly what the profile contains (SAP practice size, partner level, delivery flags, day rate, notable clients, analytics summary, LinkedIn URL). It further distinguishes itself from the sibling search_firms by noting the public directory is 'a different, wider population,' and explicitly states that person-shaped fields are never served by this endpoint, setting clear boundaries.

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 states when to use: for a paid, Legend-tier intelligence profile, searched by name. It gives a clear when-not-to-use: person-shaped fields (contacts, founders, leadership, etc.) are NEVER served here, and directs users to the platform's signed-URL path. It also contrasts with search_firms, providing an alternative. This is explicit guidance with exclusions and 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 readOnly, idempotent, and non-destructive, so the description adds value by disclosing the API key/tier requirement and the source of the id. It does not contradict annotations and provides meaningful operational context beyond the schema.

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

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

Two compact sentences. The first states the purpose and content; the second covers auth and id provenance. No filler or repetition of annotations.

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

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

For a simple single-parameter retrieval tool with an output schema present, the description covers purpose, content, auth, and id provenance. It is sufficiently complete to guide correct invocation without needing to explain return values.

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 already covers the only parameter with 100% coverage. The description adds extra semantic value by explicitly stating that `id` comes verbatim from find_sap_clients.rows[].id, reinforcing correctness of parameter use beyond the schema's brief label.

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 specifies a singular, concrete resource: the full profile of one SAP end-customer with listed content domains (SAP footprint, analytics, identity, evidence). It clearly distinguishes from the sibling find_sap_clients by referencing a specific id from that list.

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

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

States the prerequisite (subscriber API key, Legend tier) and tells the agent that the id should come from find_sap_clients.rows[].id, implying the natural workflow: first list, then get detail. It does not explicitly mention when not to use alternatives, but the referential guidance provides sufficient 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?

Beyond the annotations (readOnly, idempotent, non-destructive), the description discloses significant behavioral traits: a subscriber API key and Consultant tier requirement, the 256 KiB response ceiling, the structure-first behavior, case-insensitive section matching, and inclusion of the introduction. This is rich context useful for an agent.

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?

Every sentence earns its place: purpose, auth constraint, size limitation, usage mechanism, and pointer to list_studies. The description is front-loaded with the core action and then methodically explains the chunked reading approach without redundancy. Length is justified by the tool's complexity.

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

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

Given the tool's complexity (auth tier, size limit, section-based reading) and the presence of an output schema, the description fully covers how to invoke it correctly: what to pass, what to expect, and where to get inputs. No critical usage aspect is missing.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by noting that `section` matching is case-insensitive and that omitting `section` returns not just the section list but also the introduction. It also clarifies that `slug` is verbatim from list_studies, reinforcing schema hints.

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+resource: 'Read one Analytics Legends study BODY — the paid text behind list_studies' metadata.' This clearly distinguishes it from sibling list_studies and other get_* tools by focusing on the full text body, not metadata or other entity types.

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 tells when to use this tool vs list_studies: 'Find slugs and languages with list_studies.' It also provides a full usage pattern: call without `section` for the section list and introduction, then pass a section heading for one section. No exclusions are needed because the alternative is named.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds useful behavioral detail: the counts are 'live', indicating freshness and that the data reflects the current state, which is not conveyed by annotations or schema.

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

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

The description is two sentences, front-loaded with the core function and then a practical usage hint. Every word earns its place, with no redundancy or filler.

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

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

Given the simple parameterless signature, rich annotations, and presence of an output schema, the description provides sufficient context for an agent to understand the tool's role and when to invoke it. It adds domain context (published directory, live counts) and usage guidance, making it complete for this tool's complexity.

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

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

There are no parameters, so the description carries no parameter burden. The baseline for zero parameters is 4, and though the description doesn't add parameter-specific meaning, it explains the output grouping by organization kind, which helps set expectations for the result.

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 provides a breakdown of the published firm directory by organization kind, with live counts. It distinguishes itself from sibling tools like search_firms by focusing on population-level aggregation rather than individual firm lookup, and explicitly frames it as a precursor to searching.

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 says to use this tool before search_firms, providing clear context and a naming the alternative. It lacks explicit 'when not to use' exclusions, but the guidance to use it as a preliminary step is direct and helpful.

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, etc.), the description discloses valuable behavioral nuances: that signup_url was verified on assessed_at, that absence of a platform does not prove refusal (only that it's unassessed or unpublished), and that the tool is a subset of the directory. This context prevents misinterpretation of results and enriches the agent's understanding without contradicting 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 well-structured and front-loaded with the core purpose. The historical note about 2026-08-16 and the count of rows is marginally useful but adds length; the relationship to search_firms and the absence caveat are essential. Overall it is efficiently written, earning a 4 rather than 5 due to a slightly verbose historical aside.

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 a rich output schema and detailed input schema, the description still adds complete context: it defines the result population, the fields returned (signup_url, confidence grade, assessed_at), the filter semantics, and the caveat about absent platforms. The tool is fully specified for an agent to select and invoke appropriately.

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

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

The input schema already provides 100% parameter coverage with descriptions for limit, cursor, country, and platform_type. The description adds no parameter-specific semantics beyond the schema; it contextualizes the tool's purpose but not individual parameters. Per calibration rules, baseline 3 applies due to full 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 defines the tool as listing a subset of the published directory where consultants can create profiles, enumerating the categories (freelance marketplaces, job boards, talent platforms, expert networks) and the returned fields. It explicitly distinguishes this tool from the sibling search_firms by stating it adds platform fields and the filter, never a wider population.

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 when to use this tool: to answer the entering-contractor's registration question in one call. It explicitly identifies search_firms as the alternative for the broader population, saying 'Everything here is also in search_firms' and clarifying that this tool adds platform fields and the filter. It also provides a caution about the interpretation of absent platforms, guiding correct usage.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is well covered. The description adds value by explaining the taxonomy's content (codes, EN/FR labels, categories) and its role as a lookup/reference. 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?

Two sentences, zero waste. The first sentence states what it is, the second explains the exact use case with illustrative examples. The structure is front-loaded and purposeful.

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 and rich annotations, so return values and safety are covered elsewhere. The description fills the remaining gaps: why this tool exists, how it relates to sibling tools, and what kinds of inputs it handles. This is complete for an agent to decide when to invoke it.

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

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

Schema coverage is 100%, with each parameter (limit, query, cursor) already defined in the schema. The description adds no parameter-specific semantics but doesn't need to; the baseline of 3 is appropriate given the high 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 identifies the resource (canonical SAP module taxonomy), the action (list/classify), and the role (normalise user wording onto codes). It distinguishes from siblings by noting the codes are what other tools filter on, with concrete examples like 'SAC', 'Analytics Cloud', 'Datasphere'.

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 states when to use the tool: to normalise loose product wording into canonical codes for other tools. It gives a clear use case but does not name alternative tools or exclusion scenarios. The reference to 'other tools' is enough context for an agent.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds that this is metadata-only, that bodies are a paid deliverable via `get_study`, and the exact fields returned. This goes beyond annotations to disclose important behavioral scope, though it doesn't mention pagination 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?

Three sentences, each adding value: purpose, metadata-only caveat with alternative, and use case. No redundancy or unnecessary elaboration; it is 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?

Given the output schema exists and annotations cover safety, the description provides complete context for a list tool: what it returns, the metadata-only constraint, and how to direct users to full studies. It is sufficiently complete without needing to explain return values in detail.

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

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

Schema description coverage is 100%, with each parameter (lang, limit, query, cursor) having a detailed description. The tool description does not repeat parameter details, which is acceptable given the high schema coverage; it adds no extra parameter semantics beyond the schema.

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

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

The description states a specific verb ('List') and resource ('deep-research studies'), scopes to 'metadata only', lists the exact fields returned (edition, as-of date, audience, word count, canonical URL), and explicitly contrasts with sibling tool `get_study`. This clearly distinguishes it from related 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?

It explicitly says to use this tool to tell a reader that a study exists and where to read it, and states that study bodies are served by `get_study` with a subscriber key. This provides clear when-to-use guidance and names the alternative tool.

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

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

Annotations already declare readOnly, idempotent, non-destructive. The description adds rich behavioral context beyond that: cursor is bound to filters and refused if changed, direction is ignored without node_id and the response explicitly says so, available_edge_types is computed per call, and missing node types are documented boundaries not silent gaps. 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 long but every sentence carries unique, actionable information. It starts with the primary purpose and the key distinction, then covers scope, node types, calling patterns, and edge cases. There is no fluff or repetition; each section 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?

The tool has a comparatively complex scope (four node types, edge filtering, pagination, cursors) and an output schema. The description covers the scope boundaries, exclusions, meta fields, interaction between parameters, and cursor behavior. This is fully complete for an agent to invoke it correctly without prior knowledge.

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?

Even though schema coverage is 100%, the description adds substantial semantic value: fully-qualified node_id format with concrete examples, explanation that node_id yields edges vs nodes, direction behavior when ignored, cursor semantics, and the need to consult computed _meta.available_edge_types. This goes far beyond the schema's field 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 is explicit and specific: it states the tool serves RELATIONS/edges in the knowledge graph, with a clear verb ('traverse', 'ask what connects to what') and resource. It distinguishes itself from all other tools on the server by being the only edge-serving tool, making its 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?

It provides explicit when-to-use guidance: 'Ask it what connects to what, not what exists' and names the alternative (other sixteen tools serve rows). It also details how to invoke with node_id, node_type, query, and tells users to read _meta.available_edge_types before assuming an edge type exists. This is exemplary usage 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, idempotentHint=true, and destructiveHint=false. The description adds the behavioral trait that results return titles and summaries, not full entries, which helps set expectations. It does not 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 just two sentences, front-loaded with the tool's purpose and followed by the return format and a pointer to the sibling tool. Every word 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?

Given the tool has an output schema, the description does not need to explain return values. It covers purpose, return type, and the complementary get_concept tool. The schema handles parameter details, and annotations cover safety, making the description 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?

Schema description coverage is 100%, with detailed descriptions for all four parameters (limit, query, cursor, category). The description adds no parameter semantics beyond what the schema already provides, 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 clearly states the verb ('Search') and the resource ('SAP analytics concept encyclopaedia'), and distinguishes from sibling get_concept by noting it returns titles and summaries while get_concept provides the full entry.

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 context for when to use this tool versus the alternative get_concept: 'call get_concept for the full entry.' It does not explicitly exclude other sibling searches, but the domain-specific resource name makes the intended use evident.

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, idempotent, and non-destructive traits, so the description adds substantial behavioral nuance beyond them: the is_client flag vs kind column disagreement and which one decides results, the full pagination mechanism with cursor semantics, query-based ordering, and the module filter's 'declared link' meaning. These are critical execution details an agent would otherwise not know.

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 paragraph but is front-loaded with the core purpose and return fields, then proceeds logically through exclusions, flag semantics, pagination, and ordering. Every sentence carries meaningful information, though the prose is long and could benefit from bullet points for faster scanning.

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—multiple filters, pagination, a subtle flag-vs-kind distinction, and query-dependent ordering—the description covers all critical behavioral aspects. It explains what the tool returns, how pagination works, how filters interact, and how to interpret empty results. The output schema likely covers field-level types, so no significant gaps remain.

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%, but the description significantly enriches each parameter's meaning: it warns that 'kind=client_enterprise' is not the actual discriminator (the is_client flag is), explains the ordering for 'query', emphasizes that 'cursor' must reuse the same filters, and clarifies that 'module' only matches declared links. This is far beyond what the schema descriptions provide.

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 searches the Analytics Legends directory of SAP analytics service providers, enumerating the filters (country, kind, module, free text) and return fields. It distinguishes itself from siblings by explicitly limiting scope to the published directory and excluding SAP end-customers, which separates it from tools like search_concepts or find_sap_clients.

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 strong contextual guidance by explicitly stating SAP end-customers are NOT in this directory and are a separate paid dataset, implying alternative tools (such as find_sap_clients) for that need. It also details pagination and ordering behavior, clarifying when to use this tool for directory search. However, it does not explicitly name any alternative tools as a direct comparison.

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/idempotent/destructive annotations, the description discloses the corpus's real composition (84% AI, general enterprise-AI trade press), the structural noise in the SAC category, and the requirement to cite both the citation URL and source_url. These are behavioral traits the agent would otherwise not know.

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 every sentence carries essential caveats: scope, composition, unfiltered behavior, citation instructions. It is front-loaded with the core purpose and then layers the necessary warnings, with no filler.

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

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

Given the rich schema and annotations, the description provides the crucial context—corpus bias, filter guidance, and citation expectations—that the structured fields do not convey. It fully equips the 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 schema already provides 100% descriptive coverage of all four parameters, including a detailed explanation of `category` and `cursor`. The description adds only the usage recommendation to pass `query` or `category` for SAP questions, which is more about usage than parameter meaning; it does not materially deepen the parameter semantics beyond the schema.

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

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

The description clearly identifies the tool as a search over the Analytics Legends market-news corpus, immediately defining its scope (watched for SAP analytics) and its non-SAP composition. This specific verb+resource+scope statement distinguishes it from sibling search 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?

It explicitly tells the agent when to pass `query` or `category` for SAP-related questions, warns that unfiltered calls return mostly non-SAP items, and instructs never to present an unfiltered page as 'the SAP analytics news'. It also directs the agent to say what it actually got, providing clear usage context.

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