eglise.shop — Christian bookstore (FR/EN)

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

Annotations already flag a non-idempotent, non-destructive write, so the bar is lower; the description still adds the concrete capacity ceilings that annotations cannot express. It does not say what happens when a cap is exceeded (error vs. partial add), which is the one behavioral 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?

Two short sentences with zero filler: the action and the id provenance come first, then the hard caps. Everything stated is actionable.

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 three-parameter mutation with a well-described schema, the description covers action, valid id sources and limits. The missing piece is failure behavior on cap violation and confirmation of what the response contains, though the currency field already notes the XOF price is always returned.

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 67% and the schema already documents cart_id, currency and quantity bounds in detail. The description still adds meaning beyond the schema by declaring the cart-level limit of 20 distinct books and by pinning the id source, which the nested items.id field leaves unqualified.

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 pairs a specific verb ('Ajoute') with a precise resource ('un ou plusieurs livres ... au panier') and even names the sibling tools that produce valid inputs (search_books, get_book). This makes it distinguishable from create_cart, which provisions the cart rather than filling it.

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

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

It tells the agent what inputs to use (book ids from search_books/get_book) and states the operating envelope: 20 distinct books, 10 copies per book. It stops short of naming alternatives or exclusions (e.g., that remove_from_cart handles reductions, or that create_cart must run first), so usage is strongly implied rather than fully enumerated.

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

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

Beyond the annotations (which only tell the agent this is a non-idempotent, non-destructive write), it discloses the anonymity of the cart, a concrete rate limit (10 per hour) and hard quotas (20 distinct books, 10 copies per book). It also discloses the return value cart_id, which matters because there is no output schema.

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

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

Three short sentences, front-loaded with purpose, then return contract, then limits. Every sentence carries distinct information with no padding or repetition.

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

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

For a one-parameter creation tool with no output schema, the description covers purpose, the return contract, rate limits and quotas — everything needed to call it correctly. Minor omissions such as cart lifetime/expiry or authentication expectations keep it from being fully 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?

The single 'site' parameter is fully documented in the schema (100% coverage, enum with default and catalogue sizes). The description's restatement of the fr/en domain mapping adds nothing beyond that, so the baseline of 3 for high schema coverage applies.

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

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

States a concrete verb and resource ('Crée un panier anonyme') plus the two storefronts it applies to, which immediately distinguishes it from read-oriented siblings like get_cart. The scope ('anonyme', site fr/en) is specific enough that an agent can select it without opening the schema.

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

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

The description routes the agent forward by explaining the returned cart_id is meant to be reused 'dans les autres outils du panier', which clarifies its position as the entry point of the cart flow. It stops short of explicit when-not conditions (e.g. what to do if a cart already exists) and names no sibling as an alternative, so it is clear context rather than full routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description adds real value beyond that by disclosing which fields come back and that some are conditional ('si renseigné', 'si indiqué'), plus that the base XOF price is always included alongside the requested currency. It omits failure behavior for an invalid id/url.

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

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

Two compact sentences, front-loaded with what the fiche contains followed by the accepted identifiers. Dense but every clause adds information; only minor tightening is possible.

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 five optional parameters and no output schema, the description sensibly enumerates the returned fields so the agent knows what a call yields. It is nearly self-sufficient, missing only edge-case handling (no identifier supplied, conflicting identifiers, unknown book).

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 explains id, url, site, slug and currency in detail. The description only restates that id/slug/url are acceptable identifiers and gives no extra constraint (e.g. precedence when several are supplied), so the baseline 3 applies.

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

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

States a specific verb+resource (fetch the full record of one book from eglise.shop) and enumerates the returned fields (résumé, description, auteurs, ISBN, éditeur, prix, lien). It also implicitly separates itself from search_books by noting the id is 'renvoyé par search_books', so an agent can pick the right tool 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?

