Tchin

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

Adds real context beyond the annotations: the requirement to be connected to a Tchin account (connection requested the first time) and the concrete consequence that a deactivated link can no longer be paid. That effect is worth stating given destructiveHint=false, since an agent might otherwise assume deactivation is purely cosmetic. It stops short of saying whether the toggle is reversible or what response is returned.

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 efficient sentence with no filler. It is slightly back-loaded: the audience and connection prerequisite precede the actual action, so an agent scanning for the verb finds it second.

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 idempotent toggle with no output schema, the description covers the action, the audience, the auth prerequisite, and the effect of deactivation. Only edge cases (already-in-desired-state, error behavior, reversibility) are unaddressed, which is a minor gap given annotations already declare idempotency and non-destructiveness.

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% — 'lien' is documented in the schema, but 'actif' has no description anywhere. The description's 'active ou désactive' hints at the boolean's meaning but never states that true activates and false deactivates, so it adds only marginal value over the schema.

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

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

States a specific verb pair ('Active ou désactive') on a specific resource ('lien de paiement du marchand'), which separates it from generic link tools like modifier_lien or supprimer_lien. It also clarifies the resource is a merchant payment link rather than a withdrawal link, though it never explicitly names the sibling to prefer.

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?

Implies the use case (merchant or individual managing their own payment link) and states an authentication precondition, but gives no explicit when-to-use guidance versus modifier_lien, supprimer_lien, or afficher_lien_tchin, and no when-not conditions.

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

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

Beyond the readOnly/idempotent annotations, it explicitly discloses that no payment is executed and no money moves, and that the user personally chooses the method and validates in the form (phone code, Tchin PIN, wallet). This is exactly the safety-critical context an agent needs before invoking a payment-adjacent tool.

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

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

The core intent and the no-payment disclaimer are front-loaded, but the closing sentence repeats the opening trigger almost verbatim, adding length without new 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?

For a single-parameter, read-only display tool with no output schema, the description covers what is shown, what is explicitly not done, and who acts next — nothing an agent needs in order to call it correctly is missing.

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

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

Schema coverage is 100% and the single parameter already documents both accepted forms (full URL or short code abc123). The description adds no format or validation detail beyond that, so the baseline of 3 applies.

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

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

States a specific verb and resource: it displays the secure payment form of a tchin.tech/pay link inside the conversation, listing what the form contains (marchand, objet, montant). It is clearly distinct from creation/manipulation siblings like creer_lien_paiement and modifier_lien, since it only renders an existing link.

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?

Explicit trigger conditions are given: call it as soon as the user shares a tchin.tech/pay link, or says they want to pay, settle, or view a Tchin payment. It does not name a specific sibling alternative or an exclusion case, so it falls short of a full when/when-not/alternatives statement.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds genuinely new context: "sans compte" (no authentication required) and the return shape ("rend les passages utiles avec leur source"). It does not say what happens when the documentation has no matching passage, which is the main remaining 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 sentences, zero filler. The search scope is front-loaded and the usage condition plus read-only/no-account note follow immediately, so an agent can decide and act from the first clause.

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

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

For a single-parameter, annotation-covered retrieval tool with no output schema, this covers what it searches, why to use it, and that it needs no account. The only omission is fallback behavior when no relevant passage exists.

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 `question` parameter already carries a description, a maxLength of 300 and an example, so the schema does the heavy lifting. The description's topic list marginally hints at the kind of question to ask, but adds no syntax or format guidance beyond the schema.

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

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

States a specific verb ("Cherche") and resource ("la documentation officielle de Tchin") and enumerates the covered topics (frais, délais, API, sécurité...). The scope clause "Pour les questions sur le fonctionnement de Tchin" cleanly separates it from the transactional/account siblings (mon_compte, mes_transactions, creer_lien_paiement).

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?

"Pour les questions sur le fonctionnement de Tchin" gives a clear trigger condition, and the documentation-search framing implicitly excludes account-state queries handled by siblings. It never explicitly names an alternative or states when not to use it, so it stops short of a 5.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered; the description adds value beyond them by disclosing the auth requirement (logged-in Tchin account, merchant or individual, connection prompt on first use) and the concrete consequence for the counterparty. It stops short of saying whether the cancellation is reversible or what happens to funds already associated with the 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?

Two short sentences with no filler, and the 'encore ouvert' constraint is placed right before the consequence. Leading with the audience/auth clause rather than the action slightly delays the core verb, but overall it is tight.

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, no-output-schema tool whose annotations already spell out destructive and idempotent behavior, the description supplies the two things annotations cannot: who may call it and what changes for the recipient. Nothing essential to correct invocation is missing.

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

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

There is a single parameter with 100% schema description coverage ('L'adresse du lien de retrait ou son code'), so the schema already carries the semantics. The description adds nothing about the identifier format or accepted values, which is acceptable at this coverage level but not additive.

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 ('Annule un lien de retrait') and adds a meaningful scope qualifier ('encore ouvert') plus the observable effect ('la personne ne pourra plus retirer'). It is distinguishable from siblings like supprimer_lien or mes_liens_retrait, though it never names them 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?

The phrase 'encore ouvert' implies a precondition — only open withdrawal links are cancellable — which is real usage guidance. However, it never states what to do for already-closed links, nor points to the sibling tools (supprimer_lien, modifier_lien, mes_liens_retrait) that an agent might confuse it with.

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, destructiveHint=false and closed-world, so safety is covered; the description adds meaningful extras: an authentication prompt on first use, the default and maximum time window, and the fact that failed and pending operations are included alongside successful ones. It stops short of describing result structure or volume/pagination behavior for what could be a large aggregate.

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 dense sentence plus a scope clause, front-loaded with who the caller is before the enumeration of what is returned. Every clause carries information; the parenthetical login note is slightly buried mid-sentence.

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

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

With no output schema, the description usefully enumerates the dimensions of the report (entries/exits by genre, month, country, fees, failed/pending), which is what an agent needs to judge relevance. Authentication requirement and time bounds are stated; the shape of the returned object is not, but that is largely covered by the dimension enumeration.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns a bump by adding the default window (30 days) and hard cap (one year), which materially constrain how du/au can be used. The mode enum values are already documented in the schema and are not repeated.

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: aggregates ALL successful operations for the connected Tchin user (merchant or individual) over a period, broken down by genre, month, country, plus fees and failed/pending operations. This is clearly an aggregation/report tool, distinct from list-style siblings like mes_transactions or detail_transaction, 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?

Gives useful context (connected-user scope, first-time login prompt) and period constraints (30 days default, one year max), which implies when it applies. However, it never says when to prefer this over rapport_ventes, mes_transactions or releve_pdf, leaving alternative selection to inference.

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

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

Annotations already declare the mutation profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=false), so the bar is lower. The description adds real value beyond them: no fees, a 500 F minimum, and the exchange rate of 1 000 Tchin = 10 F, plus the authentication requirement on first use.

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: the first establishes the actor and authentication prerequisite, the second the operation and its constraints. Front-loaded and waste-free, though the parenthetical constraint list is 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 mutation tool with full annotation coverage and no output schema, the description covers actor, auth, cost, minimum and conversion rate. It does not say what happens on insufficient cashback or what the response contains, which are minor gaps given the structured data already provided.

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% (including the enum for pays and the 500 minimum for montant), so the baseline is 3. The description earns an extra point by stating the exchange rate, which explains the relationship between cashback Tchin consumed and the CFA amount received — information the schema does not contain.

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: converts cashback Tchin into fiat money on the user's country balance. The cashback scoping implicitly separates it from sibling tools like retirer_mobile_money or deplacer_argent, though it never names an alternative 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?

