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

No annotations are provided, so the description carries the full burden. It does disclose one important trait — the call is preview-only unless confirm=true, i.e. a dry-run by default — but says nothing about required permissions, what happens on failure, or what the response contains for a mutating 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?

Two tightly packed sentences: the purpose and an illustrative example come first, then the crucial preview caveat. Nothing is redundant and nothing needs trimming.

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 4-parameter mutation tool with no annotations, no output schema, and zero schema descriptions, the description covers purpose, an example, and the dry-run default but omits date formatting, what field_id refers to in the domain, and any error/return behavior.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the confirm flag's effect explicitly and loosely grounds field_id (the free-text field) and text (the example string), but leaves the date parameter's expected format entirely unspecified.

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 — adding a free-text line into a day's free-text field — and reinforces it with a concrete example ('un vol d'initiation « M. Dupont 15h 30 min »'). An agent can distinguish this from a normal signup, though the description never names its closest siblings (add_signup, add_freetext_signups_bulk) to make the distinction 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?

No when-to-use or when-not-to-use guidance, and none of the sibling tools (add_signup, add_freetext_signups_bulk, update_signup) are referenced as alternatives. The example implies a use case but the agent must infer the choice between this and a regular signup.

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?

No annotations are provided, so the description must disclose behavior. It does reveal the critical preview-by-default behavior via confirm=true, which is meaningful. However, it lacks other behavioral details such as permissions, reversibility, error handling, and what the preview returns, leaving gaps for a mutation 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?

Two short sentences with zero waste. The action and scope are front-loaded, followed by the confirm condition. Highly efficient.

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

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

Given a 4-parameter mutation tool with no annotations and no output schema, the description covers the core action and preview behavior. It remains incomplete about return values, permissions, and date/text formatting, so an agent may need to infer or experiment. Adequate but not fully satisfying for the complexity.

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

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

Schema coverage is 0%, so the description must compensate. It gives semantic roles for all four parameters: date is the day, field_id is the free-text field, texts are the multiple free-text lines, and confirm controls preview versus execution. It still omits format specifics (e.g., date format, integer field_id), but adds useful meaning beyond bare schema titles.

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: adding multiple free-text lines at once into a day's free-text field. The bulk scope is clear and distinguishes it from the singular sibling add_freetext_signup, even though it doesn't name the sibling explicitly. An agent can immediately tell this is the batch variant.

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 tells the agent how to execute versus preview: without confirm=true it is preview only. This is a clear rule for how to use the tool. It doesn't name alternatives like add_freetext_signup, but the bulk wording implies when to choose it over single-entry tools.

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

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

With no annotations, the description carries the full burden, and it does disclose the important side effect (automatic confirmation/waiting-list emails) and the preview-without-confirm behavior. However it omits auth/permission needs, duplicate-signup behavior, and reversibility, leaving meaningful gaps for a mutation 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?

Two compact sentences that front-load the core action and then the key behavioral caveat. Little waste, though the parenthetical French param labels add some density without much added value.

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

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

For a 6-param mutation tool with zero annotations and no output schema, the description covers the main action and the critical confirm/email behavior but leaves the date parameter, error cases, and required permissions unexplained.

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 compensate, and it does map several params (user_id, field_id, signup_parameter, signup_comment) to their roles and marks the latter two optional. But it adds no format or semantic detail, and the required 'date' param is only implied via 'journée'.

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 (inscrit/registers) and resource (a member/user_id into a field/field_id on a given day), which makes the operation concrete. It does not explicitly differentiate itself from the similar sibling add_freetext_signup, so an agent could still wonder which add-variant applies.

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

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

The description explains the confirm=true preview gate, which is useful, but gives no explicit when-to-use vs the many siblings (add_freetext_signup, add_freetext_signups_bulk, update_signup). No exclusions or selection conditions are 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?

With no annotations, the description carries the full burden, and it does disclose a meaningful trait beyond the schema: without confirm=true the call is preview-only and does not commit. That said, it says nothing about required permissions, whether a confirmed create is reversible, or what the response contains, so the disclosure is partial.

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

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

Two short sentences with zero padding; the core action and its parameters come first and the important confirm/preview caveat is appended compactly. Every clause earns its place.

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

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