Tells the agent which inputs to supply (id from search_books, or slug, or product URL), which is a clear usage path. It does not explicitly say 'use search_books first to discover the id' nor when not to use this tool, so it stops short of full when/when-not guidance.

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

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 genuinely useful context beyond that: the base-currency XOF total is always returned regardless of the requested currency, and shipping fees are deliberately excluded (deferred to payment). It does not cover error cases such as an invalid or expired cart_id.

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

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

Two tight sentences with zero filler, front-loading what the tool returns before the currency behavior and the shipping exclusion. Every clause carries information.

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

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

With no output schema, the description must carry the return-value burden and does so reasonably (contents, subtotal, total, mandatory XOF total). Combined with annotations covering the safety profile and 100% schema coverage on inputs, the main remaining gap is error/edge-case behavior for an invalid or expired cart.

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 cart_id and currency are already documented in the schema, including the enum list and the XOF-always-returned rule. The description restates the currency/XOF behavior but adds no new syntax or format detail, which is the expected baseline of 3 when the schema does the heavy lifting.

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

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

The description names the resource (panier) and enumerates the returned data (contenu, sous-total, total, plus a mandatory XOF total), so an agent knows exactly what this read tool yields. It does not explicitly differentiate itself from siblings like add_to_cart or start_checkout, but the resource noun makes the distinction obvious in context.

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

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

Usage is only implied: 'Les frais de livraison sont calculés au paiement' hints that shipping costs belong to the checkout step, weakly routing the agent toward start_checkout rather than this tool. There is no explicit when-to-use statement, no prerequisites, and no named alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. With no output schema, the description usefully discloses the return shape (counts, slugs, parent), but it says nothing about result size, pagination, or ordering for a list endpoint. Adequate but not rich.

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

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

A single front-loaded sentence with zero filler. Purpose, scope, and returned fields are packed in efficiently, and no sentence fails to 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 non-destructive read-only list tool with fully documented parameters and no output schema, the description covers purpose and return content well. The only gap is that it doesn't surface the default filtering behavior (books_only=true, empty categories excluded) that materially shapes results.

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

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

Schema description coverage is 100%, so all four parameters (site, parent, books_only, include_empty) are already documented in the schema, setting the baseline at 3. The description adds no parameter-level detail beyond schema, only hinting at the site being eglise.shop.

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

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

States a specific verb and resource ('Liste des catégories (rayons)') and goes further by naming the payload fields returned (article count, slug, parent category), which tells the agent exactly what it gets. It also ties its output to the sibling search_books, aiding disambiguation, though it never explicitly says when to prefer it over that sibling.

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

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

Usage is only implied: by noting the slug is 'utilisable dans search_books', it hints at a lookup-then-search workflow, but there is no explicit when-to-use, when-not, or prerequisite statement. An agent can infer the intent but must read the sibling to confirm the relationship.

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

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

Annotations already declare readOnly, idempotent, open-world, and non-destructive behavior. The description adds only that the order key appears in the confirmation email or URL, which is a useful sourcing hint but not a rich behavioral disclosure such as authentication/verification details, rate limits, or return behavior.

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

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

Two short sentences front-load the purpose and then list prerequisites. Every clause earns its place, with no repetition or structural waste.

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

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

For a simple read-only status lookup, annotations cover safety and the schema covers the 'site' enum well. The description supplies required parameters and order-key origin, though without an output schema it could say more about the returned status payload.

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

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

Schema description coverage is low at 25%, so the description must compensate. It names the three required parameters and explains where to find the order key, but it omits the optional 'site' parameter and adds little semantic detail for order_id beyond 'numéro de commande'.

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 'Statut d'une commande', clearly identifying the order-status retrieval resource. It does not name a sibling or explicitly differentiate itself, but the resource is unambiguous and distinct from all listed cart, book, and checkout siblings.

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

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