It establishes who can call it (connected user, merchant or individual) and gives a minimum threshold, which implies when it is applicable. However, it never says when to prefer this over retirer_mobile_money or mon_cashback, so the agent must infer the routing.

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

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

With annotations declaring readOnlyHint=false and destructiveHint=false, the bar is lower, and the description still adds real value: it discloses the authentication prerequisite and, critically, that only the public key is returned while the secret key must be retrieved on Tchin's API page with the Tchin PIN. It does not note that repeated calls produce separate applications, despite idempotentHint=false.

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 that front-load eligibility, then the action, then the return behavior. No filler, though the parenthetical about first-time connection is slightly buried and the key-handling clause is 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?

There is no output schema, and the description usefully covers what comes back (public key) and how to obtain the secret key, so return semantics are handled. The significant remaining hole is the six undocumented input parameters, which for a creation tool with an enum and five booleans is a real gap.

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

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

Schema description coverage is 0% across 6 parameters, so the description must carry the burden of parameter meaning and it does not: 'nom', 'crypto', 'description', 'compte_tchin', 'mobile_money' and the 'frais_paiement' enum (client vs marchand) are never mentioned. An agent must guess what each flag toggles on the created application.

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 ('Crée une application API') plus the business purpose ('pour encaisser depuis un site ou un appli'), which lets an agent distinguish it from mes_applications (listing) and supprimer_application (deletion) without opening schemas. It stops short of naming a sibling 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?

The audience prerequisite is stated ('utilisateur connecté à son compte Tchin, marchand ou particulier') and a use case is implied ('pour encaisser depuis un site ou un appli'). However, there is no guidance on when to prefer this over siblings like creer_lien_paiement or creer_formulaire for taking payments, and no stated exclusions.

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

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

Annotations already declare the write/non-idempotent/open-world profile, and the description adds genuinely new context: an authentication requirement ('connexion demandée la première fois') and the return behaviour ('Rend son adresse'), which matters because no output schema exists. It still omits what happens on failure or whether forms can be edited afterwards.

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

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

Three dense sentences, front-loaded with the actor and the core flow, then the return value, then the type list. The long type enumeration earns its space since it is the only source for those values, though the sentence is fairly breathless.

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 6-parameter mutation tool with no output schema and 33% schema coverage, the description covers the essential flow, auth and return value. It leaves the 'test' flag, the 'description' field, and the amount/quantity limits (100–100,000,000 XOF, 1–60 questions) unexplained, which leaves real 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 only 33%, and the critical gap — the nested 'type' field is a bare string with no enum — is fully compensated by the description enumerating all 19 question types. It also clarifies that 'montant' is a fixed price. It says nothing about 'test', 'titre' or 'description', which remain undocumented.

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

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

The description gives a specific verb and resource ('Crée un formulaire de paiement') and explains the full flow: the customer answers questions, then pays a fixed price. It does not, however, distinguish this from the close sibling 'creer_lien_paiement', which an agent could easily confuse it with.

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

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

Usage is implied through concrete examples ('inscription, commande sur mesure, réservation…') and the target audience (marchand ou particulier connecté à son compte Tchin). There is no explicit statement about when to prefer this over a simple payment link, nor any exclusion or prerequisite beyond the first-time login note.

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

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

Adds real behavior beyond the annotations: authentication is required (first-time login), fees are borne by the client, and the link itself collects no money. It also discloses the return artifact, the shareable URL. It does not say whether repeated calls create duplicate links (relevant given idempotentHint=false) or whether links expire.

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

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

Four tight sentences, each carrying distinct information (audience/auth, action, amount modes, fee/custody disclaimer). The opening clause about connection is slightly front-loaded over the action, but nothing is redundant.

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

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

