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

Annotations already flag this as a non-read-only, non-idempotent write operationhip. The description adds the useful constraint that only certain families (100, 300, 310, 320) are allowed serveur-side, which is behavioral context beyond the raw schema. It does not disclose side effects, auth requirements, or duplication behavior, but the annotation set partially covers the safety profile.

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-loaded, starting with the action and use case, then specifying the family constraint)Skip exactly the endpoint. Every element earns its place and no space is wasted on redundant details already present in the schema.

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

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

Despite being a write operation with 11 parameters, no output schema, and a nested object, the description does not explain expected return values, required parameter relationships, or the structure/meaning of the nested 'details' object. The use case and family constraint help, but they are not enough for a tool with this parameter 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 18%, so the description must compensate, but it does not. It adds one valuable constraint: the allowed families for the 'code' parameter. It leaves the meaning and relationship of the other nine parameters undocumented, including 'details', 'page_id', 'page_url', 'source', and 'category_id'.

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 action: adding an event to a site's history. It goes beyond the title by specifying the exact use case (signaling modifications made outside GPSEM) with concrete examples, and the POST endpoint further confirms the write operation. This distinguishes it from read-only sibling tools like getSiteHistorique.

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 clear context for when the tool should be used: to log changes made outside GPSEM such as redesigns, robots.txt updates, link campaigns, or reworked content. It also constrains valid input by stating authorized families. However, it does not explicitly mention alternatives or state when not to use this 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 indicate a non-read, non-idempotent mutation, and the description adds genuinely useful behavioral context: collection takes minutes and the report goes from pending to ready. This goes beyond structured fields and accurately sets expectations for an asynchronous operation.

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

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

The description is a single well-structured sentence with the core action, key scope, async behavior, and endpoint all included. Every clause earns its place and the important information is front-loaded.

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

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

For a one-parameter creation tool with no output schema, the description covers the behavior and lifecycle well. The only minor gap is that it doesn't explicitly state how to poll or retrieve the completed report, though sibling tools make that reasonably inferable.

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 siteId already described as an encoded site ID (hashid). The description adds no additional parameter semantics beyond the endpoint path, so the baseline of 3 applies because the schema carries the documentation 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 states a specific action ('Crée un rapport') and resource (audit report with all available sections), clearly distinguishing it from sibling read tools like getAuditReport and listAuditReports. The phrase 'toutes les sections disponibles' signals it is the full-audit creation entry point.

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 it: when a complete audit report is needed. It does not explicitly name alternatives or state when not to use it, though the pending-to-ready status hints that follow-up retrieval will be required. More explicit routing to getAuditReport or listAuditReports would strengthen this dimension.

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

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

Annotations already declare readOnlyHint=false, so the description need not restate that it writes. It adds the behavioral detail that draft=true creates an idea without launching the writing, which is useful. However, it does not disclose potential side effects, return values, or asynchronous behavior. The description adds some value beyond annotations but is 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 and front-loaded with the purpose. It uses em-dashes to separate key aspects, making it scannable. It includes the endpoint, which is useful. It could be slightly clearer about the requirement of exactly one source, but it is efficient and not 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?

For a tool with 10 parameters and no output schema, the description is incomplete. It does not mention what the tool returns (e.g., content ID, status), nor does it explain the format parameter (discover/article/guide) or the optional author/persona/category parameters. The lack of output information is a significant gap for an agent needing to confirm success. The description covers the core source selection and draft but leaves much unspecified.

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 10% (siteId). The description compensates for the most critical parameters by explaining the source selection (expression, url, urls, keyword_id) and draft, which are not described in the schema. However, it leaves format, author_id, persona_id, and category_id unexplained, and these may require additional context for correct usage. Overall, the description adds meaningful semantics for key parameters but not all.

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 creates content via automatic writing, lists the four possible input sources (expression, url, urls, keyword_id), and explains the draft mode. This distinguishes it from siblings like getContentIdea or writeContentIdea, which operate on ideas rather than creating content directly. The verb 'Créer' and resource 'contenu' are explicit.

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

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

The description provides clear guidance on how to choose among the source parameters (one of expression, url, urls, keyword_id) and explains the draft flag. However, it does not explicitly state when to use this tool instead of alternatives like createPage or writeContentIdea. The context is implied but not contrasted with other 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 indicate a non-read-only, mutating operation, but the description adds value by disclosing the default draft state, the push_to_cms side effect, and the history logging. These are behaviors not covered by annotations, so the description enhances transparency beyond the structured data.

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 main action, then an important side-effect, and a final note on history. Two sentences carry significant meaning with no fluff, making it efficient 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?

With 19 parameters, no output schema, and only 37% schema description coverage, the description is far from complete. It does not explain the return value, possible status/type effects, or how parameters interact. An agent would lack critical details to correctly invoke and understand the tool's full behavior.

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 37%, so the description must compensate, but it does not. It mentions push_to_cms but fails to explain other parameters like type, status, slug, content, or title_tag. The schema provides descriptions for type and status, but many parameters remain undocumented in both schema and description, leaving the agent without guidance for most inputs.

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 'Créer' (create), the resource 'une page' (a page), and the system 'GPSEM', distinguishing it from sibling tools like updatePage or getPage. It also specifies the default draft behavior and the optional CMS push, making the purpose unambiguous.

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

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

The description provides clear context: it creates a page, default draft, with an option to push to CMS. It implies when to use it (creating a new page) but does not explicitly mention alternatives or when not to use it. It gives enough context for a typical creation scenario, but lacks explicit exclusions.

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

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

Annotations only indicate readOnlyHint=false, idempotentHint=false, and destructiveHint=false. The description adds meaningful behavioral context: creation is conditional on quota, failure yields 402, and the response includes keycms for CMS connection. This goes beyond the structured 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 compact, front-loaded with the core action, and every sentence adds value: the quota condition, the 402 error, the keycms return, and the endpoint. 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?

For a creation tool with no output schema and sparse annotations, the description covers the essential invocation context: endpoint, precondition, failure mode, and return value. It does not explain all input parameters, but the schema partially handles that. Overall, an agent has enough to call it correctly.

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

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

Schema description coverage is 55%, so the schema partially documents parameters like name, goal, site_type, and entrepriseId. However, the description adds no input parameter semantics beyond the endpoint path; it focuses on output and preconditions. With 11 parameters and only partial schema coverage, the description should have compensated more.

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 action ('Crée un site') and resource (site), and distinguishes itself by noting the subscription/quota precondition and the keycms return value. It also includes the exact endpoint, making the tool's purpose unmistakable and distinct from sibling tools like createPage.

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 clear usage context: use only if the active subscription allows it, check subscription.can_add_site via GET /me, and expect a 402 otherwise. It does not explicitly name alternatives, but the precondition and error behavior provide enough guidance for when to call this 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=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds a behavioral nuance: raw data is excluded by default but included when detail=full. This is useful context beyond the annotations, but it does not elaborate on potential side effects of 'collect' (e.g., whether it mutates state) or response format 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 a single sentence, compact and front-loaded with the main purpose and key contents. The parenthetical HTTP endpoint adds useful reference but is placed at the end. It is concise with no filler, though it could be even more direct without the endpoint detail.

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 5 parameters with 2 required and no output schema, the description covers the main purpose and the 'detail' behavior but leaves out guidance on the 'collect' parameter (which may have side effects) and the 'section' parameter's exact format. Sibling tools are numerous, but the description doesn't help disambiguate, so completeness is moderate.

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 80%, and the schema already documents 'detail', 'siteId', 'collect', and 'section'. The description adds no new meaning for these parameters; it merely mentions 'detail=full' as a trigger for raw data. Since coverage is high, the baseline is 3, and the description adds little beyond what the schema already provides.

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 reads an audit report and lists the key contents (scores, synthesis, prioritized action plan with follow-up status, sections). It also mentions the HTTP endpoint format, which adds technical specificity. This distinguishes it from sibling tools like listAuditReports, getAuditSection, and createAuditReport.

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

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

The description does not explicitly state when to use this tool versus alternatives. It provides no context about when to choose this over listAuditReports or getAuditSection, nor does it mention prerequisites like having a valid report ID. The sibling tools are not referenced, so an agent is left to infer use cases from the name and schema.

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, fully covering the safety profile with no contradiction. The description adds genuine behavioral value beyond annotations by disclosing that the section is computed at call time on up-to-date data rather than served from cache, and by enumerating the response composition. It does not address computation cost or potential staleness, which is a minor gap.

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

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