It lists the required inputs (order number, order key, billing email) and implies use when checking an order's status. However, it gives no explicit when-to-use/when-not-to-use guidance or named alternatives, so usage remains inferred rather than stated.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered by structured data. The description adds useful scope detail (one book vs. the entire cart), but says nothing about behavior when both key and all are supplied, or about permission/auth requirements.

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

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

A single front-loaded sentence with no filler; the primary action precedes the alternative mode. Every clause earns its place.

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

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

For a three-parameter destructive mutation with no output schema, the description covers both modes and the key's provenance. Minor gaps remain (precedence when both key and all are given, error behavior for an invalid key), but 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?

Schema coverage is only 33% ('all' and 'key' are undocumented in the schema), so the description must compensate: it explains that 'key' is the identifier returned by get_cart and that all=true empties the whole cart. That meaningfully disambiguates both optional parameters beyond the bare schema types.

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

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

States a specific verb and resource ('Retire un livre du panier') and distinguishes two distinct modes of operation (single item by key vs. full clear via all=true). An agent can tell it apart from siblings like add_to_cart and get_cart immediately.

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

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

Explicitly states the two usage modes and the condition selecting each (key for one book, all=true to empty the cart), and routes the agent to get_cart as the source of the key. No explicit exclusions or error-case guidance, but context is clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so safety behavior needs no restating. The description adds useful context about output (XOF always returned alongside the requested currency, a link is produced, availability is reported), but says nothing about pagination limits or result 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?

Two sentences, zero filler: the search axes come first, the return payload second. Every clause earns its place and nothing is repeated from the structured fields.

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

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

For a 10-parameter, zero-required search tool with no output schema, the description covers purpose, searchable fields and return shape adequately. However, it never mentions that 'site' selects between two separate catalogs (~5 600 FR vs ~2 800 EN books) or that per_page caps at 20 — meaningful constraints an agent could miss.

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?

At 70% schema description coverage the baseline is 3, but the description adds real meaning beyond the schema: it specifies that keywords are matched against titre, résumé and auteur, and that the price filter is a 'fourchette' mapping to min/max. It still leaves the site (fr/en shop), orderby and page/per_page parameters unelaborated.

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

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

States a precise verb and resource ('Recherche dans le catalogue d'eglise.shop') and enumerates the search axes (mots-clés, catégorie, fourchette de prix) plus the returned fields. This cleanly separates it from get_book (single record lookup) and list_categories (taxonomy listing) without 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?

No explicit when-to-use or when-not-to-use statement, and no sibling is named as an alternative (e.g. use get_book when the ISBN/ID is already known). Usage is only implied by the available filtering dimensions, which lands at 'implied usage'.

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

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

Goes well beyond the annotations by disclosing link lifetime (30 min), a hard rate limit (5 links/hour), that the merchant sees no payment data, and that no order is created — exactly the operational context readOnlyHint/openWorldHint cannot convey. No contradiction with idempotentHint=false, since each call yields a fresh link.

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?

Five short sentences, front-loaded with what is returned and how long it lasts, then the interaction model, then the limit. Every sentence carries a distinct fact; nothing is padding.

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

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

With only two well-documented parameters, no output schema, and annotations covering the safety profile, the description fills the remaining gaps an agent needs: what comes back, its validity window, who pays, and the throughput cap.

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 already 100%, but the description adds real meaning: it explains the currency is forwarded to the site via ?wmc-currency= and that the XOF base price is always returned alongside. It does not name cart_id or spell out the currency enum's FR/EN variation, which lives in the schema.

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

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

States a concrete verb+resource: returns a payment link (valid 30 minutes) that opens the site's payment page for a given cart and currency. It also scopes what it does NOT do (no order created, no payment data seen), which separates it from the order/status siblings, though no sibling is named explicitly.

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?

'À donner au client. C'est le client qui paie lui-même' makes the usage context clear, and 'Le connecteur ne crée aucune commande' tells the agent not to expect an order afterwards. There is no explicit pointer to which sibling to use instead or when to prefer order_status, so it falls short of a 5.

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