With no output schema, the description compensates by stating that a URL (https://tchin.tech/pay/…) is returned and meant to be shared. Combined with full annotation and schema coverage, an agent has what it needs, with only lifecycle questions (expiry, duplicates) left open.

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

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

Schema coverage is 100%, so the schema already documents titre, montant, moyens, test and description. The description's note that an omitted montant produces a free-amount link and that amounts are in F CFA largely repeats the schema's own wording, adding little beyond 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?

States a concrete verb+resource ('Crée un lien de paiement Tchin au nom du marchand connecté') and explicitly disclaims what it does not do ('N'encaisse rien par lui-même'), which separates it from the payout/transfer siblings. It never names a sibling tool, so differentiation is functional rather than 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?

Usage context is implied — a merchant wants an address to share with clients, and 'montant omis' yields a free-amount link. However, no alternative is named (e.g. creer_lien_retrait, creer_formulaire, mes_liens), and there is no explicit when-not guidance, so the agent must infer the routing.

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

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

The description adds substantial behavioral detail beyond the annotations: authentication requirements, email delivery, recipient self-withdrawal, payment from the user's balance, test mode creating the link immediately without real money, and real mode preparing a request that does nothing immediately until the user confirms with their Tchin PIN within 15 minutes. It also specifies the follow-up call to etat_demande.

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

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

The description is front-loaded with the account context and purpose, then moves through test versus real behavior and the required follow-up. Despite its length, every sentence carries operational meaning for correctly invoking or interpreting the tool.

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-read-only creation tool with no output schema, the description covers authentication, test versus real semantics, the PIN confirmation flow, and the follow-up tool. It is nearly complete, though it does not explicitly say what is returned in test mode and leaves some parameter semantics to the schema.

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

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

Schema description coverage is only 25%, so the description must compensate. It explains the important test=true behavior and clarifies that the recipient receives an email and withdraws via Mobile Money or crypto, but it does not add meaning for several parameters such as devise, titre, message, or pays beyond what the schema enums and names provide.

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

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

The description states a specific verb and resource: it creates a withdrawal link where the recipient receives an email and withdraws Mobile Money or crypto from the user's balance. It also differentiates the link-based flow from immediate withdrawal by explaining that the recipient acts themselves, and it names the follow-up tool etat_demande.

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

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

It gives clear usage context: the user must be connected to their Tchin account, merchant or individual, and first-time connection is required. It also explains the test versus real mode and instructs the agent to call etat_demande afterwards, though it does not explicitly compare this tool with alternatives such as retirer_mobile_money.

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

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

The description adds essential behavior beyond the annotations: it does not move money immediately, it prepares a request and returns a tchin.tech URL where the user confirms with their Tchin PIN, and the confirmation window is 15 minutes. This is exactly the kind of side-effect and confirmation-flow detail an agent needs before calling the tool.

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

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

The description is front-loaded with the actor and operation, then immediately highlights the critical non-immediate behavior before stating the follow-up tool. Every sentence carries useful information, including the authentication context and the 15-minute confirmation window.

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?

Although there is no output schema, the description explains what the tool returns in practice: a request-preparation URL for the user to confirm. It also covers authentication requirements, the confirmation mechanism, timing, and the required follow-up call, leaving no major gap 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 schema already documents the three parameters, including country codes and amount in F CFA. The description reinforces the concept of two country balances but does not add format or validation detail beyond what the schema 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 states a specific verb and resource: moving money between the user's own country balances. The example 'du Bénin vers le Togo' makes the scope concrete and implicitly distinguishes it from sending money to a third party via envoyer_argent.

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 the context: the connected Tchin user, merchant or individual, moving funds between their own country balances. It also gives the crucial next step 'Ensuite, appelez etat_demande', but it does not explicitly explain when to use this instead of sibling tools such as envoyer_argent.

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 read-only, non-destructive, closed-world profile, so the bar is lower. The description still adds real value by disclosing the authentication prerequisite ('connexion demandée la première fois') and by enumerating the returned fields in the absence of an 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?

Two sentences with no filler; the field enumeration is dense but purposeful. The caller/authentication context leads, which is slightly less important than the resource identity but not wasteful.

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

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

For a one-parameter read tool with annotations and a field list, most of what an agent needs is present. The remaining gaps are the lack of any cue on behavior when the reference is unknown, and no signal on how this differs from the many sibling payment/transaction lookups.

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 parameter is fully documented in the schema (100% coverage), including its dual nature as a payment reference (token) or a link code, and the description restates that same fact. Baseline 3 applies since the schema already carries the parameter semantics and the description adds no new constraints.

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 (a payment) and enumerates exactly what is returned — montant, frais, net, moyen, pays, statut, dates, lien concerné — which gives an agent a concrete picture of the tool's output. It never explicitly contrasts itself with close siblings such as etat_paiement or detail_transaction, so the differentiation is left implicit.

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 states the caller context ('pour l'utilisateur connecté à son compte Tchin, marchand ou particulier') and the lookup key ('avec la référence du paiement ou le code du lien'), which is useful usage framing. However, there is no explicit when-to-use versus when-not, and no mention of when an agent should prefer etat_paiement or detail_transaction instead.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered elsewhere. The description contributes the authentication/connection requirement and the fact that any operation kind is accepted, which is genuine added context. It says nothing about failure behavior for an invalid reference or about the shape of the returned detail.

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

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

Two sentences, no filler, with the core action first and the reference formats second. The parenthetical about first-time connection sits awkwardly inside the opening sentence but does earn its place by flagging auth.

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

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

For a one-parameter read tool with full annotation coverage, the description supplies what the schema cannot: which reference forms are valid, the auth requirement, and the range of operation kinds accepted. With no output schema, it only vaguely characterizes the returned 'détail', which is the remaining gap.

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

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

Schema description coverage is 0% for the single required 'reference' parameter, so the description carries the full burden — and it does: the reference may be either the operation number from the history or the provider's reference. That tells the agent two distinct accepted formats that the bare 'string' schema does not convey. It still lacks a concrete format example.

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: returns the detail of one account operation, identified by its reference. It also scopes the operation type broadly ('de n'importe quel genre'), which helps separate it from the narrower detail_paiement. It does not name detail_paiement or mes_transactions as alternatives, so the sibling differentiation is only implicit.

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: use it when you already hold a reference and need the full record of that operation. The description adds a real precondition ('connexion demandée la première fois'), which is useful context. However, it never says when to prefer detail_paiement or mes_transactions, nor what to do if the reference is unknown.

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

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

Beyond the annotations (readOnly=false, idempotent=false), it discloses key behavioral traits: the call only creates a pending request, returns a tchin.tech URL, requires the user to confirm with a Tchin PIN, and expires in 15 minutes. It also names the applicable fee schedule.

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 critical 'NE FAIT RIEN TOUT DE SUITE' caveat and the next-step pointer are front-loaded and every sentence carries information. It is dense and slightly run-on, but nothing is wasted.

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

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

Without an output schema, the description still explains what is returned (a confirmation URL) and the follow-up tool (etat_demande), plus auth and timing constraints. Only the unexplained 'vers' parameter and vague fee reference 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 description adds real meaning beyond the schema: tchin_id is the recipient's Tchin ID (with an example like boutique@tchin), and the source is the user's country balance, with fee context for montant. The optional 'vers' parameter is never explained in the description, which is a minor gap given 75% schema coverage.

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

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

The description states a concrete verb and resource (sending money from the user's country balance to another person's Tchin account via tchin_id) and adds scope detail like fee type. It does not explicitly distinguish itself from the similar sibling preparer_demande_tchin, leaving some ambiguity about which one to pick.

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 states the preconditions (logged-in user, merchant or individual, first-time connection) and, crucially, that no transfer happens immediately and that the agent should then call etat_demande. It does not explain when to prefer this over preparer_demande_tchin, which is the main missing piece.

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 that the tool is read-only, non-destructive, and closed-world, but the description adds important behavior: authentication may be requested on first use, the possible status outcomes are enumerated, and agents are warned not to report success prematurely. This is material operational context beyond the annotations.

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

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

The description is three focused sentences: authentication context, status semantics, and a critical usage warning. It is front-loaded and every sentence contributes useful 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?

For a one-parameter read-only status tool with no output schema, the description is complete enough: it identifies the caller context, enumerates the possible outcomes, and supplies the key rule for interpreting the result before telling the user the operation succeeded.

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 explains that the single parameter is the returned reference such as D123. The description adds some contextual meaning by tying it to a prepared request, but it does not add syntax or format details beyond the schema.

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

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

The description states a specific verb and resource: it tells whether a prepared request has been confirmed/done, refused, failed, or is still pending. The examples of prepared requests (envoyer_argent, retirer_mobile_money, deplacer_argent) make clear which family of operations this status check applies to.

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 specifies the usage context: the connected Tchin user, merchant or individual, with first-time authentication. It also gives a strong sequencing rule not to tell the user something is done until this tool answers 'fait', though it does not explicitly name alternatives such as etat_paiement or detail_transaction.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered and 'Lecture seule' merely repeats it. The description earns credit beyond that by disclosing the actual return vocabulary (paye / en_cours / a_payer), which is essential behavior given 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?

One sentence that front-loads the status question and closes with the three possible values plus the read-only note. Nothing is redundant or padded.

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 enumerated states are exactly the return-value information an agent needs, and the token source is documented. Minor gaps remain: no statement on behavior for an unknown or expired token, and the overlap with etat_demande is left unresolved.

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 token parameter is already documented, including its provenance from afficher_lien_tchin / preparer_demande_tchin. The description only restates 'by its code', adding no new syntax or format detail, so the baseline 3 applies.

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

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

States a specific verb and resource: reports whether a Tchin payment (payment link or payment request, by its code) is paid, in validation, or still to pay. The three enumerated outcome states make the tool's function concrete. It stops short of explicitly distinguishing itself from the sibling etat_demande, which also sounds like it reports request status.

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?

'Lecture seule' plus the token reference implies the read-only lookup context, but there is no explicit when-to-use / when-not-to-use guidance and no routing to detail_paiement or etat_demande. An agent must infer which status tool applies to a 'demande de paiement'.

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, destructiveHint=false and openWorldHint=false, so safety is covered; the description adds the authentication requirement and enumerates the returned fields (plan, montant, rythme, statut, prochaine échéance, échéances payées), which is valuable since there is no output schema. It omits ordering, default result size and whether 'limite' truncates the list, leaving 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?

Two compact sentences: the authentication prerequisite is front-loaded, followed by the data scope. Nothing is padded, though the enumeration of output fields sits awkwardly close to the unmentioned 'statut' filter param.

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, zero-required-parameter listing tool with no output schema, the description adequately covers audience, auth and returned fields. It would be complete with a note on pagination/default limit and on what the status filter does.

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 0% and neither parameter is explained: 'limite' (1–50) and the 'statut' enum (active/pending/cancelled) appear only as bare types. The description mentions a 'statut' field among the returned data, which may confuse the agent about whether it is a filter or an output, and adds nothing about the limit's default or effect.

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

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

The description names the resource precisely (subscriptions with plan, amount, rhythm, status, next due date, paid installments) and scopes it to either the logged-in individual or a merchant's clients. The verb is implicit (it reads as a listing) and there is no explicit differentiation from look-alike siblings such as mes_prelevements or mes_ventes, so it stops short of a 5.

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

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

It gives one real prerequisite: a Tchin login is requested the first time, which tells the agent the call can trigger an auth flow. Beyond that, usage is only implied — no statement of when this is preferred over mes_prelevements, mes_ventes or bilan_compte, and no exclusions.

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

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

Annotations already establish readOnlyHint=true, destructiveHint=false, and openWorldHint=false. The description adds useful context beyond that: it requires authentication and explicitly states that secret keys are never exposed, which is meaningful security behavior for an API-application listing tool. Pagination or ordering behavior is not described, but the safety and data-visibility profile are clear.

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 dense sentences with no filler: the first establishes the authenticated user context, and the second lists returned fields and the secret-key exclusion. It is appropriately sized, though it could be slightly more front-loaded by leading with the listing action itself.

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 listing tool with no output schema, the description supplies the necessary return-field overview and explicitly notes what is not returned (secret keys). Authentication context is also provided. It is nearly complete, with only minor gaps such as ordering or result size.

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

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

The tool takes zero parameters, so there are no parameter semantics to explain. The baseline for 0 params is 4, and the description does not create any parameter-related confusion.

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 precisely: the connected user's API applications, with the exact fields returned (nom, description, moyens acceptés, qui paie les frais, date). It distinguishes the tool from write siblings like creer_application and supprimer_application by framing it as a read of existing applications, though it does not explicitly name those 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?

It gives a clear usage condition: for the logged-in Tchin user, merchant or individual, with connection requested the first time. However, it does not explicitly say when to choose this over other application-related siblings or describe any exclusions beyond the implied read-only 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?

The readOnly, non-destructive, closed-world annotations already establish the safety profile. The description adds useful context beyond annotations: it requires a first-time login, defines vaults as locked savings from recurring Mobile Money deposits, and enumerates the returned fields including status and next due date. It does not mention ordering or pagination, but for a no-parameter read-only listing this is strong 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?

Two tightly written sentences: the first front-loads the user scope and authentication prerequisite, the second names the resource and lists the returned fields. Every element earns its place, and there is no redundant restatement of the title.

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

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

Given zero parameters, read-only annotations, and no output schema, the description provides the key domain context and explicitly lists what the returned vault data includes. It is close to complete for this simple tool, though a brief note about ordering or whether all vaults are returned would remove the remaining ambiguity.

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 is no parameter semantics to document. Baseline 4 is appropriate; the description does not need to explain inputs because none exist.

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 connected user's Tchin savings vaults, and explains what a vault is (locked savings fed by regular Mobile Money deposits). It also lists the exact fields shown, which makes the purpose concrete. It does not explicitly differentiate itself from sibling account-listing tools, which keeps it from a 5.

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

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

It establishes the user context (connected Tchin account, merchant or individual) and notes that login is requested the first time. However, it does not say when to use this instead of nearby tools like mon_compte, bilan_compte, or tchin_suivi, so usage is implied rather than 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 declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false. The description adds meaningful context beyond that: authentication is required on first use, the scope is recent money recipients, and the returned fields are Tchin ID, name, and country. It does not discuss pagination or ordering, which keeps it from a 5.

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

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

The definition is compact and front-loads the authenticated user context before stating the data scope and purpose. Every clause adds useful meaning with no filler.

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

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

For a zero-parameter read tool with annotations covering safety, the description covers authentication, data scope, and returned fields well. It omits details like result limits or ordering, so it is not 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 takes zero parameters, so the baseline is 4. The description correctly adds no parameter details and does not need to.

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: recent Tchin accounts to whom the connected user has sent money, with fields Tchin ID, name, and country. It implies a listing operation for finding a recipient, though it never states an explicit verb like 'list' or 'return'.

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

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

It gives a clear usage context: for a connected Tchin user, merchant or individual, to find a recipient they have paid recently. It does not name alternatives or exclusion conditions, so it falls short of a 5.

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

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

Annotations already establish readOnly, non-destructive, closed-world behavior, and the description adds meaningful context: authentication requirement, result ordering, and the fields returned. It does not describe limits or pagination behavior, but the annotation coverage lowers the burden.

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 audience/authentication context before describing the returned items. The field list is useful rather than redundant, though the parameter is omitted entirely.

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 listing tool with no output schema, the description explains who can use it, what it returns, and the ordering. The main omission is the behavior of the optional 'limite' parameter, which leaves a small but real gap.

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

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

The schema has one optional parameter, 'limite', with bounds 1–50 but 0% schema description coverage. The description never mentions this parameter, its default, or how it affects the number of returned links, so it does not compensate for the schema 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 identifies the resource as the connected user's payment links and forms, with a stated ordering ('les plus récents d’abord') and returned fields. It distinguishes this from withdrawal-link and transaction tools by naming payment links and forms, though it does not use an explicit verb like 'list'.

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

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

It states that the tool is for the authenticated Tchin user, merchant or individual, and notes that login is requested the first time. This gives useful usage context, but it does not say when to choose this tool over siblings such as mes_liens_retrait or detail_paiement.

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=true, destructive=false, openWorld=false, so the safety profile is covered. The description adds real value beyond that: it discloses the authentication requirement (connection requested the first time) and the shape of the returned data (who, amount, status, address), which an agent cannot infer from annotations.

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

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

Two short sentences, front-loaded with the audience/access condition followed by the returned content. Nothing is padded, though the phrasing is slightly fragmented rather than crisply 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?

With no output schema and readOnly annotations, the description does a fair job covering auth and return fields. But it leaves gaps an agent would want: what 'limite' controls, ordering, and pagination behavior are all unaddressed.

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

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

There is one parameter (limite) with 0% schema description coverage, and the description never mentions it at all. It neither explains the limit's purpose nor its range/bounds, so it fails to compensate for the undocumented schema.

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

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

The description clearly identifies the resource — the connected user's sent withdrawal links — and enumerates the fields surfaced (recipient, amount, status, address). It reads as a listing operation but never explicitly states the verb 'list', and it doesn't differentiate from near-neighbors like mes_liens or mes_retraits.

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 establishes context — the connected Tchin user, merchant or individual, with login required on first use — which implies when the tool applies. However, it offers no explicit when-to-use vs alternatives (e.g., mes_retraits, mes_liens) and no exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this non-redundantly: it explains that nothing is paid or debited and that the user pays for themselves on tchin.tech if they so choose. It also discloses the first-use authentication requirement. It stops short of describing result volume or 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?

A single compact paragraph ordered sensibly: audience and auth, then what the data is with its fields, then the read-only guarantee. Every clause carries information, though the run-on sentence structure around the field enumeration is 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?

With no output schema, the description compensates by enumerating the returned fields, and it covers the auth prerequisite and the no-side-effects guarantee. What is missing is disambiguation from mes_abonnements and any sense of result size or recency of the due dates, so it is strong but not complete.

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

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

The tool takes zero parameters, which is the baseline-4 case: there is no parameter semantics to convey and the description correctly spends no words on them. The field list it gives describes outputs, not inputs, so it does not mislead.

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 (the subscriptions the connected user pays to merchants, i.e. their prélèvements) and enumerates what it exposes: merchant, formula, amount, rhythm, next due date, delay, and the tchin.tech address. That is far more specific than the bare title. It does not, however, differentiate itself from the very close sibling mes_abonnements, which an agent would also plausibly pick.

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 establishes who it applies to (the user connected to their Tchin account, merchant or individual) and notes that connection is requested the first time, which is a real prerequisite. But there is no explicit when-to-use / when-not-to-use guidance, and the obvious alternative, mes_abonnements, is never named or contrasted.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuine context beyond that: the scope is the authenticated user's own account and a Tchin login may be requested on first call, which the annotations do not say.

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 that lead with the audience/scope and then the returned content. Nothing is wasted, though the second sentence could be trimmed into a shorter field list.

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

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

A read-only list tool with no output schema, so it is valuable that the description enumerates the returned fields. The remaining gap is the 'limite' parameter and whether results are capped by default, which the description never addresses.

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%: 'mode' is documented in the schema, but 'limite' (1-50) has no description anywhere. The description mentions no parameters at all, so it fails to compensate for the undocumented limit or to clarify real-vs-test semantics.

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

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

States a specific verb+resource: the last withdrawals of the account, and enumerates the returned fields (date, montant, frais, moyen, statut). It is clearly a personal-history list, distinct from detail_transaction or retirer_mobile_money, though it does not explicitly name the sibling it contrasts with.

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

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

Implies usage: for the connected user's own account, merchant or individual, with login requested on first use. It gives no explicit when-to-use/when-not guidance or pointer to alternatives such as mes_transactions or detail_transaction for a single withdrawal.

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

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

Beyond the readOnly/non-destructive annotations, the description discloses the authentication requirement, the sort order (most recent first), the aggregate totals returned alongside the filtered rows (entrées, sorties, frais), the page size behavior, and that each row carries its originating canal. With no output schema present, this return-shape disclosure is exactly what the description needs to carry.

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 scope and ordering come first, followed by filters and then pagination/return shape, which is a sensible front-loading. It is a dense semicolon-chained paragraph and repeats enum values already documented in the schema (genre, canal, mode), so a few clauses do not add new 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?

For a 10-parameter, all-optional read tool with no output schema, the description covers scope, ordering, every meaningful filter, defaults, limits, and the returned totals and canal field. Remaining gaps are minor: the 'page' parameter is not described and there is no note on what an empty result looks like.

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 60%, and the description closes most of the gap: it explains genre meanings, that canal means payments from WooCommerce stores or WordPress buttons, that mode defaults to 'reel', and that pagination defaults to 25 with a 100 ceiling (a default the schema does not encode). Only 'page' is left unstated, and it is self-evident alongside limite.

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: it returns the FULL transaction history of the connected Tchin account, ordered most-recent-first, and enumerates the record genres (paiements reçus, dépôts, retraits, envois, cashback, épargne, etc.). That enumeration implicitly separates it from narrow siblings such as mes_retraits, mes_ventes, or detail_transaction, but those alternatives are never named, so sibling differentiation is left to inference.

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 context is clear: it applies to the logged-in user's own account (merchant or individual) and requires a first-time connection. The filter dimensions are spelled out, which tells the agent how to narrow results. It never says when NOT to use it, e.g. that detail_transaction is the right tool for a single transaction or that bilan_compte covers aggregate balances, so exclusions are absent.

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, destructiveHint=false and openWorldHint=false, so safety is covered; the description still adds real value by disclosing the auth requirement, the 'les derniers' recency/limited scope, and the privacy trait that no client private data is exposed. It does not state a default result count or pagination behaviour, which is the remaining 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 compact sentences with the audience/prerequisite stated first and the returned fields second. Every clause carries information (audience, auth, payload, privacy), with only minor density from the parenthetical.

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?

Because there is no output schema, enumerating the returned fields is valuable and largely covers the return shape. But for a 3-parameter tool with only 33% schema coverage, leaving 'limite' and 'statut' completely undocumented in both schema and description leaves an agent without enough to invoke it precisely.

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% — 'limite' and 'statut' have no schema documentation at all — and the description compensates for neither. Only a faint hint ('les derniers') gestures at 'limite'; nothing explains valid 'statut' values or how filtering interacts with mode.

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 — recent payments received (sales) for the authenticated Tchin user — and enumerates the returned fields (date, montant, net, moyen, statut, lien), so an agent can tell what it fetches. It stops short of a clean verb ('List…') and never differentiates itself from close siblings like rapport_ventes, mes_transactions or detail_paiement, which is what keeps it off a 5.

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

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

It supplies a prerequisite (user must be connected to their Tchin account, connect on first use) which frames the usage context. But there is no explicit when-to-use/when-not, and no routing signal versus rapport_ventes (aggregate reporting) or mes_transactions (all movements), so the agent must infer selection.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and readOnlyHint=false, so the safety profile is known. The description adds useful context the annotations lack — login requirement on first use, and the 0 = montant libre convention — but it never explains what 'destructive' means here (overwrite vs. partial update) or whether omitted fields are preserved.

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, front-loaded with the actor/auth condition before the action. Dense but no filler; only the parenthetical about first-time login could be trimmed.

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 destructive, idempotent mutation with 6 params and no output schema, the description should state update semantics (partial vs. full replace) and what a successful call yields. It covers the field list and auth well but leaves those behavioral questions to inference.

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

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

With schema coverage at only 33%, the description carries real weight: it maps out the modifiable surface (titre, montant, description, moyens, test/réel) and clarifies that montant=0 means free amount and that test toggles test vs. real mode. It does not clarify the moyens enum values or lien address/code formats beyond what the schema already says.

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 ('Modifie') and resource ('un lien de paiement ou un formulaire') and enumerates the mutable fields. It is clearly distinguishable from creer_lien_paiement, supprimer_lien and activer_lien by the verb alone, 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?

The first sentence gives caller context ('utilisateur connecté à son compte Tchin, marchand ou particulier') and an auth note, which implies this edits an already-existing link. But it never says when to prefer this over activer_lien or supprimer_lien, nor any exclusion or prerequisite beyond login.

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

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

Annotations already declare readOnly/openWorld=false, so the safety profile is covered. The description adds real context beyond that: it requires an authenticated session, and notes a login is prompted the first time, plus it discloses the 1 000 Tchin = 10 F exchange rate and the scratch-card concept. It doesn't cover failure modes or output format, but that is modest against annotation coverage.

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, front-loaded with the audience/auth condition, then the payload contents. Dense but every clause contributes a distinct data point or constraint; no filler.

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

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

With no output schema, the description carries the burden of describing the return payload, and it does so by enumerating the four items returned. The only gap is the shape/format of those values (units, structure), which an agent can reasonably infer.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline for a parameterless tool is 4.

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 resource (the account's Tchin cashback) and enumerates exactly what is reported: Tchin earned, their F CFA value, pending scratch cards, and the conversion minimum. It is distinguishable from the sibling convertir_cashback (which acts) because this one reads. It stops short of naming siblings explicitly, which keeps it at 4.

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

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

Usage is implied by 'Pour l'utilisateur connecté à son compte Tchin' – it's the self-scoped read of one's own cashback. There is no explicit when-to-use versus alternatives, and no pointer to convertir_cashback for the conversion action mentioned at the end, so routing 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. Beyond that, the description adds genuinely new behavioral context: the tool requires an authenticated session (prompting login on first use) and enumerates the exact data surface returned (name, Tchin ID, country, KYC, PIN status, per-country balances, crypto, cashback) – valuable given 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?

Two sentences, front-loaded with the audience/context and then the returned fields. The second sentence is a dense fragment list, but every item maps to real returned data rather than 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 parameterless, read-only tool with no output schema, the description compensates well by enumerating the returned fields and noting the login requirement. It stops short of stating failure behavior when no session exists or how the two account types differ in what is 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?

The tool takes zero parameters, so the baseline of 4 applies. The description adds no parameter-level information, but none is needed or possible for a parameterless call.

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 (the connected user's Tchin account, merchant or individual) and enumerates the fields it exposes, but never states an explicit verb such as 'retrieve' or 'view'. It also fails to distinguish itself from closely related siblings like bilan_compte, mon_cashback, or mon_parrainage, which an agent must differentiate on its own.

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?

'Pour l'utilisateur connecté à son compte Tchin' implies the usage condition (an authenticated session) and parenthetically notes that connection is requested the first time. However, no alternative tool is named and no when-not-to-use guidance is given, leaving routing between account-related siblings to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds valuable behavioral context: authentication is required on first use, and it enumerates the returned data (code, link, filleuls count, active count, tier, earnings). It does not discuss error cases or rate limits, but for a simple read tool this is sufficient.

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

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

Two sentences with zero waste. The user context is front-loaded, followed by the exact data returned. Every part of the description serves a clear purpose.

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 (no params, no output schema), the description is complete: it explains authentication needs and lists the return fields in detail. An agent has enough information to decide to call the tool and interpret its output.

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, which is the baseline for a 4. The description does not need to explain parameters, and it instead usefully describes the return values, compensating for the lack of an output schema.

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

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

The description clearly indicates that the tool returns referral details for the logged-in account: invitation code and link, number of filleuls, tier, and earnings. It lacks an explicit verb like 'retrieve', but the listed fields make the purpose unambiguous. Sibling differentiation is not needed as this is the only referral-related 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?

The description specifies the context: for logged-in users (merchant or individual) with a note that login is requested the first time. However, it does not explicitly state when to use this tool versus alternatives or any exclusions, leaving usage implied rather than clearly 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 declare readOnly/openWorld=false/destructive=false, so safety is covered; the description adds the key behavior beyond that: it returns an address rather than executing anything, and authentication may be triggered on first use. It stops short of saying whether the URL is single-use or how long it stays valid.

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?

Purpose and auth prerequisite are front-loaded, followed by a compact page catalogue. The enumeration is long but every entry does disambiguation work; the only mild redundancy is that the introductory clause and the page list both restate the in-app action set.

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?

No output schema exists, yet the description explicitly states the return is a page address, and the prerequisites and page inventory are covered. What is missing is only marginal (URL lifetime, what happens for a non-authenticated user), so it is complete enough to invoke correctly.

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

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

Schema description coverage is 0%, so the description carries the full burden — and it does, glossing all 13 enum values with what each page contains (e.g. 'api' holds applications and their secret key requiring the Tchin PIN, 'banque' includes coffres). This adds real meaning beyond the bare enum strings.

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 ('Rend l'adresse d'une page de Tchin') and scopes it to the logged-in user's in-app screens, so an agent knows this returns a deep link rather than performing an action. It does not name any sibling tool (mes_transactions, mon_compte, tchin_crypto…) to contrast against, which keeps it from a 5.

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

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

'Pour l'utilisateur connecté… (connexion demandée la première fois)' gives an auth prerequisite, and 'pour ce qui se fait sur l'écran de Tchin' frames the context. However there is no explicit when-to-use-this-vs-sibling guidance despite ~40 siblings that cover the same domains programmatically; the agent must infer that this is for handing a URL to a user rather than fetching data itself.

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 key non-obvious behavior is disclosed forcefully: it performs NO payment and debits no one, the user must confirm in the secured form. This goes beyond what readOnlyHint=false / destructiveHint=false / idempotentHint=true convey, and is essential for a tool whose name suggests a transfer. It omits what happens to the request afterwards (expiry, reference, status), and the idempotentHint claim is left unexplained.

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 no-payment disclaimer is front-loaded in the second sentence where it matters most, and each sentence carries distinct information. Slight redundancy with the schema's min/max amount range keeps it from being maximally tight.

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

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

With no output schema, the description does explain the observable result (a secure payment form rendered in the conversation), which is what an agent needs to narrate to the user. It leaves open what a failure looks like or whether an existing request is reused given idempotentHint=true.

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 three parameters are already documented including the XOF unit, pseudo@tchin format and the 200–1 000 000 bounds. The description restates the amount range and the Tchin ID notation without adding new syntax or constraints, so the baseline applies.

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

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

States a specific verb and resource ("Crée une demande de paiement (une facture)") in XOF for a designated Tchin ID, and explicitly distinguishes the outcome (a payment form shown in the conversation) from actually moving money. An agent can separate it from envoyer_argent or creer_lien_paiement from the description alone.

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?

"À utiliser quand l'utilisateur veut payer ou envoyer un montant à un Tchin ID" gives a clear triggering condition, and the 200–1 000 000 F bounds constrain usage. It does not name the alternative siblings (envoyer_argent, deplacer_argent, creer_lien_paiement) or say 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 declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered structurally. The description adds genuine context beyond that: an authentication requirement on first connection and a default 30-day window with a fixed date format. It does not describe the response shape or any limits/aggregation caveats, so it adds moderate rather than rich behavioral context.

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

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

Three sentences, front-loaded with the resource and the metrics, then scope and defaults. Dense but every sentence carries information; the capitalized VENTES is mild emphasis noise but not 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?

With no output schema, the description carries the burden of describing return values and does so by listing the aggregates and the three breakdown dimensions, plus the default period. What remains unstated is whether periods return a single aggregate or a time series, which matters for an agent deciding how to interpret 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 coverage is 100%, so the baseline is 3 and the schema already documents au, du and mode. The description earns the extra point by supplying behavior the schema omits: the AAAA-MM-JJ date format restated for both bounds and, more importantly, the default of the last 30 days when dates are not supplied.

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 (VENTES = paiements reçus) and enumerates exactly what the report contains: total encaissé, net reçu, counts of successful/failed payments, and breakdowns by method, country and link. It also delimits scope with 'les ventes seulement, sans les dépôts, retraits ni envois', which separates it from balance/transaction reports. It stops short of naming a specific sibling tool (e.g. mes_ventes vs bilan_compte) for the agent to choose against.

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

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

Gives clear usage context: for the logged-in Tchin user, with login requested on first use, plus a default window of the last 30 days when dates are omitted. It explicitly excludes non-sales movements, telling the agent when not to reach for this tool. No explicit pointer to an alternative sibling for listing individual sales or for account balance.

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: requires the user to be logged into their Tchin account (prompted on first use), defaults to the last 30 days with a hard one-year cap, applies the same filters as account history, and returns a download URL valid 24 hours that only opens for the authenticated holder. These are real constraints an agent must know before calling.

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?

Information is front-loaded: audience and access condition first, then what is produced, period limits, and return value, ending with the usage trigger. Dense but each sentence carries distinct facts; the opening clause is slightly overloaded.

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 supplies exactly what it must: the return value (a 24-hour download URL restricted to the logged-in holder) and the operational envelope (default and maximum period, filter parity with history). Nothing essential for a correct call 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 57% and the description supplies key semantics the schema lacks: the default period (30 days) and the one-year maximum for du/au, plus the fact that the other filters mirror account history. The enum parameters (mode, sens, statut, pays) are left to the schema, so it does not fully 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?

States a specific verb and resource: "Fait le relevé des transactions en PDF, au format officiel des documents Tchin", scoped to a period and filters. This is clearly distinguishable from siblings such as mes_transactions (raw history) or rapport_ventes (sales report).

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?

Explicit trigger given: "À utiliser dès que l'utilisateur demande un relevé, un PDF ou un document de ses transactions." It does not name an alternative (e.g. mes_transactions for a non-PDF listing), so no explicit exclusion, but the positive routing condition is 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 mark the tool as read-only, non-destructive, and closed-world. The description adds useful behavioral context by stating that authentication is required the first time and that only currently working networks are returned alongside their fees.

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

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

The description is two sentences and reasonably front-loaded, though the authentication prerequisite appears before the actual purpose. It avoids unnecessary repetition and stays focused on eligibility and 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 one simple parameter and no output schema, the description sufficiently explains the return content, including network code, name, fees, and current availability. It also covers the authentication requirement, leaving no major gap 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 description coverage is 100%, and the single enum parameter is fully documented in the schema. The description only restates that the query is for a country, adding little semantic detail 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 the resource: Mobile Money networks that can receive a withdrawal in a given country, including their fees and current operational status. It goes beyond the title by specifying the returned fields, though it does not explicitly differentiate itself from action-oriented siblings such as retirer_mobile_money.

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 mentions that the user must be connected to a Tchin account, but this is an eligibility prerequisite rather than guidance on when to use this tool versus alternatives. It does not name retirer_mobile_money or explain that this tool should be used to discover networks before initiating a withdrawal.

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 declare readOnlyHint=false, idempotentHint=false and destructiveHint=false; the description goes well beyond them by disclosing the two-step confirmation flow, the 15-minute validity window of the tchin.tech confirmation URL, PIN-based user confirmation, and that fees are deducted from the requested amount. It does not say what happens on expiry or failure, which is the main remaining 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?

Purpose is front-loaded in the first two clauses, then prerequisite, then non-execution warning, then next step. Every sentence carries operational information; nothing is repeated from the title or 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?

For a mutating money-movement tool with no output schema, the description covers what is returned (a tchin.tech verification URL), who confirms (the user, with a Tchin PIN), the time limit, the fee treatment, and the required next call. An agent has enough to invoke it correctly without additional context.

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 80%, so the schema already documents most fields; the description adds real meaning by clarifying that 'frais pris dans le montant' means the montant is gross of fees, and that reseau must come from reseaux_retrait. It does not resolve the ambiguity between 'pays' and 'depuis', whose schema descriptions are identical, and telephone remains undocumented in both places.

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 pair: withdraws money from a country balance to a Mobile Money number, with fees taken from the amount. It also scopes the audience (Tchin merchant or individual, login required on first use), which lets an agent separate it from siblings like envoyer_argent, deplacer_argent or tchin_mobile_money.

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 names the prerequisite (call reseaux_retrait first to learn networks and their fees) and the follow-up (call etat_demande). It also states the crucial when-not-to-expect-execution condition: the call does not move money immediately, it prepares a request the user must confirm with their Tchin PIN.

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

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

Adds substantial behavior beyond the annotations: the call is non-destructive on its own ('NE FAIT RIEN TOUT DE SUITE'), it prepares a request, returns a tchin.tech URL where the user confirms with a Tchin PIN, and the request expires in 15 minutes. This explains the async confirmation flow that readOnlyHint/destructiveHint flags alone cannot convey.

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

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

Compact and mostly front-loaded, with the critical no-op/confirmation caveat emphasized in capitals. Slightly better ordering would place the 'does nothing right away' warning before the deletion claim, but every sentence earns its place.

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

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

With no output schema, the description correctly supplies the return behavior (a tchin.tech confirmation address) and the time limit, plus the required next step. Nothing an agent needs in order to call this correctly and handle the result 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 single parameter has 100% schema description coverage ('Le nom ou le numéro de l'application'), so the schema already carries the semantics. The description adds no format, matching, or ambiguity-resolution details about the identifier beyond what the schema states; baseline 3 applies.

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

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

States a specific verb and resource ('Supprime une application API') plus the concrete consequence ('ses clés ne marcheront plus'), which distinguishes it clearly from creer_application and mes_applications. An agent knows exactly what this tool accomplishes 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?

Explains the applicable context (logged-in Tchin user, merchant or individual) and explicitly routes to the follow-up tool: 'Ensuite, appelez etat_demande.' It does not state any exclusion or alternative for deletion, but the workflow guidance is clear and actionable.

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, and the description adds useful context beyond them: deletion is permanent and already-received payments remain unaffected. It also discloses the authentication requirement, which is not visible in 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 definition is compact and contains no wasted words. The action statement comes after the authentication context, which is slightly less front-loaded than ideal, but the text remains 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 single-parameter destructive tool, the description is sufficiently complete: it covers authentication, permanence, and the important caveat that existing payments remain. With annotations covering the safety profile and the schema covering the parameter, little is missing.

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

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

Schema coverage is 100%, and the single parameter is fully documented in the schema as the link address or its code. The description does not add any additional meaning about the parameter, 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 ('Supprime définitivement') and names the resources being deleted: a payment link or a form. It is clear what the tool does, though it does not explicitly distinguish itself from close siblings such as modifier_lien or annuler_lien_retrait.

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 states the required context: the user must be connected to a Tchin account, either merchant or individual, with authentication requested the first time. However, it gives no explicit guidance on when to choose this tool over alternatives like modifier_lien or annuler_lien_retrait.

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 declare readOnlyHint=false and destructiveHint=false, indicating a non-read, non-destructive write, yet the description says nothing about what side effect occurs, whether a payment is initiated, or what the required token represents. It adds only the conversational-sheet context, leaving the mutation behavior opaque.

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 scoping constraint, so it is not bloated. But the second sentence merely restates the title and does not earn its place, and the whole is under-specified rather than tight.

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 three parameters, no output schema, and only sparse annotations, the description needed to carry significant explanatory weight. Instead it omits the token's role, the devise semantics, and the write behavior, and even references an 'adresse' that isn't a parameter, leaving the agent under-equipped 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 coverage is 0%, so the description must explain token, devise, and montant. It mentions 'montant' (matching one param) and implies a crypto devise, but 'adresse' does not correspond to any schema property — a confusing mismatch — and the required 'token' is never explained.

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

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

The description is essentially the title restated — 'Adresse et montant crypto' — with no verb describing what the tool actually does (e.g., submit, prepare, or record a crypto address/amount). It adds a scope constraint ('Réservé à la feuille de paiement Tchin') but an agent still cannot tell what action this performs versus siblings like tchin_feuille or tchin_crypto_etat.

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?

'Réservé à la feuille de paiement Tchin affichée dans la conversation' gives a concrete gating condition for when to call it, which is real guidance. However, it doesn't state when NOT to use it or name alternatives such as tchin_mobile_money or tchin_feuille, leaving the agent to infer the boundary.

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 declare readOnlyHint=false with destructiveHint=false, so this is a mutation-capable but non-destructive, closed-world tool. The description's 'suivre' (track) reads like a read operation and never explains what side effect justifies the non-read-only annotation, what credentials the token needs, or what happens on repeat calls. It adds only the conversation-sheet scoping constraint.

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

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

Two short sentences, front-loaded with the scoping constraint, with no filler. The second sentence largely restates the title, which is the only wasted 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?

For a three-parameter, mutation-capable tool with no output schema and zero schema documentation, the description should explain parameters and the effect of calling it. Instead it covers only the usage context, leaving the agent without enough information to invoke 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 0% across three parameters, and the description mentions none of them. In particular it leaves the near-duplicate 'jeton' and 'token' string parameters completely unexplained, forcing the agent to guess which identifier to supply and what 'simuler' toggles.

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?

It gives a verb and resource ('Suivre un paiement crypto') plus a scoping constraint ('réservé à la feuille de paiement Tchin affichée dans la conversation'), which hints at what it does. But it does not distinguish itself from close siblings such as tchin_crypto, tchin_suivi, etat_paiement or detail_paiement, so an agent cannot tell which one to pick from the description alone.

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 first sentence states a real precondition: the tool is only for the Tchin payment sheet displayed in the conversation. That is useful implied guidance, but no alternative tool is named for when that context is absent, and there are no explicit when-not rules.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that: it never explains what is configured, whether state changes, or what the returned effect is — and "configuration" sits slightly awkwardly against the readOnly hint without any clarification.

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 the scope stated first — appropriately sized and front-loaded. The economy is not a virtue here, though, because the brevity reflects under-specification rather than tight phrasing.

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, no documented parameters, and a vague mutation-like verb, the description should carry the load but does not. An agent cannot determine what to pass for `token`, what a successful call yields, or how this differs from the many other tchin_* 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?

There is a single required parameter, `token`, with 0% schema description coverage and no explanation in the description. The description does not say what the token identifies, where it comes from, or what form it takes, so the agent must guess.

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 second sentence, "Configuration de la feuille," simply restates the title, and the first only adds the scope "réservé à la feuille de paiement Tchin affichée dans la conversation." Neither states what configuring actually does or what changes as a result, so an agent can only tell it concerns a payment sheet, not what operation it performs.

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?

"Réservé à la feuille de paiement Tchin affichée dans la conversation" does narrow the context to the in-conversation sheet, which is a usable usage constraint. But no alternative sibling (e.g. afficher_lien_tchin, ouvrir_tchin, tchin_suivi) is mentioned, and no exclusion or prerequisite is given.

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

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

Annotations already declare readOnly=false, destructive=false and openWorld=false, so the mutation profile is covered. The description adds one genuinely new behavior — the client must confirm on their phone — but says nothing about the resulting state (pending vs completed), latency, or failure handling for a tool with 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?

Two short sentences with the critical precondition front-loaded and no filler. Slightly redundant since the parenthetical largely restates the title, but nothing is wasted.

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

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

For a six-parameter mutation tool with zero schema documentation and no output schema, two sentences is thin. The description leaves undocumented parameters, the return/state after launch, and the phone-confirmation flow's implications for follow-up calls.

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 0% across six parameters, and the description never names or explains any of them. It does not say what token authorizes, what pays/numero/reseau mean, or the currency and unit of montant, so the schema's heavy burden is entirely unmitigated.

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 concrete action ("Lancer un Mobile Money") and clarifies the mechanic ("le client valide sur son téléphone"), so the agent knows this initiates a push-confirm payment. It does not distinguish itself from nearby siblings such as retirer_mobile_money or envoyer_argent, so the resource boundary stays partly ambiguous.

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 opening clause "Réservé à la feuille de paiement Tchin affichée dans la conversation" is a real precondition that tells the agent when this tool is valid. It gives no explicit alternative for when that sheet is absent, so an exclusion is implied 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 readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered and there is no contradiction. Beyond restating the title, the description adds only the sheet-scoping constraint; it says nothing about what is retrieved, whether repeated calls are cheap/idempotent, what happens if the sheet is no longer displayed, or what the agent gets back for a tracking 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?

Two short sentences with the scoping constraint front-loaded; nothing is padded. It is efficient, though the second sentence is pure title repetition and therefore does not fully 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 token-gated tracking tool with no output schema and no parameter documentation, the description should at minimum say what state is being tracked and what comes back. Instead it delivers a scope restriction and a restated title, leaving the agent unable to predict the outcome of invoking it.

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

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

Schema description coverage is 0% for both parameters, and the description never mentions "token" or "suivi" at all. An agent must guess that the required token is an auth/context token obtained from the referenced payment sheet and that "suivi" is a tracking identifier; the description does not compensate for the coverage 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 sentence "Suivre un Mobile Money" is a verbatim restatement of the title, so on its own it is tautological. The only added information is the scoping sentence "Réservé à la feuille de paiement Tchin affichée dans la conversation", which narrows the context but never explains what "suivre" actually does (poll a status? subscribe? record?) or how it differs from close siblings such as tchin_mobile_money, tchin_feuille, or detail_paiement.

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 state a precondition for use — it is reserved for the Tchin payment sheet currently displayed in the conversation — which is real usage guidance. However, it names no alternative tool and gives no when-not guidance, which is a notable gap given the density of Tchin-prefixed and Mobile Money siblings.

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