The description is compact at two sentences and front-loads the purpose before the content enumeration and endpoint. The leading phrase repeats the title verb ('Collecter une section d'audit') creating slight redundancy, but every other element — the live-computation behavior, the response breakdown, and the REST endpoint — earns its place.

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

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

For a 7-parameter computation tool with no output schema, the description compensates well by enumerating what the response contains and noting the live recalculation. Safety is fully covered by rich annotations and parameter semantics by the high-coverage schema. Missing are details on how the calculation behaves (cost, rate limits, freshness guarantees) and clearer routing among the audit siblings, but these are moderate, not crippling, gaps.

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

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

Schema coverage is high (86%), so the schema already documents bloc, data, page, limit, detail, and siteId, keeping the baseline at 3. The description adds no parameter-level explanations, but 'cle' gains meaning from the endpoint path (GET /sites/{siteId}/audit/sections/{cle}), clarifying it as the section key and compensating for the one undocumented 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 states a specific verb and resource ('Collecter une section d'audit — Calcule la section maintenant') with a concrete enumeration of the computed content: summary, indicators, findings, prioritized actions (1 = urgent), and detailed data. The live-calculation aspect distinguishes it from the sibling listAuditSections and getAuditReport, so an agent can tell them apart without opening schemas.

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 the many audit-related siblings (listAuditSections, listAuditReports, getAuditReport, listAuditActions). The required 'cle' parameter and endpoint path imply a single-section use case, but there is no explicit when-to-use, when-not-to-use, or alternative routing, leaving the agent to infer.

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, covering the safety profile. The description adds no additional behavioral context such as auth requirements, rate limits, or side effects. It does include the GET method, which aligns with the annotations, but that's redundant. The description doesn't contradict annotations, but also doesn't go beyond 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 a single, concise sentence that front-loads the tool's purpose (coordonnées de l'entreprise) and lists the exact fields returned, followed by the endpoint. There is no wasted text or repetition. It is appropriately sized for a simple read operation with one parameter.

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 tool with one parameter and no output schema, the description is quite complete: it lists all fields that will be returned and the HTTP endpoint. It doesn't mention error cases or response format, but these are less critical for a simple GET. The main omission is a brief note on when to use this vs. getEntreprise, but that's covered under usage guidelines.

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 the only parameter 'entrepriseId' described as 'ID entreprise encodé (hashid)'. The tool description does not add any further meaning to this parameter—it only lists the output fields. Since the schema fully documents the parameter, the baseline of 3 applies, and the description offers no additional semantic 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 clearly states the tool's purpose: it retrieves company contact details (name, type, address, country, VAT, phone, email, website). It also includes the HTTP endpoint, making the operation explicit. It distinguishes itself from sibling tools like updateCompanyInfo by being a read operation, though it doesn't explicitly name alternatives. The verb and resource are specific, and the field list removes 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention conditions, exclusions, or compare with getEntreprise or updateCompanyInfo. An agent is left to infer that it's for reading company contact info, but there's no explicit routing to the correct tool among siblings.

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, covering the safety profile. The description adds that the tool returns status and produced page, which is useful behavioral context. It also specifies the HTTP GET method and path, aiding understanding. 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 single, concise sentence that front-loads the purpose and includes the HTTP endpoint. Every word adds value; there is no 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?

For a simple read operation with only two parameters and no output schema, the description adequately conveys the primary output (status and produced page). It does not detail error conditions or the exact response structure, but given the low complexity and that annotations cover safety, it is largely 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 coverage is 50% (only siteId has a description; id has none). The description does not explain the parameters beyond the schema—it only mentions the output. The id parameter is left undocumented in both schema and description, and the description does not compensate for this 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 clearly states the action (read/lire) and the resource (content idea), and it specifies what is returned (status and produced page). It distinguishes itself from sibling tools like listContentIdeas (list) and createContent/writeContentIdea (write).

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 when you have a specific content idea ID and want to read its status and produced page. However, it does not explicitly state when not to use it or name alternatives like listContentIdeas for browsing. There is no exclusionary 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 important behavioral constraint that the entrepriseId must correspond to the enterprise linked to the token, which is beyond what the annotations state. The GET method also reinforces the read-only nature.

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 very short, front-loaded with the purpose, and followed by the ID constraint and endpoint. The only minor redundancy is that 'Détail entreprise' repeats the tool title, but overall it is compact and clear.

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

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

For a simple one-parameter, read-only detail endpoint with a fully documented schema and safety annotations, the description provides the essential constraint and endpoint. It could be richer by naming the expected return fields or differentiating from getCompanyInfo, but nothing critical is missing for invoking 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 already documents entrepriseId as 'ID entreprise encodé (hashid)' with 100% coverage. The description adds extra parameter-level meaning by requiring the ID to match the token's enterprise, which is not present in the schema. This is modest but useful additional context.

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 (entreprise) and the operation (GET /entreprises/{entrepriseId}), and the title 'Détail entreprise' makes the intent obvious. It does not explicitly distinguish itself from sibling tools like getCompanyInfo, so it loses the point for sibling differentiation.

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

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

The description gives a useful precondition: 'L'ID doit correspondre à l'entreprise du token' (the ID must match the token's company), implying this tool should only be used for the authenticated company's enterprise. However, it does not state when to choose this over alternatives such as getCompanyInfo, or when not to use it.

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 mark the tool as read-only, idempotent, and non-destructive, so the safety profile is covered. The description adds behavioral context beyond that: it is a reference catalog meant to guide subsequent writes, and it discloses the fallback logic and examples of applicable codes. 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 single dense sentence, but every element earns its place: the purpose, the timing, the precision requirement, concrete examples, and the fallback rule. It is front-loaded with the key instruction and avoids 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 zero-parameter, read-only catalog tool, the description is complete. It explains why the catalog exists, when to use it, how to choose a code, and what to do when no code fits. Even without an output schema, the agent has enough context to invoke and interpret 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 has zero parameters, so the baseline is 4. The description correctly focuses on the tool's content and usage rather than parameter details, which would be irrelevant here.

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

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

The description clearly identifies this as a catalog of history codes and explicitly states its purpose: to be read before writing history entries. It distinguishes itself from writing tools like addSiteHistorique by framing itself as a prerequisite reference, and provides concrete examples of codes to make the resource 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 gives explicit when-to-use guidance: consult this catalog before writing history. It also provides a decision procedure: select the most precise code, and if none fits, fall back to a generic code and describe the modification. This is actionable and leaves no ambiguity about how to apply 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=true and idempotentHint=true, establishing a safe, read-only operation. The description adds the HTTP endpoint format and the list of returned data items, which gives context about what the response will contain. It does not disclose any side effects or constraints beyond what annotations imply, but the additional detail on the data included is helpful. With annotations covering the safety profile, a mid score 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 a single sentence that front-loads the resource and immediately lists the data contents, separated by em-dashes. It is efficient, with no redundant wording or filler. The structure is clear and scannable.

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 lists the expected data items, giving the agent insight into the response. However, it does not describe the response format, error conditions, pagination, or any additional context an agent might need for handling the result. For a simple read-only getter with two parameters, this is adequate but not fully comprehensive.

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 describes siteId as 'ID site encodé (hashid)', but id has no description, leaving 50% of parameters undocumented. The description includes the URI template with {siteId} and {id}, implying id is the keyword ID from the tool name, but it does not explicitly define either parameter. The description partially compensates for the missing id description but does not fully clarify 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 identifies the resource as a keyword and its semantic analysis, and enumerates the components (entities, salient terms, related searches, questions, SERP articles, strategy, editorial guide). This distinguishes it from sibling tools like listKeywords and runKeywordSemanticAnalysis. However, it lacks an explicit verb such as 'retrieve' or 'get', relying on the tool name for that. Still, the meaning is clear.

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

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

The description does not explicitly state when to use this tool versus alternatives like listKeywords or getSemanticMap. It implies that it fetches the analysis for a specific keyword ID (via the endpoint path), but provides no conditions, prerequisites, or exclusions. The usage is inferred from the tool name and endpoint rather than explicitly stated.

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

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

Annotations already establish readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds meaningful context by listing the actual returned sections (publisher, hosting, RGPD, CGV, etc.), which helps the agent understand what the GET will produce. 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, single line with em-dash separated content sections and an endpoint at the end. It avoids filler words and every listed item carries information, though a structured list might be slightly easier 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?

With no output schema, the description's detailed outline of returned content serves as the return-value documentation. It also includes the route and the single required parameter is already documented in the schema. Minor details like response format and error behavior are absent but not critical for selecting and calling 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 schema fully covers the single parameter siteId as 'ID site encodé (hashid)', so schema_description_coverage is 100%. The description adds no param-specific meaning, but none is needed since the schema already documents it adequately.

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

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

The description names a specific resource (mentions légales), enumerates its exact contents, and identifies the HTTP method and path (GET /sites/{siteId}/mentions-legales). This clearly distinguishes it from the sibling updateLegalNotice and other site-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?

Usage is implied: when the agent needs to retrieve the legal notice content for a site, this is the tool. However, there is no explicit guidance about when not to use it or any alternative such as updateLegalNotice, so the guidance is minimal.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful context by naming what is returned, but it does not disclose error behavior, authentication failure handling, or any other behavioral details beyond the safe read operation.

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

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

The description is a single compact sentence that front-loads the purpose, states the returned data, and includes the HTTP endpoint. Every part 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?

With zero parameters and no output schema, the description adequately covers the main return values: company, subscription, and site quota. It is complete enough for a simple GET /me call, though a bit more detail about the response shape or error cases would make it fully exhaustive.

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

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

The tool has zero parameters, so there are no parameter semantics for the description to clarify. The schema coverage is trivially 100%, and the description correctly avoids inventing parameters. This matches the baseline for a parameterless tool.

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 clear action and resource: it verifies the token and returns the linked company, subscription, and site quota. This goes beyond the title and makes the tool's purpose concrete, though it does not explicitly distinguish itself from sibling tools like getEntreprise or getCompanyInfo.

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 about when to use this tool instead of alternatives such as getEntreprise or getCompanyInfo. The use case is only implied by the endpoint /me and the token-focused wording, leaving the agent to infer 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 readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds value by detailing what the status report contains, which is especially useful given there is no output schema. 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 dense but efficient, front-loading the resource name and immediately listing the relevant status fields. The endpoint at the end is slightly redundant with the tool name but not harmful. Every listed item contributes to the agent's understanding of the returned data.

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 only one parameter, no output schema, and annotations covering safety, the description is complete: it explains the purpose, the pre-order usage context, and the key return fields. An agent has enough information to invoke this tool correctly and interpret its result.

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%: the only parameter, siteId, is described as an encoded hashid. The description does not add parameter-level detail beyond the schema, so the baseline score 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 a status/state readout for a site's MyBack.link configuration and enumerates the exact data it returns (purchase authorization, monthly cap, spend, credit, options, themes, anchors). This distinguishes it from sibling tools like orderBacklinks or getSiteStats by focusing on pre-order eligibility information.

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

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

The phrase 'À lire avant toute commande' explicitly tells the agent when to use this tool: before placing any order. It does not name alternatives or state when not to use it, but the pre-order context is clear enough to guide selection among the many 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 establish read-only, idempotent, non-destructive behavior, and the description's GET path is consistent with that. The description adds context by stating the report is computed on weekly clicks/visits/engagement and covers anomalies/traffic drift, but it does not disclose edge behaviors such as missing reports or date-boundary handling.

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 compact sentence that front-loads the resource name and follows with useful content detail and the endpoint. Minor redundancy exists between the title and the opening phrase, but there is no padding.

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

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

There is no output schema, so the description should carry the burden of explaining what the agent will receive; it lists report themes but not structure, format, or the valid values for the 'rapport' parameter. An agent would still need additional knowledge to call this tool correctly for a specific report type.

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 67%: the required 'rapport' parameter has no description, and the tool description does not clarify its accepted values (e.g., navrank vs clickrank) or format. The description's mention of NavRank/ClickRank hints at the parameter but does not compensate for the 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 names the resource (NavRank/ClickRank report) and specifies its contents: page priority, recommendations, ML scores, anomalies, and traffic drift computed on weekly stats. It is clear but does not explicitly contrast with the sibling listNavrankReports, leaving some differentiation to the name and GET path.

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 call this tool versus listNavrankReports or getSiteStats, and no prerequisites are mentioned. The only usage signal is implicit: the tool name and the GET endpoint indicate retrieval of a specific report.

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 does not contradict these and adds the URL-search mode ('pageId = « url » avec ?url=') and the concrete set of returned data, including fixed history length and score types. This is meaningful behavior context 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?

The description is a single information-dense sentence that front-loads the purpose and enumerates the valuable response sections before giving the endpoint. There is no fluff, though the title-like opener repeats the tool title.

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

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

For a complex read tool with no output schema, the description gives a strong high-level contract: it names all major response areas, the special pageId/url mode, and the REST route. It doesn't describe low-level JSON structure or error behavior, but the annotation hints plus required parameters make it sufficient for correct invocation.

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

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

The schema already covers all four parameters with descriptions, giving a baseline of 3. The description adds an important invocation detail: when pageId is set to the literal 'url', the tool searches by the url query parameter. This makes the relationship between pageId and url more actionable than the raw schema entries alone.

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

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

The description names the resource ('Fiche complète d'une page') and enumerates the exact data blocks returned: SEO fields, categories, keyword, indexation, four-week scores, history, and Screaming Frog issues. This clearly distinguishes a full single-page detail fetch from sibling list/detail tools such as listPages or getScreamingFrogPage.

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

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

The phrase 'Fiche complète d'une page' plus the field list gives an agent clear context for when to call this tool: whenever a complete page profile is needed. It stops short of explicitly naming alternatives or exclusions, but the GET endpoint and content scope make the usage situation unambiguous.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds what content is returned but not behavioral traits such as default crawl handling, data freshness, or response format; this is acceptable but not richly transparent.

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

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

The description is compact and enumerates the dashboard contents efficiently. However, it starts by repeating the title 'Tableau de bord Screaming Frog' and appends the endpoint as metadata, which adds minor redundancy rather than 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?

There is no output schema, so the description must carry some return expectations. It lists the main components, but it does not describe the structure, score scale, priority representation, or how the optional crawl parameter affects results, leaving meaningful gaps for an agent.

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

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

Schema description coverage is 100%, so both siteId and crawl are already documented. The description does not add parameter-level meaning beyond that, and the baseline of 3 is appropriate since the schema carries the semantic load.

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 returns a Screaming Frog dashboard with crawl, crawl quality, categorized issues with priority and score, 12 priority actions, and most affected pages. This is concrete and specific, though it is phrased as a noun phrase rather than a clear verb like 'Récupère' and does not explicitly compare itself to sibling detail 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 'Tableau de bord' wording implies this is for a high-level dashboard view, but the description does not say when to use this tool instead of listScreamingFrogActions, listScreamingFrogCrawls, or getScreamingFrogIssue. No exclusions or alternative-routing guidance is provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: it specifies the response contents (explanation, correction, evolution between crawls, affected URLs/links, resolved URLs) and pagination (50 per page), which helps the agent expect the data shape. 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 single, compact sentence with clear enumeration of key content and the API endpoint. It is front-loaded with the core purpose. While it could be improved with bullet points for readability, it is concise and contains 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 there is no output schema, the description provides a good sense of the return data (explanation, correction, evolution, URLs, resolved URLs) and pagination. It implies the required parameters (siteId and code) through the tool name and path. Other parameters (filters, sorting) are covered by the schema, so the description is adequate for an agent to understand the call.

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

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

Schema coverage is 89%, so most parameters are well documented. The description mentions pagination (50 per page) which loosely relates to the 'page' parameter, but it does not add deeper semantic meaning beyond what the schema already provides. Since the schema does the heavy lifting, a 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's purpose: getting a report of a specific problem (issue) in Screaming Frog, enumerating the content (explanation, correction, evolution between crawls, affected URLs/links, resolved URLs). This distinguishes it from sibling tools like getScreamingFrogDashboard or getScreamingFrogPage, which target different resources. The verb 'Rapport' and the resource 'problème' provide a specific action and object.

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 what the tool does but gives no explicit guidance on when to use it versus alternatives. It does not mention any conditions, prerequisites, or exclusion criteria. An agent must infer that this tool is for a specific issue code from a crawl, but no direct comparison to sibling tools (e.g., getScreamingFrogDashboard or listScreamingFrogCrawls) is provided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the GET endpoint and the data scope, which is consistent. It does not disclose any crawl dependency or response behavior beyond the content list, but there is 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 compact but somewhat redundant: it repeats 'Problèmes d'une page' from the title and then says 'Problèmes propres à la page,' which restates the same idea. The key specifics (links to errored/redirected URLs, linking pages) and the endpoint are present, but a few words could be trimmed without losing meaning.

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 tool with three schema-covered parameters and no output schema, the description provides a reasonably complete picture of the response content and the endpoint. It could explicitly mention the response shape or the requirement that a crawl exists, but the essential information for calling the tool is present in the description and 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%: url ('URL de la page'), crawl ('ID du crawl'), and siteId ('ID site encodé') are all documented. The description adds no parameter-level meaning beyond the schema, so the baseline score 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 resource as a page's Screaming Frog issues, enumerating the specific data it returns: page-specific problems, links to errored/redirected URLs, and pages linking to an errored page. This distinguishes it from siblings like getScreamingFrogIssue (a single issue) or getScreamingFrogDashboard (an overview). It lacks an explicit action verb, but the name 'getScreamingFrogPage' and the GET endpoint fill that gap.

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

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

The description implies when to use it—when you need problems specific to a page in a crawl—but gives no explicit guidance on alternatives or exclusions. It does not mention how it relates to getScreamingFrogIssue, listScreamingFrogCrawls, or the dashboard. The usage context is inferable from the content, not stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds meaningful behavior beyond these: the default summary mode, the 'full=1' to get all data, and 'refresh=1' to trigger recalculation. It clarifies that the tool can recompute results, which is not implied by the annotations alone. No contradiction with annotations exists.

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

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

Two sentences with dense but efficient information. The purpose is front-loaded, and parameter combinations are compressed into a list. The endpoint URL at the end is slightly redundant but harmless. Overall, it's well-structured and avoids fluff, though the density might make it less scannable than a more sentence-based format.

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 10 parameters and no output schema, the description gives a partial picture. It explains the summary output and the detail mode but doesn't describe what a 'detail' response contains or what the clusters represent beyond 'hors sujet'. The meaning of sort values is left to the schema, and interactions like how 'cluster' and 'page_id' combine are unspecified. This is adequate for a basic call but not fully complete for complex usage.

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 individually documented. The description adds value by grouping parameters into modes (summary vs detail), explaining the effect of 'full' and 'refresh', and indicating which parameters apply to the detail view. This goes beyond the schema's per-parameter descriptions and helps the agent understand how to combine 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 identifies the resource as 'Cartographie sémantique du site' and implies a retrieval action. It clarifies the default output as a summary of clusters and the 50 most off-topic pages, giving a concrete sense of what the tool returns. It distinguishes itself from siblings because no other tool mentions semantic mapping, though it doesn't explicitly state the verb (get) or differentiate from potential similar 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 explains parameter-driven behavior (default summary vs detail, full=1, refresh=1) but provides no guidance on when to choose this tool over alternatives. There are no exclusions or comparisons to sibling tools, leaving the agent to infer that this is the only semantic map tool. This is a clear gap in routing guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds the HTTP method (GET), which is consistent with annotations but does not describe response format, error handling, or any side effects. Since the annotations carry most of the transparency burden, 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 extremely concise, just a single line. It is front-loaded with the purpose and includes the endpoint for reference. There is no waste, though the lack of additional context means it is not 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?

Given the tool's simplicity (single parameter, no output schema, no nested objects), the description is mostly adequate. However, it lacks any mention of what the 'detail' includes (e.g., fields returned) and does not hint at whether the response is the same as listSites items. Given the large number of sibling tools, a bit more context would help, but it's not severely incomplete.

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%, meaning the schema documents the single parameter siteId as a 'hashid'. The description does not add any extra meaning beyond the schema. For a single parameter already well-documented in the schema, the baseline of 3 applies.

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

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

The description says 'Détail d'un site' (Site details) and includes the HTTP endpoint, which makes the purpose clear. However, it does not explicitly differentiate it from sibling tools like getSiteStats or listSites, so it loses a point for lack of sibling differentiation.

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

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

There is no guidance on when to use this tool versus alternatives. The description is purely a statement of what it does, with no mention of scenarios where it should be preferred over listSites (which lists sites) or getSiteStats (which provides stats). An agent would have to infer usage from the name and endpoint.

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 readOnly/idempotent/non-destructive. The description adds valuable behavior: default chronological ordering and automatic exclusion of Google crawls (700-01-003) unless explicitly filtered. It does not describe pagination or output shape, but with annotations covering safety, this is adequate.

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 concise sentences plus the endpoint; no filler, front-loaded with purpose and critical filter behavior.

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 11 parameters and no output schema, the description leaves out essential call semantics: date-range parameters, pagination defaults, meaning of family/category filters, and response structure. It conveys only the core purpose and one exclusion rule.

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 18% of parameters have schema descriptions, so the description carries a heavy burden. It only clarifies that `code` can filter specific event codes (e.g., 700-01-003) and implicitly identifies `siteId` through the endpoint. The many filter/pagination parameters (`from`, `to`, `family`, `page_id`, `page_url`, `category_id`, `cpt_id`, `page`, `limit`) remain unexplained in both schema and 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 states the tool returns a site's history events, sorted from most recent to oldest, and gives the endpoint. This clearly distinguishes it from sibling tools like addSiteHistorique (write) and getSite (current site).

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 implies this is the endpoint to consult a site's history, but provides no explicit when-to-use vs alternatives or exclusions (e.g., when to prefer getHistoriqueCodes or listPages). The only usage nuance is the Google-crawl exclusion.

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 aligns with annotations: readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the GET endpoint confirms a non-mutating operation. It adds the endpoint path but does not disclose additional behavioral traits such as authentication requirements, rate limits, or behavior when the site does not exist. With annotations already covering the safety profile, the description meets the minimum expected value.

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 resource name before listing the returned settings and the endpoint. The field list is useful for an agent to know what this tool returns, and there is no redundant prose or filler, though it could be slightly improved with an explicit active verb.

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

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

For a simple one-parameter, read-only GET tool with no output schema, the description adequately enumerates the setting fields returned and provides the endpoint. It does not describe possible error conditions or response formatting, but given the low complexity and strong annotations, the description is largely complete enough for correct 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 description coverage is 100%, and the schema already defines siteId as an encoded hashid. The description adds no further meaning about the parameter beyond embedding it in the GET path, 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 clearly identifies the resource as site settings and enumerates the specific setting categories it covers (description, sector, positioning, objective, type, internal links, min length, indexing tests, CMS). The trailing GET endpoint makes the retrieval intent explicit, and it is easily distinguished from the sibling updateSiteSettings, though it does not explicitly name that alternative.

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

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

There is no guidance on when to use this tool versus alternatives such as updateSiteSettings, getSite, or getSiteStats. The agent must infer from the GET verb and field list that this is the read-only settings lookup, but no explicit when-to-use or when-not-to-use context is provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is established. The description adds that the statistics follow the GPSEM dashboard and that the call is a GET, which is useful but does not disclose deeper behavior such as auth needs or empty/error responses.

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 the key information is front-loaded: what the stats cover, their dashboard alignment, and the endpoint. It slightly repeats the title with 'Statistiques home du site', but there is no meaningful bloat.

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

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

For a one-parameter, read-only tool with strong annotations and no output schema, the description names the main returned metrics and scopes the resource clearly. It is sufficient for correct invocation, though it could mention response format or authentication for full 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?

The schema describes siteId as 'ID site encodé (hashid)' with 100% coverage, so the parameter semantics are already fully documented. The description adds no parameter-level detail, but none is necessary here.

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

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

The description identifies the resource and specific metrics ('Pages publiées, planifiées, taux d'indexation') plus the GET endpoint, so an agent can tell it is a read-only stats tool for a site. It does not differentiate against sibling getters, which prevents a top score.

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 intended use is implied by the tool name and metric list, and the 'aligné sur le dashboard GPSEM' note gives some context. However, there is no explicit guidance about when to choose this over related dashboard/history/stat 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 establish read-only, idempotent, and non-destructive behavior. The description adds valuable context beyond those annotations: the resource represents an asynchronous API-launched treatment and that finished=true signals completion, which helps the agent interpret polling 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 short, front-loaded with the core meaning, and every element (status, finished flag, endpoint) earns its place. The punctuation-separated structure keeps the information scannable.

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 two-parameter, read-only design, the description is largely complete: it identifies the async nature, the completion signal, and the route. Without an output schema, some return details are left unspecified, but the essential polling contract is present.

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

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

Schema coverage is 50%: siteId is documented as an encoded hashid, while id has only a type. The endpoint string in the description clarifies that id is the task identifier, adding modest meaning, but the description does not otherwise compensate for the undocumented 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 identifies the resource as the status/progress of an API-launched task, and the finished=true flag removes ambiguity about completion. It is not a pure tautology because it adds the endpoint and async-job context, though it doesn't explicitly contrast with sibling 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?

There is no when-to-use or when-not-to-use guidance, and no named alternatives. The only hint is the phrase 'lancé par l'API', which implies polling an async job, but an agent is given no explicit direction about choosing this tool over the many sibling getters.

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, so the safety profile is covered. The description adds useful behavioral context by indicating what data is included in the archive listing and how the returned ID relates to the history, going beyond the annotation-only picture.

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, front-loaded with the resource name, and each sentence adds distinct information: what is listed, key fields, and the ID's role in history. There is 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?

For a simple read-only list call with one required parameter, the description covers the resource, key output fields, and the ID's semantic meaning. The absence of pagination or ordering notes is a minor gap, but overall the description is sufficient for correct invocation.

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

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

Schema coverage is 100% and the only parameter, siteId, is already documented as an encoded hashid. The description does not add further parameter-level detail beyond what the schema provides, 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 a specific verb ('Lister') and a clearly identified resource ('archives (CPT)'), then details what the archive entries contain (slug, import exclusion, published pages). It also distinguishes itself from sibling tools like listPages and listCategories by naming CPT archives as the target.

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 clear context by identifying the resource as site content type archives and explicitly ties the ID to the history mechanism ('L'ID sert de cpt_id dans l'historique'). It does not explicitly name alternatives or state when not to use it, but the resource scope is sufficiently clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond this: actions are sorted by priority then estimated gain, and each action has a stable key and tracking status. This is useful for an agent deciding whether and how to use the result.

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 sentence with the key information front-loaded: the resource, the scope, and the ordering. The endpoint at the end is slightly redundant with the tool name but adds a useful reference. No wasted words, though the phrase 'Plan d'action du dernier audit' and 'Actions du dernier rapport collecté' are somewhat 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?

For a simple read-only list operation with optional filters, the description conveys the core return semantics: actions from the latest audit, sorted, with stable keys and status. There is no output schema, so the description carries the burden of telling the agent what to expect, and it does so adequately. It does not mention pagination or limits, but those are less critical for this type of 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 all parameters (siteId, status, priority) already have descriptions. The tool description does not add meaning beyond the schema, such as filter behavior or default values. This meets the baseline of 3 but does not exceed it.

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 resource ('actions du dernier rapport collecté') and the scope ('dernier audit'), and the sorting criteria make the tool's behavior recognizable. It does not use an explicit verb like 'liste' but the meaning is clear from the name and phrasing. It does not explicitly differentiate from sibling tools such as updateAuditAction or listAuditSections, but the resource is distinct enough.

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 the tool is used to retrieve the action plan from the most recent collected audit report. There is no explicit statement about when to prefer this over updateAuditAction or listAuditReports, nor any exclusion criteria. The context is understandable but the guidance is not explicit.

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 signal read-only, idempotent, non-destructive behavior. The description adds genuine behavioral detail beyond annotations: reports are sorted from newest to oldest and include preview/PDF links. 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 short and front-loaded with the core action, ordering, and return content. The opening phrase 'Lister les rapports d'audit' is somewhat redundant with the tool name/title, preventing 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?

For a simple, one-parameter list tool with no output schema, the description adequately explains what the agent gets back (ordered reports with links). It does not mention pagination or filtering, but these are not clearly required for basic use.

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 siteId parameter is already described as an encoded hashid. The description does not add parameter-level meaning beyond the endpoint template, so the baseline of 3 applies.

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

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

The description clearly states a specific verb and resource: list audit reports for a site, ordered newest to oldest, with preview and PDF links. It is distinct from sibling tools like listAuditSections, listAuditActions, and getAuditReport by identifying 'rapports' as the target resource.

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

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

The description gives clear context: this is for listing all audit reports for a given site, useful before drilling into a single report. It does not explicitly name alternatives or exclusions, so it stops short of a 5, but the intended use case is 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 cover the safety profile with readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the GET endpoint and the response contents, which is useful context, but it does not disclose additional behavioral traits beyond what the annotations already establish.

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 and front-loads the main purpose. The opening phrase repeats the title exactly, and the em-dash structure is slightly fragmented, but every substantive detail—keys, chapters, questions, endpoint—is included without padding.

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

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

For a zero-parameter, read-only list endpoint, the description is nearly complete. It states the endpoint and indicates what the response will contain. A more explicit response shape would help, but given the low complexity and rich annotations, nothing critical is missing.

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

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

The input schema declares zero parameters, so the baseline is 4. There are no parameter semantics to document, and the description correctly implies a simple no-argument call by specifying the GET endpoint.

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 as a catalogue of audit sections and states that it returns the available section keys, chapter, and covered questions. It is specific enough to distinguish from audit reports or audit actions, though it does not explicitly contrast with its closest sibling getAuditSection.

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 about when to use this tool versus alternatives. It does not mention that getAuditSection should be used for a single section's details, nor does it state any exclusions. The intended usage is only implied by the tool name and the word 'catalogue'.

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 the description's extra value is the explicit GET endpoint and the newest-to-oldest ordering. That discloses behavior 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?

The description is compact, front-loaded with the purpose, and adds only useful context: scope, ordering, and endpoint. No filler sentences.

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 list operation, the combination of sorted scope in the description, full parameter docs in the schema, and read-only/idempotent annotations is sufficient. The absence of an output schema is not a major gap for 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?

Schema description coverage is 100%, so the schema already documents siteId, limit, offset, and search. The description adds no additional parameter semantics, so the baseline 3 applies.

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

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

The description names a specific verb-resource pair: listing backlink order history, scoped to 'Commandes MyBack.link du site'. The endpoint and sorting make it distinct from siblings such as orderBacklinks and getMybacklinkStatus.

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 clearly frames the tool as the read-only order history for a site, which is the intended use case. It doesn't explicitly name alternatives or exclusions, but the context is unambiguous enough to route a caller.

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 GET method and notes that the response includes page counts, providing behavioral context beyond the annotations. It does not contradict 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 one concise sentence followed by the endpoint. It is front-loaded with the action and resource, and every element (taxonomy clarification, page count, HTTP method) adds value 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?

For a simple read-only list tool with one parameter and no output schema, the description provides enough context: what is listed, the page-count detail, and the endpoint. It does not mention pagination or fields, but these are not critical for a basic list call.

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

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

Schema coverage is 100% for the single parameter siteId, whose description already explains it as an encoded hashid. The tool description adds no further parameter semantics, so the baseline score of 3 applies.

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

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

The description clearly states the action ('Lister les catégories') and the specific resource ('Catégories (taxonomies) avec leur nombre de pages'). It distinguishes itself from sibling list tools like listSites and listPages by naming the resource explicitly and adding the page-count detail.

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 usage is implied by the resource name, but the description does not explicitly explain when to choose this tool over alternatives or mention any exclusions. There is no guidance on when not to use it, leaving the agent to infer from the resource.

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, covering the safety profile. The description adds that the result includes status and the produced page, which is mild additional context, but it does not disclose response shape, pagination metadata, or ordering 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?

The description is short and front-loaded with the core purpose, followed by the returned fields and the endpoint. The endpoint annotation is arguably redundant with the tool name, but it does not bloat the text.

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

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

With six parameters and no output schema, the description is too thin. It mentions the returned status and page but does not explain filtering behavior, pagination semantics, or the actual response structure. An agent would still need to infer important call-level details.

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

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

Schema description coverage is 100%, so each parameter is already explained (q, page, limit, siteId, source, status). The description adds no parameter-level detail beyond the schema; the baseline of 3 is appropriate because the schema carries the full parameter 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 identifies the action ('Lister') and resource ('idées de contenu'), and adds that results include each idea's status and the produced page. This distinguishes it from the singular getContentIdea and from writeContentIdea, which are the main sibling 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?

There is no explicit guidance about when to use this tool versus siblings like getContentIdea or writeContentIdea. The description implies a listing use case but never states exclusions or alternatives, so an agent must infer 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 readOnlyHint, idempotentHint, and destructiveHint=false. The description adds meaningful behavioral context beyond those: the result set is limited to 'mots-clés suivis' and sorted by decreasing volume, which helps an agent predict output ordering.

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-loaded: it states the action, scope, and ordering in a single line, then gives the endpoint. There is no redundant or filler text.

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

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

The tool is a simple read-only list operation with full input schema coverage and informative annotations. The description covers scope and ordering; the only minor gap is the lack of explicit response-shape details, but no output schema exists and the operation is straightforward.

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 input schema already fully documents all four parameters. The description adds no parameter-specific meaning beyond the schema, so the baseline score 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 action ('Lister les mots-clés') and the resource (tracked keywords), and adds a specific sorting criterion ('par volume décroissant'). This distinguishes it from sibling tools like getKeyword, which retrieves a single keyword.

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 clear context: this tool lists tracked keywords, ordered by decreasing volume. It does not explicitly name alternatives or exclusion conditions, but the plural 'list' intent is unambiguous relative to the single-keyword 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 cover read-only, idempotent, and non-destructive traits. The description adds that results are page-by-page and that the tool belongs to the internal linking audit section, providing useful context but not extensive behavioral detail like rate limits or response format.

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, well-structured sentence that front-loads the core purpose ('Suggestions de maillage interne — Liens à ajouter proposés par GPSEM, page par page') and then adds context. It is concise 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?

For a list-focused tool with a clear schema and annotations, the description provides sufficient domain context to call the tool correctly. The lack of output schema means the description doesn't need to explain return structure, and pagination details are covered by 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 coverage is 100% with descriptions for all four parameters, so the description does not need to explain parameter meanings. It adds no additional parameter-specific info, warranting the baseline score.

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 internal linking suggestions proposed by GPSEM, per page, and identifies it as part of the internal linking audit section. This makes its purpose distinct from sibling audit or page 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 implies usage for internal linking suggestions and mentions the audit section context, but it does not explicitly state when to use this tool over alternatives or provide exclusions. Usage is inferable from the domain but not directly guided.

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 carry readOnlyHint, idempotentHint, and destructiveHint; the description adds the GET verb and the 'available reports' scope, which is consistent and mildly useful. It does not disclose return shape or pagination, but for a zero-parameter catalogue that is a minor gap.

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

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

The description is short, but its first clause duplicates the title almost verbatim. The endpoint fragment earns its place, while 'Rapports Navboost disponibles' adds only modest context.

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 no parameters, read-only annotations, and the endpoint, the description is mostly sufficient for invoking the tool. However, with no output schema, the agent is not told what the catalogue entries actually look like, so completeness is not full.

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 baseline of 4 applies. The description adequately conveys the endpoint and resource without needing to explain 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 identifies the resource as a catalogue of NavRank/ClickRank reports and includes the GET endpoint, so an agent can infer a list operation. It does not state an explicit verb, but 'Catalogue' and the sibling getNavrankReport make the distinction from fetching a single report reasonably clear.

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 getNavrankReport or other list tools, and no conditions or exclusions are stated. The endpoint is provided, but selection criteria are left entirely to the agent.

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

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

Annotations already cover safety (readOnlyHint, destructiveHint, idempotentHint). The description adds value by specifying the returned data includes SEO fields and performance indicators (clicks, impressions, indexing, internal links). It also exposes the endpoint, but doesn't discuss pagination behavior, default limits, or response structure beyond those hints. Since annotations carry the safety profile, a 3 is appropriate – description supplements but doesn't fully elaborate behavioral traits.

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, concise sentence that front-loads the action ('Lister les pages') then specifies the returned content. The HTTP endpoint is included but doesn't bloat it. Every element earns its place; it's efficient and scannable.

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 is a list operation with 11 parameters fully documented in the schema, and the description adds response field context, it's fairly complete. It doesn't explain return format beyond field hints, but that's minor since output schema is absent and the schema covers all inputs. The lack of any mention of filtering or pagination defaults is compensated by the schema descriptions. A 4 reflects that it's nearly complete but could hint at typical usage patterns.

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 every parameter (q, cpt, page, sort, type, limit, siteId, status, indexed, eligible, category_id) already has a description. The tool description adds minimal parameter context beyond mentioning the SEO fields that align with sort options. Baseline 3 is correct when schema fully documents 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 lists pages of a site with SEO fields and indicators (clicks, impressions, indexing, internal links). It identifies the resource (pages) and the action (list), distinguishing it from sibling tools like listSites or listCategories. However, it doesn't explicitly name alternatives, so it loses one point for lack of explicit differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to prefer listArchives for content types or listSites for site-level data. The HTTP path (GET /sites/{siteId}/pages) is given but no context on 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 cover the safety profile (read-only, idempotent, non-destructive). The description adds useful behavioral context by saying actions are prioritized and categories are template/content/highly-linked URLs, but it does not explain ordering criteria, pagination, output shape, or the dependency on a crawl.

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 very short, but the opening phrase 'Plan d'action Screaming Frog' largely repeats the tool title, and the endpoint suffix adds little. It is not overlong, yet part of the text does not earn its place.

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

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

For a simple read-only listing tool with one required parameter and strong annotations, the description is minimally adequate. However, with no output schema, it does not describe the response structure, and it offers no selection guidance among the many audit/Screaming Frog sibling tools.

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, so every parameter (siteId, crawl, priorite, categorie) is already documented. The description adds no extra parameter semantics, but the baseline of 3 is appropriate because the schema carries the load.

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 a specific resource — the Screaming Frog action plan — and states that it returns prioritized corrective actions grouped by categories (template, content, highly linked URLs). It is clear enough to distinguish from crawling/dashboard siblings, though it does not explicitly call out any sibling tool.

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

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

There is no guidance on when to use this tool versus alternatives such as listAuditActions, getScreamingFrogDashboard, or getScreamingFrogIssue. The description does not mention prerequisites like an existing crawl or explain how this differs from other audit/action 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 declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds minimal context ('Crawls importés du site') but does not disclose any additional behavior like pagination, result size, or field details. With annotations present, the bar is lower, and the description provides some value.

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, efficient sentence that front-loads the purpose and includes the HTTP method and resource path. 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?

Given the low complexity (one parameter, no output schema), the description is adequate but minimal. It does not explain what a crawl contains or any pagination/filtering behavior, which could be useful for an agent expecting a list. However, for a simple read-only list operation, it is not severely incomplete.

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 siteId described as 'ID site encodé (hashid)'. The description does not add any parameter-specific meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the verb 'Lister' (list) and the resource 'crawls', and clarifies they are imported from the site. The HTTP method and path reinforce the resource. This distinguishes it from siblings like listScreamingFrogActions and getScreamingFrogDashboard.

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. While the name suggests it lists crawls, there is no mention of exclusions or comparisons to sibling list tools, leaving the agent to infer its scope.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful details like the HTTP GET endpoint and the return fields, but it does not mention pagination, error behavior, or any other operational nuance.

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 packs the endpoint, resource, and returned fields into a single line. There is slight redundancy between the title 'Lister les sites' and the descriptive start, but no unnecessary elaboration.

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 low-complexity list operation with one required parameter and no output schema, the description gives enough information: it identifies the resource, the filter (entrepriseId), and the fields returned. It could mention pagination or error scenarios, but these are not critical for correct invocation here.

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%: entrepriseId is documented as an encoded hashid. The description mentions 'ID encodé' but does not add meaning beyond what the schema already provides, 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 clearly states the action ('Retourne tous les sites') and the resource ('sites de l'entreprise'), and specifies the output includes encoded ID and URL. This distinguishes it from sibling tools like getSite (single site) and createSite (creation).

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 makes the intended use case clear—retrieving all sites for a given enterprise—but it does not explicitly state when to prefer an alternative such as getSite or createSite. There is no misleading guidance, but the when/why choice is left to inference.

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

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

Beyond annotations, the description discloses that this is a real financial debit, that user consent must be obtained, that the API can return 403 purchase_refused, and that the order is recorded in history with specific codes. These are meaningful behavioral traits an agent needs to know before invoking a purchase action.

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

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

The description is moderately dense but every clause adds operational value: real debit, consent requirement, failure mode, and history logging. It repeats the title and endpoint, but the endpoint is useful and the length is still justified for a purchase operation.

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 9-parameter purchase action with no output schema, the description covers the critical context: it is a real paid action, user confirmation is mandatory, failure can occur, and the order is stored. It does not describe the response format, but the provided behavior and endpoint make the tool adequately complete for an agent to invoke it safely.

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 nine parameters. The description adds little param-level detail beyond restating 'Un article par entrée de urls', which duplicates the urls field description. This is the correct baseline when structured schema data carries the parameter documentation 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 states a specific verb and resource: 'Commander des backlinks' and 'ACHAT RÉEL débité sur le crédit MyBack.link', making the action unmistakable. It is clearly differentiated from read-only siblings like listBacklinkOrders by emphasizing that this performs a real purchase. The endpoint is also provided as confirmation.

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 explicit call conditions: show the user URLs, keywords, article count, and options, and wait for explicit consent before calling. It also mentions refusal conditions (purchase disabled or company cap reached). It does not explicitly name competing tools or state when not to use it, but the consent precondition provides clear usage 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?

The description states the tool 'overwrites' the GPSEM version, which is a destructive action, but the annotations declare destructiveHint=false. This is a direct contradiction. Additionally, no details on permissions, reversibility, or response behavior are provided, and the annotations do not compensate.

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 plus an endpoint. It front-loads the core action and overwritten fields. The endpoint inclusion is somewhat redundant with the tool name but not harmful. No unnecessary 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?

For a write operation with only 2 parameters and no output schema, the description should clarify side effects, reversibility, and required permissions. It mentions overwriting and recording a code but omits auth requirements, failure modes, and behavior beyond the overwrite. The contradiction with destructiveHint further reduces 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 coverage is 50%: only siteId has a description ('ID site encodé (hashid)'), pageId has none. The description does not explain either parameter beyond what the schema provides, and does not compensate for the missing pageId documentation. It does mention overwritten fields but not how they relate to 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 uses a specific verb ('Réimporter') and resource ('une page depuis le CMS'), and clearly states the action: overwriting the GPSEM version with the CMS version, listing the fields affected (title, content, tags, status, categories). This differentiates it from the sibling 'pushPageToCms' by direction.

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 the usage direction (CMS to GPSEM) and what it overwrites, but does not explicitly state when to use this tool versus alternatives like 'pushPageToCms' or when to avoid it. No exclusions or prerequisites are mentioned.

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 this is a write operation (readOnlyHint=false) and non-idempotent (idempotentHint=false). The description adds valuable behavioral detail: it can either create or update an article, and it records a specific code (300-05-001) in history. This extra context beyond the annotations helps the agent understand side effects, justifying a 4.

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 very concise, with three compact sentences. The primary purpose is front-loaded, followed by the side effect and the endpoint. Every sentence adds value: verb+resource, create/update distinction, history code, and HTTP method. There is 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 the simplicity of the tool (2 params, no nested objects, no output schema), the description is mostly sufficient. However, it lacks details on the operation's effects (e.g., what happens to existing content, success/failure indicators) and does not explain the history code's significance. An agent might need more information to handle errors or verify success, so a 3 is fair.

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 50%, with only siteId having a description ('ID site encodé (hashid)'). The description does not explain the parameters further; it only implies the context. Since high coverage would be a baseline of 3, but here coverage is lower, the description should compensate, but it doesn't. The siteId description in schema helps, but pageId lacks any description in both schema and tool description, so a 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 'Envoie' (send) and the resource 'page' to the CMS, with the purpose of creating or updating an article. It distinguishes from siblings like pullPageFromCms by the direction (push vs pull). The inclusion of the HTTP endpoint adds specificity, but it does not explicitly name sibling 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 implies when to use this tool (when you need to send a page to the CMS) and contrasts with pullPageFromCms through the verb. However, it does not provide explicit exclusions or specify when to use a sibling like updatePage. The context is clear enough for an agent to infer, but lacks 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?

Annotations already mark this as a mutating, non-idempotent operation, and the description adds valuable async behavior: processing takes a few minutes and the caller must follow a task_id. This is useful context beyond the structured fields and does not contradict 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 a compact single sentence with the purpose front-loaded, followed by workflow and endpoint. It repeats the title's phrasing slightly but every segment adds information needed to invoke and monitor the operation.

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 an async operation with no output schema, the description explains the wait time and names the exact follow-up tools (getTask, getKeyword). It does not describe the launch response shape in detail, but the provided workflow is sufficient for correct invocation.

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

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

Schema coverage is only 50% because id lacks a description. The description's endpoint clarifies that id refers to a keyword, and siteId is already documented as a hashid. It partially compensates for the gap but adds no format, constraint, or relationship details beyond the path.

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 a specific verb ('Lancer') and resource ('analyse sémantique d'un mot-clé'), reinforced by the endpoint. It also distinguishes this tool from siblings by framing it as an async launch that requires follow-up via getTask and getKeyword.

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 clear workflow guidance: launch the analysis, track the task_id with getTask, then read getKeyword. It does not explicitly state when-not to use the tool, but the sequential context with siblings is strong enough to orient 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 flag readOnlyHint=false and destructiveHint=false. The description adds the key behavioral detail that the operation runs 'En tâche de fond' (in the background), which is not present in annotations. It also clarifies the data-flow direction for each action, but does not disclose how the background task can be monitored or whether existing data is merged or overwritten.

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 concise sentence with em-dash separators: it states the purpose, defines both actions, mentions background execution, and includes the HTTP endpoint. Every part earns its place with no repetition 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 background operation with no output schema, the description leaves a notable gap: it does not say how the agent will know when the sync finishes or how to track progress. A sibling tool 'getTask' exists and could be the intended follow-up, but the description does not mention it. For a two-parameter bulk sync tool this is the main missing piece.

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 only 50% because the 'action' parameter has an enum but no description. The tool description compensates by explaining what 'import' and 'push' actually do. 'siteId' is already described in the schema as an encoded hashid, and the endpoint string reinforces its role.

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 synchronizes the entire site and breaks down the two specific actions (import = bring CMS content into GPSEM; push = send followed pages to CMS). This clearly identifies a bulk operation distinct from the individual page-level siblings like pushPageToCms and pullPageFromCms.

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 clear context for when to use each action via the import/push definitions, and the phrase 'tout le site' makes the bulk scope explicit. However, it does not explicitly name alternatives or state when NOT to use this tool in favor of single-page operations.

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

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

Annotations already declare readOnlyHint=false (write operation), destructiveHint=false, and idempotentHint=true. The description adds a key behavioral detail not in annotations: setting status to 'fait' registers the action in the site's history (100-09-002). This is a meaningful side-effect that helps the agent anticipate consequences. It does not contradict annotations and provides extra context beyond the structured metadata.

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, roughly three clauses separated by em-dashes. It front-loads the main purpose and includes a concrete example of a side-effect. However, the inclusion of '100-09-002' is cryptic and may be an internal code that adds noise without clear explanation. Overall, it is concise but could be more polished in structure.

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 6 parameters, low schema coverage, and no output schema, the description is incomplete. It explains the core purpose and the 'fait' side-effect but does not describe the expected response, error conditions, or the semantics of optional parameters like comment and due_date. An agent would need to infer behavior from the schema alone, which is insufficient for a reliable call.

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

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

Schema description coverage is only 17% (only siteId has a description). The description compensates by explaining that 'cle' is the key from GET …/audit/actions, which is useful. However, it does not add meaning for the other parameters (owner, comment, due_date) beyond what the schema provides. Status is an enum, so its meaning is inherent, but the description fails to clarify the optional fields or their formats, leaving significant gaps in 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 the exact purpose: 'Mettre à jour l'état d'une action' (update the status of an action), identifies the resource (audit action) and the verb (update), and even specifies the endpoint (PATCH /sites/{siteId}/audit/actions/{cle}). It distinguishes itself from sibling tools like listAuditActions by implying a write operation on a specific action, and the mention of the key from GET …/audit/actions further clarifies the target resource.

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

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

The description provides clear usage context: it updates the status of an audit action and requires the key ('clé') obtained from GET …/audit/actions. This implicitly tells the agent when to use this tool (when modifying an audit action status) without explicit alternatives or exclusions. It does not mention when not to use it, but the context is sufficient for an agent to distinguish from read-only 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 indicate that this is a non-read-only, non-destructive, idempotent operation. The description adds value by specifying PATCH semantics and stating that all getCompanyInfo fields are optional, which conveys a partial-update behavior beyond what the 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 a single compact sentence containing the action, the acceptable fields, optionality, and the HTTP endpoint. There is no filler, and the most important information is front-loaded.

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

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

For a two-parameter PATCH tool with no output schema, the description is nearly complete: it gives the purpose, source of fields, optionality, and method. A sentence about the response shape would be a minor improvement but is not necessary for correct invocation.

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

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

The schema already lists the body field names, but the description adds meaning by saying these are exactly the fields of getCompanyInfo and that all are optional. This helps an agent construct a valid partial body and tells it where to find the authoritative field definitions.

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, 'Modifier les coordonnées de l'entreprise', and clarifies the body contract by referring to the fields of getCompanyInfo. Together with the PATCH endpoint, this makes the operation unambiguous and distinguishes it from sibling update tools that target other resources.

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 clearly states that this tool modifies company information and that its fields come from getCompanyInfo, all optional. It does not explicitly name excluded alternatives, but there is no competing sibling for updating company info, so the usage context is clear enough.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true. The description adds that all body fields are optional ('tous facultatifs'), indicating partial updates, and specifies the HTTP method (PATCH). It does not contradict annotations and provides useful behavioral context beyond 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 a single line broken into three clear segments: purpose, field source/optionality, and HTTP endpoint. It front-loads the action and contains no filler, making it highly efficient.

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

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

For a two-parameter update tool with annotations covering safety and idempotency, the description provides the essential context: the action, the field source, optionality, and the HTTP method. It does not describe the response format (no output schema), but the absence is not critical given the tool's simplicity and the reference to getLegalNotice for field shapes.

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 covers both parameters with descriptions (siteId as 'ID site encodé (hashid)' and body listing many field names). The description adds that these fields come from getLegalNotice and are all optional, which clarifies the expected body structure and update semantics beyond the schema's static field list.

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 'Modifier' and the resource 'mentions légales', making the tool's purpose explicit. It also references the fields of getLegalNotice, distinguishing this update operation from its read counterpart and other update tools like updateSiteSettings. The HTTP method and path add precision.

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 by mentioning 'Champs de getLegalNotice', suggesting one might fetch first, but it does not explicitly state when to use this tool versus alternatives or provide exclusion criteria. It names no sibling alternatives or conditions for selection, leaving the agent to infer from 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=false, destructiveHint=false, idempotentHint=true, openWorldHint=true. The description adds valuable behavioral context: every change is recorded in history (listing the specific tracked fields), and push_to_cms=true sends the page to the CMS afterward. This goes beyond the annotations by explaining the side effect of history logging and the conditional CMS push. 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 single sentence with a parenthetical list of fields and the HTTP endpoint. It's compact and front-loaded with the main action. The field list is long but necessary to convey scope. The endpoint at the end is useful context. No wasted words, though the field enumeration makes it slightly dense.

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 20-parameter mutation tool with no output schema, the description covers the main behavior (partial update, history logging, optional CMS push) but doesn't explain return values, error conditions, or prerequisites (e.g., does the page need to exist? what happens if push_to_cms fails?). The annotations cover idempotency and non-destructiveness, but the description doesn't address what the response contains or how to handle partial failures. Given the complexity, this is a moderate 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 35%, so the description must compensate. The description lists many field names (statut, titre, contenu, balise title, meta description, H1, slug, catégories, mot-clé, importance) but doesn't explain their formats or semantics beyond what the schema already provides. It does clarify that category_ids replaces categories and push_to_cms sends to CMS, which adds some value. However, with 20 parameters and low coverage, the description could do more to explain parameter relationships (e.g., status enum meanings are in schema, but not in 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 'Modifier une page' (modify a page) and specifies it's a partial modification (PATCH), listing the exact fields that can be changed. It distinguishes itself from createPage and pushPageToCms by mentioning the push_to_cms behavior. However, it doesn't explicitly contrast with sibling tools like createPage or pullPageFromCms, so it's clear but 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?

The description implies usage: use this to partially update a page, and if push_to_cms=true, it will also send to CMS. It mentions the HTTP method PATCH, which signals partial update semantics. It doesn't explicitly state when NOT to use it (e.g., use createPage for new pages, use pushPageToCms for pushing without editing), but the context is clear enough for an agent to infer.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false. The description adds the valuable detail that all fields are optional, indicating partial updates are possible, and reveals the PATCH method. It does not contradict annotations and provides useful behavioral context (partial update semantics) beyond what annotations state.

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 exceptionally concise: a single sentence plus the endpoint. It front-loads the action, then adds the relationship to getSiteSettings, and finally the HTTP method. There is no filler or repetition, and every element contributes to the agent's understanding.

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

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

For a tool with two parameters and a nested body, the description provides the essential context: it links the body fields to getSiteSettings and states they are optional, which guides the agent on what to send. The lack of return-value specification is a minor gap, but the overall guidance is adequate for correct invocation, especially given the reference to the GET tool for field details.

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% (both parameters have descriptions). The tool description reinforces that the body fields are from getSiteSettings and explicitly states 'tous facultatifs' (all optional), which is not evident from the schema alone. This adds meaningful semantic clarity about the body parameter's flexibility.

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 'Modifier les paramètres du site' (modify site settings), identifies the resource (site settings), and references the associated GET tool (getSiteSettings) to define scope. It distinguishes from siblings like updateCompanyInfo or updatePage by explicitly naming the target as site settings and including the PATCH 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 effectively tells the agent that the body fields correspond to getSiteSettings and that all are optional, implying a fetch-then-modify workflow. It does not explicitly mention alternative tools or when not to use this one, but the reference to getSiteSettings provides clear contextual usage guidance beyond mere identification.

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 readOnlyHint=false (write operation) and destructiveHint=false (not destructive). The description adds the 'automatic writing' aspect, implying an async process, but doesn't disclose side effects, whether it overwrites existing content, or what the response looks like. With annotations present, the bar is lower, but the description provides only marginal additional behavioral context.

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

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

The description is concise—one sentence with a dash-separated note. It front-loads the action and includes the HTTP endpoint, which is useful for debugging. No unnecessary fluff, though the endpoint could be considered extra. Overall, 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 write operation with no output schema and minimal annotations, the description is incomplete. It doesn't state what happens after launching (e.g., creates a content draft, runs in background, takes time), nor does it mention required parameters (siteId, id) or optional format. An agent would need additional context to call this correctly and anticipate outcomes.

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 33% (only siteId is described). The description mentions no parameters at all—it doesn't explain what 'id' refers to or how 'format' affects the output. Since coverage is low, the description should compensate but fails to do so, leaving the agent to guess about 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 states the action: 'Lance ou relance la rédaction automatique d'une idée existante' (Launches or relaunches automatic writing of an existing idea). It specifies the verb (launch/relaunch), the resource (an existing idea), and distinguishes from siblings like createContent (which creates new) and getContentIdea (which retrieves). This is specific and 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?

The description implies usage: you call this to trigger or retrigger content generation for an existing idea. It doesn't explicitly name alternatives or say when not to use it, but given siblings like createContent and getContentIdea, the context is reasonably clear. A slightly more explicit exclusion (e.g., 'use createContent for new ideas') would elevate it, but it's acceptable.

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