For a 4-parameter mutation tool with no annotations and no output schema, the description covers all parameters and the critical dry-run gate, which is the information an agent most needs to avoid an accidental write. Missing only secondary detail such as permission requirements and error behavior.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: date format is given as AAAA-MM-JJ, duration is clarified as days, and confirm's effect (preview vs commit) is explained. Only 'title' is left without added semantic detail, which is self-evident.

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 un événement') plus the accepted date format and that duration is in days, so an agent knows exactly what the tool produces. It does not explicitly contrast itself with update_event or delete_event, so it stays at 4 rather than 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?

The confirm=false preview behavior is a genuine usage condition and is stated explicitly, which implies a two-step preview-then-commit workflow. However, there is no explicit when-to-use guidance relative to siblings (update_event, delete_event, get_next_events) and no stated prerequisites or 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?

With no annotations provided, the description carries the full behavioral burden. It usefully discloses that an activation email is sent and that a preview mode exists without confirm=true. It still omits permission requirements, error behavior for duplicate emails, reversibility, and what happens to other defaulted fields.

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

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

The description is two short sentences, front-loading the core action and its side effect. The roles and confirm notes are efficient and there is no 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 7-parameter creation tool with no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It omits required-field guidance beyond relying on the schema, does not clarify name versus first_name, and says nothing about the returned user object or error handling.

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 must compensate for all 7 parameters. It explains only roles (list of role IDs, see get_roles) and confirm (preview behavior); the remaining five parameters, including the confusing name vs first_name distinction, phone_number, and preferred_language, are 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 states a specific verb and resource: 'Crée un membre' (creates a member). It also adds the key side effect that an activation email is sent. It does not explicitly distinguish itself from sibling tools like update_user or add_signup, but the creation action is clear.

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

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

It gives one important usage condition: 'Sans confirm=true : aperçu seulement' (without confirm=true, preview only). This tells the agent how to avoid unintended creation. However, it does not state when to use this tool versus alternatives such as update_user or add_signup, nor does it mention prerequisites like permissions.

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

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

With no annotations, the description carries the full behavioral burden and does well on critical points: it is destructive and bulk, it requires confirm=true for actual deletion, and send_emails=true notifies every member by email. It still omits permissions, reversibility, and rate-limit behavior.

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

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

Three short sentences, front-loaded with the destructive scope. Every sentence carries concrete information about deletion, email side effects, and preview safety.

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 bulk tool with no annotations, no output schema, and 0% schema coverage, the description covers the key invocation safety checks but omits auth requirements, reversibility, and what the preview return 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 description coverage is 0%, so the description must compensate. It explains confirm and send_emails well, including defaults and the preview behavior, but adds no format or meaning for date and field_id beyond the implied day/field scope.

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 with clear scope: deletes ALL signups for one field on one day. The 'TOUTES' and day/field scoping distinguishes it from the sibling delete_signup tool, which appears to target a single signup.

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

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

The description implies usage through the preview gate ('Sans confirm=true : aperçu seulement') and bulk scope, but it names no alternatives and gives no explicit when-to-use vs delete_signup or delete_signup_by_user guidance.

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

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

With no annotations provided, the description carries the full disclosure burden, and it does the most important part: revealing that the default (confirm absent/false) is a non-destructive preview, so the agent knows deletion only occurs when confirm=true is passed. It stops short of saying the deletion is irreversible or what errors/authorization are involved, which leaves some behavioral gaps for a mutation 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?

Two short, front-loaded sentences with zero filler: the action first, then the safety-relevant condition. Every word earns its place.

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

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

For a destructive, no-annotation, no-output-schema tool, the description covers the preview/confirm gate but omits irreversibility, failure modes, and authorization. An agent could invoke it correctly given the confirm semantics, but the risk profile is only partially described.

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 must compensate for both parameters. It does explain the semantics of 'confirm' (gate for actual deletion vs preview), which is the non-obvious one, but says nothing about 'message_id' (e.g. format, source, what happens if the ID does not 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?

States a specific verb+resource ('Supprime un message du forum du jour'), which cleanly separates it from the sibling post_daily_forum_message and update_daily_forum_message. It does not, however, explicitly name a sibling or explain how it differs from those at the behavioral level.

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 clause 'Sans confirm=true : aperçu seulement' tells the agent the exact two-step pattern (preview first, then confirm) for this specific tool. Beyond that there is no when-to-use guidance, no mention of alternatives such as update_daily_forum_message, and no prerequisites such as required permissions.

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

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

With no annotations, the description carries the full burden and does disclose the critical safety behavior: without confirm=true the call is a preview only, and delete_all expands the scope to all occurrences across days. It does not mention permissions, irreversibility, or rate limits, so a small gap remains.

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

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

Three short sentences, front-loaded with the core action before the two parameter behaviors. No filler, though the flag semantics could be grouped more tightly.

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 tool with no annotations and no output schema, the description covers the essential information an agent needs: the destructive action, the preview-by-default gate, and the widened scope flag. Permission and return-value details are absent but not required 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 coverage is 0%, so the description must compensate, and it does for confirm (preview vs real delete) and delete_all (all occurrences over multiple days). Only event_id is unexplained, but that is self-evident from its name and required status.

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 un événement'), and the resource name itself distinguishes it from siblings like delete_signup and delete_user. It is clear but does not explicitly contrast itself with any alternative event 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 explains the confirm gate ('Sans confirm=true : aperçu seulement') and the delete_all scope, which is real usage context for the parameters. However it never says when to prefer this tool over siblings such as update_event or the various delete_signup variants, so tool-selection guidance 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?

No annotations are supplied, so the description carries the full burden, and it does disclose two high-value behaviors: the destructive action is gated behind confirm=true (otherwise preview only), and send_emails defaults to true and notifies affected members. It still omits permission requirements and whether the deletion is reversible.

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

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

Three short, front-loaded sentences with zero filler: the action, the side effect, and the safety gate, in that order. Every clause earns its place.

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

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

For a destructive tool with no annotations and no output schema, the description covers the critical safety and side-effect semantics an agent needs before calling. The absence of return-value or error information is a minor gap given the tool's simplicity.

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 compensate, and it explains two of the three parameters: send_emails (default true, emails members) and confirm (preview unless true). signup_id is left implicit, which is reasonable given the name, but the coverage gap keeps it below 5.

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 inscription par son identifiant'), so an agent immediately knows this is a deletion keyed by ID. It does not, however, distinguish itself from the close siblings 'delete_signup_by_user' or 'delete_all_field_signups', so the top score is not earned.

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

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

The description gives clear operational guidance on how to invoke the tool safely: without confirm=true it only produces a preview, so the agent knows to preview before committing. It does not, however, route the agent between this tool and its deletion siblings, which keeps it from a 5.

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

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

With no annotations, the description carries the full burden and does disclose two non-obvious behaviors: send_emails defaults to true and triggers email notification, and without confirm=true the call is a dry-run preview. It omits permissions and reversibility, but the dry-run gating and side-effect disclosure are substantive for a destructive 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?

Three short sentences, front-loaded with the action and followed by the two behavioral caveats. Dense with no filler; only slightly terse given the destructive nature of 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 destructive, 5-param tool with no annotations and no output schema, the description covers the key safety behaviors (dry-run, email side effect) but omits what a preview returns, what happens to the deleted record, and permission requirements. Adequate but with clear gaps.

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

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

Schema description coverage is 0% across 5 params, so the description must compensate and only partially does: it explains send_emails (default true, sends email) and confirm=true (preview gating), covering 2 of 5. date, user_id and field_id are left entirely to their self-descriptive titles.

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 (supprime/delete) and resource (inscription d'un membre dans un champ donné d'une journée), so an agent knows it removes one member's signup for a specific field/day. It is clear, but it does not explicitly distinguish itself from the closely-named siblings delete_signup and delete_all_field_signups, which the agent must infer.

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 confirm=true / preview-only note gives practical usage guidance for the delete flow, but the description never states when to choose this tool over delete_signup or delete_all_field_signups. Usage is implied rather than routed against alternatives.

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

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

With no annotations, the description carries the full burden and does well: it declares the operation irreversible and discloses a dry-run/preview default via confirm. It omits permission requirements and downstream effects (e.g., what happens to the user's signups or messages), which keeps it short of 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?

Three terse sentences, front-loaded with the action, then the irreversibility warning, then the confirm nuance. Every sentence earns its place and there is zero 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 two-parameter destructive tool with no annotations and no output schema, the description covers the essential facts an agent needs: what it destroys, that it cannot be undone, and how to preview first. Only auth/permission expectations and side effects on related data are missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it explains the critical semantic of confirm (absence = preview only), which the schema's bare boolean does not convey. user_id is left implicit but is self-evident; the key non-obvious parameter is covered.

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 un membre du club'), making it immediately distinguishable from sibling delete tools like delete_signup or delete_event. It does not name siblings explicitly, but the resource scope is unambiguous, so 4 is appropriate.

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 conveys an important mode condition ('Sans confirm=true : aperçu seulement'), which tells the agent the tool is safe to call without confirm. However, it gives no guidance on when to prefer this tool over alternatives (e.g., removing a signup vs. a user) or any prerequisites, so usage is only implied.

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?

No annotations are provided, so the description carries the burden, and it does disclose the key behavioral trait: this reads local counters and does NOT perform an API call, so it consumes no quota and has no side effects. It stops short of stating that the returned counters reset at period boundaries, but for a read-only local counter the disclosure is meaningful.

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. The core purpose and its numeric meaning are front-loaded, and the side-effect disclaimer follows as a compact second 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?

With zero parameters and no output schema, the description must explain what comes back, and it does: today's call count against a 300 limit and last minute's count against a 20 limit, plus the fact that no API call is made. Nothing needed to invoke 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?

The tool takes zero parameters, so there is nothing to document and no risk of ambiguity. Baseline 4 applies; the description correctly omits parameter discussion.

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 reports local consumption of the API quota, and even quantifies the limits (calls today / 300, last minute / 20). No sibling tool overlaps with this purpose, so the agent can identify it immediately 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?

Usage is implied rather than stated: 'N'appelle pas l'API' hints that this is a cheap, local, safe-to-call check, but no when-to-use/when-not-to-use guidance or alternatives are named. Adequate for a trivial zero-argument utility, but nothing explicit.

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

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

No annotations are provided, so the description carries the burden. It usefully declares read-only behavior and a single API call (cost/latency hint), but says nothing about return format, pagination, or whether the day has to contain activity.

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 action and resource, with no redundant restatement of the tool name 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 one-parameter read-only tool with no output schema, the description covers the date format, the read-only nature, and the API cost. It is close to complete, lacking only guidance on alternative read tools and result shape.

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% and the single parameter has no schema description, so the description must compensate. Its '(AAAA-MM-JJ)' gives the required date format, which is exactly the missing information; only range/timezone semantics are left unstated.

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 (lit) and resource (messages du forum) with a clear scope (d'une journée). The day-scoped read is readily distinguishable from the write siblings post_daily_forum_message / update_daily_forum_message / delete_daily_forum_message, 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?

No indication of when to use this rather than get_forum_conversations, list_messages, or the write siblings. The day-scoped intent is only implied by the parameter, so the agent must infer the routing decision.

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

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

With no annotations, the description carries the full burden. It explicitly discloses that it is read-only ('Lecture seule') and that it makes a single API call, which adds useful behavioral context. However, it does not describe pagination, permissions, or the structure of returned data beyond mentioning messages.

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 short, front-loaded sentences with no filler. Every word contributes to stating the purpose and the key behavioral traits (read-only, single API call).

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 tool with no output schema and no annotations, the description is adequate but lacks important context. It does not clarify how results are returned (e.g., pagination, ordering) or when to choose it over similar read tools, leaving gaps that an agent might need to resolve.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. The baseline for zero parameters is 4, as the description cannot add further meaning beyond what the empty schema already implies.

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 ('Lit') and resource ('conversations du forum général du club avec leurs messages'), clearly indicating it reads general forum conversations and includes their messages. It implicitly differentiates from siblings like get_daily_forum by specifying 'général', but does not explicitly name or contrast with alternatives.

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

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

There is no guidance on when to use this tool versus alternatives such as get_daily_forum or list_messages. The description only states what it does and that it is read-only with one API call, leaving usage context 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?

With no annotations provided, the description carries the full burden, and it does disclose two useful traits: read-only operation and a single API call (cost/rate-limit relevant). It stops short of explaining what 'next' means (count, time window, timezone) or pagination behavior.

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

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

Two short sentences with no filler, and the scope/grouping constraint is front-loaded. Given the tool's zero-parameter simplicity, this is appropriately sized.

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 0-param, read-only tool with no output schema, the description supplies the essentials: what is returned, how it is organized, and that it is a cheap read. It does not define the meaning or bound of 'prochains', which is the one 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 takes zero parameters, so there is nothing for the description to disambiguate; baseline for a 0-param schema is 4. Schema coverage is 100% and no parameter meaning is missing.

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

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

States a specific verb and resource ('Liste les prochains événements'), plus the output shape ('regroupés par date'). This clearly distinguishes it from the create_event/update_event/delete_event siblings, though it never names or contrasts with any 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?

There is no explicit when-to-use statement, but none is really needed since no other sibling lists events. The description only implies usage via 'prochains événements', leaving the agent to infer that it is the canonical read path for upcoming events.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose two useful traits beyond the name: read-only semantics ('Lecture seule') and low cost ('1 appel API'). It says nothing about permissions/auth requirements or error behavior, so it is only partially transparent for a tool with zero 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?

A single short sentence with the resource first and the operational traits second. Every clause earns its place and nothing is 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?

For a no-parameter, read-only listing tool with no output schema, the description covers the essentials: what is listed and what the returned items contain. Without an output schema, a slightly fuller statement of the return shape would have made it fully self-sufficient.

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 4 applies. The parenthetical naming of returned fields adds a bit of value even though no input semantics 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?

States a specific verb and resource ('Liste les rôles du club') and even names the returned fields ('identifiant et nom'). It is clear what the tool does, but it makes no attempt to position itself against sibling list tools such as get_users or get_signups.

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 the name and the fact that it returns roles; an agent can infer it should be called when role data is needed. There is no explicit when-to-use/when-not guidance or mention of alternatives, but none of the siblings expose role data, so the risk of misselection is low.

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

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

With no annotations, the description carries the full burden; it usefully discloses that the operation is read-only and costs one API call, which matters against the many mutating signup siblings. It omits auth requirements, result format, and pagination behavior.

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

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

A single compact sentence that front-loads the resource and outcome, followed by two brief parenthetical qualifiers for the date format and read-only/API-cost traits. No wasted words.

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

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

For a one-parameter read tool with no output schema, the description states the resource, the scope, the date format, the read-only nature, and the API cost. It could say more about the returned structure, but what an agent needs to call it is largely present.

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

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

Schema coverage is 0% and the 'date' property has no description, so the description must compensate. It does so by specifying the expected format '(date AAAA-MM-JJ)', which is exactly the missing information an agent needs to invoke correctly.

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

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

States a specific verb ('Liste') and resource ('les champs du planning et les inscriptions') scoped to a single day, which implicitly distinguishes it from get_signups_range. It does not name the range sibling explicitly, so differentiation requires inference from the '(une journée)' scoping.

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 single-day scope implies when this tool applies versus get_signups_range or the add_signup/update_signup mutators, but no explicit when-to-use, prerequisites, or alternatives are stated. Usage is inferable rather than spelled out.

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

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

With no annotations, the description carries the full burden, and it does add value by declaring 'Lecture seule (1 appel API)' — a safety and cost/quota signal. However it omits return shape, pagination, or result-size behavior for a listing tool, leaving meaningful gaps.

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

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

Two compact sentences, front-loaded with the core purpose before the format and read-only notes. Every clause contributes; nothing is 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?

For a simple 2-param listing tool with no output schema or annotations, the definition covers purpose, format, and read-only status, but omits anything about the returned data or result limits. It is adequate but leaves the agent guessing on outputs.

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 must compensate; it usefully specifies the date format (AAAA-MM-JJ) and that bounds are inclusive, which is genuine semantic value. It still does not clarify per-parameter meaning beyond the obvious names, so it only partially compensates.

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 ('Liste') plus resource ('inscriptions') plus scope ('plage de dates'), and the inclusive-bounds format makes the range semantics concrete. It does not explicitly name the sibling get_signups to contrast with, so it falls short of full differentiation.

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

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

The date-range scoping implies when this tool is appropriate versus an unfiltered list, but there is no explicit 'use this when / use get_signups instead' guidance. Usage is only inferable from the range wording.

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

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

With no annotations provided, the description carries the full burden and does disclose meaningful traits: read-only behavior, a cost signal (single API call), and the fact that the payload is personal data. It stops short of stating required permissions or result volume/pagination behavior, which are the remaining unknowns for a read 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?

A single compact sentence plus two short fragments, front-loaded with the resource and the returned fields. Every clause earns its place; no filler or redundancy.

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

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

For a parameterless read tool with no annotations and no output schema, the description compensates well by naming the returned fields. It is nearly complete, missing only permission requirements and any indication of result size or pacing.

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. There is nothing further the description could add about inputs, and it does not attempt to invent or misdescribe any.

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

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

States a specific verb and resource ('Liste les membres du club') and enumerates exactly what each record contains (nom, email, téléphone, rôles, dernière visite). This clearly separates it from sibling read tools like get_roles and the mutation tools create_user/update_user/delete_user.

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

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

No when-to-use guidance, no prerequisites, and no named alternatives. It does not tell the agent when to prefer get_users over get_roles or get_signups, nor whether it needs any scope or permission to run; usage is only inferable from the resource name.

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

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

With no annotations, the description carries the full burden and does well: it discloses ordering, pagination behavior (page, page_size ≤ 100), the non-destructive trait ('rien n'est marqué comme lu'), and a quota/transport nuance (headless browser, not API quota). It omits what a returned conversation looks like and any permission requirements, leaving some behavioral detail unstated.

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 purpose is front-loaded, followed by folder semantics, pagination, then behavioral caveats, in a tight multi-line format with little waste. Dense but each clause adds information; minor density could still 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 four-parameter list tool with no annotations and no output schema, the description covers scope, ordering, folder semantics, pagination limits, and non-destructive behavior. The notable hole is the undocumented unread_only parameter and the absence of any hint about the return shape.

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 must compensate. It documents folder values (inbox/sent/all) and page/page_size with the ≤100 cap, covering three of four parameters, but says nothing about unread_only, which is left completely undocumented in both schema and description.

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

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

States a specific verb and resource ('Liste les conversations de la messagerie Click n' Glide'), the ordering ('les plus récentes d'abord'), and explicitly distinguishes itself from the read tool by noting it does not open conversations. An agent can differentiate it from read_message, send_message, and list_recipients at a glance.

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 context for folder selection with inline definitions ('inbox' reçus, 'sent' où j'ai écrit, 'all') and clarifies the tool is read-only in effect (nothing marked as read). It does not, however, name an explicit alternative or state when-not-to-use this versus read_message, so it stops short of the full when/alternatives specification.

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?

No annotations are provided, so the description carries the full burden. It discloses the return composition (members with id/name/roles, groups including 'Tous' plus one per role with member counts), which is genuinely useful, but says nothing about permissions, rate limits, or that it is a non-destructive read.

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

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

A single front-loaded sentence with no filler, leading with the verb and the scope. It is dense but readable, and nothing needs to 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?

With no output schema, the description usefully compensates by describing the returned entities and their fields. For a zero-argument read tool this is nearly complete; only the absence of any safety/permission framing keeps it from a 5.

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 per the baseline this scores 4. The description correctly spends no words on arguments and instead describes the response content.

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?

Specific verb (Liste) plus resource (destinataires sélectionnables dans la messagerie) and it enumerates what the result contains: members and groups. It is clearly distinguishable from write siblings like send_message or add_signup, though it doesn't explicitly name its closest read siblings (get_users, list_messages).

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 messaging context hints at why you would call it, but there is no explicit when-to-use statement, no prerequisites, and no routing to alternatives such as get_users or get_roles for the underlying data. The agent must infer the trigger.

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

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

With no annotations, the description carries the full burden. It discloses the important dry-run behavior ('Sans confirm=true : aperçu seulement'), but says nothing about required permissions, whether posting on behalf of user_id needs elevated auth, or side effects of the real post.

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, purpose front-loaded before the confirm caveat, with no filler. Appropriately sized for the tool, though terse given the remaining coverage gaps.

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 no annotations, no output schema, and 0% parameter coverage, the description omits auth requirements, return/confirmation behavior, and the date/text parameter meanings. The preview note is helpful but far from complete.

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

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

Schema coverage is 0%, so the schema gives only bare titles. The description usefully clarifies confirm (preview vs real post) and implies user_id is the author, but leaves 'date' (forum day/format) and 'text' (message body) unexplained, so it only partially compensates 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 (publie/posts) and resource (a message in the day's forum), and adds the identity dimension ('au nom du membre user_id'). It is clearly distinguishable from siblings like update_daily_forum_message and delete_daily_forum_message by the posting action, though it never names them.

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 confirm semantics implicitly tell the agent it can call in a safe preview mode versus actually posting, which is useful in-tool guidance. However, there is no explicit when-to-use/alternative routing against the sibling update/delete/post tools, so usage must be inferred.

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

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

With no annotations, the description carries the full burden, and it does disclose the most important behavioral trait: reading has a side effect on the read-state only when mark_as_read=true, plus the oldest-to-newest ordering. It omits return format and any failure behavior, but the critical state-change disclosure is present.

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

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

Two tight sentences, front-loading what the tool does before the default/flag nuance. No filler; every clause adds information, though it could be marginally tighter.

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 tool with no annotations, no output schema, and 0% schema coverage, the definition covers purpose and the read-state side effect adequately but leaves include_html unexplained and does not describe what the returned conversation 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 0%, so the description must compensate for all three parameters. It meaningfully explains mark_as_read (effect and default), but include_html is never mentioned and conversation_id is only implicit, so roughly one of three parameters is covered.

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?

Names a specific verb (reads) and resource (a complete messaging conversation, all messages oldest to newest), giving scope and ordering. It is clear on its own, but it does not distinguish itself from the sibling list_messages, and the singular name 'read_message' belies the whole-conversation scope.

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 default (does not mark as read) versus the mark_as_read=true variant, which is genuine usage guidance for that flag. However it names no alternative tool and gives no condition for choosing this over list_messages, leaving the key routing decision 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?

With no annotations, the description carries the full burden and does disclose two key behaviors: messages also go out by email (side effect) and the default confirm=false path is a dry-run that only returns the resolved-recipient preview. It omits auth/permission requirements and error behavior for unresolved recipients.

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 action and channel before the recipient mechanics and the confirm gate. Every clause carries information; slightly parenthetical but 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 6-parameter tool with no annotations and no output schema, the description covers the essentials: what is sent, where it goes, how recipients are resolved, and the preview/send gate. It lacks authentication, rate-limit, and error-handling context, so it is strong but not 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?

Schema coverage is 0%, so the description must compensate, and it does for the non-obvious parameters: groups are keys from list_recipients with '*' meaning all, recipient_names are 'prénom nom', and confirm controls preview vs. send. subject and text are left undocumented but are self-explanatory from their names.

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

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

The description names a specific verb and resource ('Envoie un nouveau message via la messagerie Click n' Glide') and states the dual channel (messaging + email). This clearly separates it from the read-oriented siblings (list_messages, read_message) and the forum tools.

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

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

It gives clear operational context: recipients may be specified via recipient_ids and/or recipient_names and/or groups, and without confirm=true nothing is sent. The preview-first workflow is implied but it does not explicitly contrast with siblings like post_daily_forum_message or point to list_recipients/read_message as the follow-up steps.

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?

No annotations are provided, so the description carries the full burden. It does disclose a meaningful trait: the tool is a dry-run by default unless confirm=true. It says nothing about required permissions, reversibility of the edit, or what the preview returns, leaving gaps for a mutation 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?

Two short sentences with no filler, and the critical confirm/preview behavior is front-loaded right after the core action. Every clause earns its place.

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

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

For a 3-parameter mutation tool with no annotations and no output schema, the description covers the single most important behavioral fact (default preview). It omits permission requirements, post-confirm behavior, and return information, so it is adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the semantics of the confirm parameter (preview vs. apply), which is the most consequential one, but adds no format or meaning for message_id or text beyond what their names imply.

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: modifying the text of a message in today's forum. It is clearly distinguishable from post_daily_forum_message and delete_daily_forum_message by the verb alone. It stops short of explicitly naming those siblings, so it is clear but not maximally differentiated.

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

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

The phrase 'Sans confirm=true : aperçu seulement' implies the intended two-step workflow (preview, then commit), which is useful guidance. However, it offers no explicit when-to-use-vs-alternatives routing against the post/delete forum siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the dry-run behavior ('Sans confirm=true : aperçu seulement') and partial-update semantics ('date et durée sont transmises si fournies'), but says nothing about permissions required, reversibility, or whether a null field clears or preserves the existing value.

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

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

Three compact clauses, front-loaded with the verb and the ID source, with no filler. Nothing is padded, though the parenthetical placement slightly interrupts the flow.

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 5-parameter mutation tool with no annotations and no output schema, the description covers the essentials (ID source, confirm gate, optional fields) but omits return-value expectations, error behavior, and the exact meaning of omitted vs null fields.

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

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

Schema description coverage is 0%, so the description must compensate, and it does for several parameters: it clarifies that event_id is the fieldId returned by get_next_events (resolving the name mismatch with the schema's 'event_id'), explains confirm as the apply switch, and notes title/date/duration are optional and sent only when provided. It leaves duration units and date format unspecified.

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 ('Modifie un événement'), making it immediately distinguishable from create_event and delete_event. It also anchors the resource to an external source, but it does not explicitly name the sibling tool set it should not be confused 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 rather than stated: the reader must infer this is for changing an existing event and that get_next_events is the prerequisite for obtaining the ID. The preview-vs-apply condition (confirm=true) is given, but there is no explicit when-to-use/when-not guidance against siblings such as create_event.

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

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

With no annotations, the description carries the full burden and does disclose consequential side effects: it can move members to the waiting list and send emails, and it defaults to a safe preview unless confirm=true. Missing details are the exact return shape and whether changes are reversible, but the destructive surface is surfaced well.

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

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

Three short, front-loaded sentences with zero filler: purpose first, then side effects, then the confirm guard. Every clause earns its place.

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

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

For a mutation tool with no annotations and no output schema, the description covers purpose, side effects, and the preview/commit switch adequately. It is slightly thin on return behavior and the effect on unspecified fields, but nothing critical 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?

Schema description coverage is 0%, so the description must compensate, and it does for the three non-obvious parameters: confirm (preview vs execute), signup_parameter, and signup_comment. signup_id is implicitly the target but never named, which is a minor 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 (Modifie) and resource (inscription existante) plus the two mutable fields (paramètre et/ou commentaire), making it clearly distinct from add_signup and delete_signup. It is clear without opening the schema, though it never explicitly names a sibling alternative.

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

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

The description supplies the key operational condition: without confirm=true it is preview only, so the agent knows when it will actually write. It does not explicitly route the agent to alternatives (e.g. delete_signup) for other intents, so it falls short of full when/when-not guidance.

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

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

With no annotations at all, the description carries the full burden and does disclose two non-obvious behaviors: that 'roles' REPLACES the entire role list rather than appending, and that omitting confirm=true yields a preview/dry-run only. It still omits what happens to fields left unspecified and any permission requirements.

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

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

A single tight sentence plus two clauses, front-loaded with the action and resource. Every clause adds information (fields, REPLACE semantics, confirm gate) with no redundancy.

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

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

For a 6-parameter mutation tool with no annotations and no output schema, the description covers the critical role-replacement and preview behaviors but leaves permission requirements, handling of omitted fields, and response shape 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?

Schema description coverage is 0% across 6 parameters, so the description must compensate, and it does: it names the modifiable fields (prénom, nom, téléphone, rôles) mapping to schema properties, clarifies roles takes identifiers, and explains the confirm flag's effect. Only user_id and input formats 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?

States a specific verb+resource ('Modifie un membre') and enumerates the fields touched (prénom, nom, téléphone, rôles), which clearly separates it from create_user and delete_user among the siblings. It does not name a sibling explicitly, but the mutation verb makes the intent unambiguous.

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

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

Implies a workflow by pointing to get_roles for role identifiers and by describing the confirm=true gate, but never states when this tool should be used instead of alternatives or what prerequisites (permissions) are required. Usage context is inferable but not spelled out.

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