IDDET

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

With no annotations the description carries the full burden. It does disclose two useful traits: the operation targets the authenticated user's currently active subscription, and it is financially irreversible (pas de remboursement). It omits error behavior, reversibility of access, and what occurs to the subscription record.

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 sentence with zero filler, front-loading the action and resource, with the no-refund caveat parenthetically attached rather than buried.

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 destructive tool with no annotations and no output schema, the description covers the what, the whose, and the financial consequence, but leaves failure modes and post-cancellation state entirely unspecified.

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

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

Schema description coverage is 0% for the single auth_token parameter. The mention of 'l'utilisateur authentifié' hints that the token binds the action to the caller's own subscription, but the description adds no token format, source, or scope 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 (annule) and resource (l'abonnement Iddet Plus actif) plus scope (de l'utilisateur authentifié), which cleanly separates it from siblings like mcp_grant_subscription, mcp_get_subscription_status and mcp_list_subscriptions. An agent can pick this tool without opening any 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 only implied by the verb: cancel the active Iddet Plus subscription. There is no guidance on when this is appropriate versus checking mcp_get_subscription_status first, no prerequisites, and no statement about what happens if no active subscription exists.

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 full behavioral burden. It implies a write operation but does not disclose permissions required, whether the comment is immediately visible, rate limits, or any side effects. It only says what it does, not how it behaves.

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

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

The description is a single, front-loaded sentence that directly states the action. It is concise with no wasted words, though it may be too terse for a tool that requires authentication and has multiple parameters.

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

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

Given no annotations, no output schema, and three required parameters with 0% schema description coverage, the description is insufficient. It does not explain authentication (auth_token), the meaning of actfile_id, or the expected format of content. It leaves significant gaps 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 0%, so the schema provides no description for the three parameters. The description does not add any detail about the parameters (content, actfile_id, auth_token) beyond what their names imply. Baseline for 3 parameters with 0% coverage would be low, but the parameter names are fairly self-explanatory; still, the description does not compensate for the missing schema descriptions.

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

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

States a specific verb (Ajoute/Add) and resource (commentaire/comment to an actfile), clearly distinguishing it from siblings like mcp_like_actfile or mcp_list_actfile_comments. It is clear what the tool does, though it doesn't elaborate on the nature of an actfile.

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

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

No guidance on when to use this tool versus alternatives, prerequisites (e.g., must be logged in, must have access to the actfile), or any conditions. The description merely states the action without context.

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

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

With no annotations, the description carries the full burden, and it does disclose one real side effect beyond the schema: all of the author's subscribers are automatically notified. It says nothing about permission/auth requirements beyond the auth_token parameter, reversibility, or failure modes 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 tight sentences with the creation action front-loaded and the notification side effect appended. 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?

A write tool with no annotations, no output schema, and zero schema description coverage needs more than two sentences. Missing are auth/permission expectations, what category means, how community_slug and channel_slug interact or whether they must be paired, and any return/confirmation detail.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate and largely does not. It clarifies that content is Markdown and that community_slug/channel_slug are optional placement targets, but category and auth_token receive no semantic explanation at all.

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

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

States a specific verb and resource ('Publie un nouvel actfile'), qualifies the content type (Markdown), and the word 'nouvel' distinguishes it from sibling mcp_update_actfile and mcp_comment_actfile without opening any schema.

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

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

The description implies context by noting the actfile can optionally be placed in a community/channel, but it never states when to choose this tool over mcp_update_actfile or mcp_comment_actfile, nor any prerequisites. Usage is inferable but not explicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses one side effect (the creator becomes admin), but says nothing about auth requirements, slug uniqueness/conflict behavior, privacy defaults, or what happens on failure.

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 the core action front-loaded and no filler. It is concise rather than padded, though the terseness reflects under-specification rather than deliberate economy.

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 create mutation with no annotations, no output schema, and six undocumented parameters, one sentence is far too thin. It covers the action and one side effect but omits parameter guidance, permissions, and error/conflict 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?

Six parameters with 0% schema description coverage, and the description adds no meaning for any of them (slug format, name constraints, category, is_private, description, auth_token). With the schema silent and the description silent, an agent cannot know the semantics of the required inputs.

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

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

States a specific verb and resource ('Crée une nouvelle communauté') and adds the creator-becomes-admin consequence, which distinguishes it from the read/update/delete/join community siblings. It does not name those siblings explicitly, but the create semantics are 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?

No guidance on when to use this versus join_community, update_community, or the other community tools, and no prerequisites stated. The agent must infer usage entirely from the verb.

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, yet it only discloses the ownership constraint. For a destructive operation it says nothing about irreversibility, permission failures, or what happens to dependent data such as comments and likes.

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 operation and scope front-loaded and no filler. It is efficient, though arguably under-specified rather than truly concise.

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, two-parameter tool with no annotations, no output schema and 0% parameter coverage, the description omits confirmation behavior, error cases and return shape. It is not sufficient on its own for an agent to invoke this safely.

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

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

Schema description coverage is 0% and the description does not compensate: it never explains the format or source of actfile_id or auth_token. The only parameter-adjacent hint is that the actfile must belong to the authenticated user, which is a semantic constraint rather than parameter documentation.

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

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

States a specific verb (delete) and resource (actfile) and adds an ownership scope ('appartenant à l'utilisateur authentifié'), which separates it from siblings like mcp_delete_community, mcp_delete_message and mcp_delete_user. It stops short of describing what an actfile is or contrasting with mcp_update_actfile, so it is clear but not fully sibling-differentiating.

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 statement of when to use this versus mcp_update_actfile (modify) or mcp_get_actfile (read), nor any prerequisites or exclusions. Usage is only implied by the verb 'Supprime'.

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 must carry the full behavioral burden. It does disclose one meaningful trait — that the operation is restricted to the community creator — but it omits irreversibility, what happens to members and content, and how auth_token is validated. Partial disclosure only.

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 destructive action front-loaded and no redundant phrasing. It is efficiently structured, though its brevity leaves gaps that a destructive tool would ideally cover.

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, irreversible-style operation with no annotations, no output schema, and 0% parameter documentation, one sentence is insufficient. An agent lacks confirmation of permanence, cascading effects, and auth requirements needed to call this safely.

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

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

Schema description coverage is 0%, so the description must compensate. It identifies the target entity (the community) but says nothing about community_id format or the required auth_token, leaving the second parameter entirely 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 ("Supprime une communauté") plus a scope qualifier ("créateur uniquement"). It clearly differentiates the community resource from sibling delete tools (mcp_delete_actfile, mcp_delete_message, mcp_delete_user), though it does not explicitly contrast with mcp_leave_community.

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 parenthetical "créateur uniquement" implies who may invoke it, which is a usage precondition. However, there is no guidance on when to delete versus leave a community, and no statement of prerequisites or consequences that would direct an agent between 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies an ownership restriction (only messages sent by the authenticated user), but says nothing about whether deletion is permanent or reversible, whether other participants are affected, required permissions, or error behavior 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?

A single tight sentence with the core action and scope front-loaded and zero filler. It is efficient, though its brevity is also a symptom of under-specification rather than deliberate economy.

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 mutation tool with no annotations, no output schema, and 0% parameter coverage, the description is too thin. It omits confirmation semantics, permission requirements, and return/error behavior that an agent would need before invoking a delete.

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%: neither auth_token nor message_id is documented in the schema. The description only hints that auth_token identifies the authenticated user and message_id the target message, adding marginal semantic value without explaining formats, tokens, or 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?

States a specific verb (Supprime) and resource (un message) plus a scope constraint (envoyé par l'utilisateur authentifié), which lets an agent distinguish it from mcp_send_message. It stops short of naming a sibling or clarifying the relationship to other delete tools like mcp_delete_user or mcp_delete_community.

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, no mention of prerequisites, and no indication of what happens on failure or when the message id is invalid. The ownership constraint is the only implicit usage hint.

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 state that deletion is permanent ('définitivement'), which is crucial behavioral context. However, it omits other important details: authentication requirements (auth_token is required but not described), irreversibility warnings beyond 'permanent', and whether any cleanup or cascade occurs. The confirm parameter's role is mentioned but not elaborated.

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 core action and a critical requirement. No unnecessary words; every sentence adds value.

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

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

For a destructive operation with no annotations and no output schema, the description should be richer. It covers the permanence and the confirm flag but omits authentication context (auth_token is required but unexplained) and any consequences like data loss or account recovery. It is minimally adequate but leaves gaps for an agent to infer correct 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 mentions confirm=true, which helps clarify the intent of the 'confirm' parameter (a safety gate), but gives no guidance on auth_token or the exact effect of confirm. The baseline for 0% coverage is low, and the description only partially compensates by naming one parameter without full 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 and resource: 'Supprime définitivement le compte de l'utilisateur authentifié' (Permanently deletes the authenticated user's account). This clearly distinguishes it from siblings like mcp_delete_actfile or mcp_delete_community, and the scope is 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?

Mentions that confirm=true is required, which implicitly tells the agent when it can be invoked. However, it does not explain when to use this tool versus alternatives (e.g., account deactivation is not an option in siblings, but no context is given). The requirement is a condition rather than full usage guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states it retrieves an actfile with author info but doesn't disclose whether it's read-only, whether it errors on missing IDs, whether it requires authentication, or what the return structure looks like. For a read operation with zero annotation coverage, this is thin.

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 sentence that is front-loaded with the action and resource. No wasted words, though it could include a bit more context without becoming verbose.

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

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

With no annotations, no output schema, and 0% parameter description coverage, the description is insufficient. It should explain read-only nature, error behavior, and what 'infos de son auteur' entails. The lack of a return schema makes the author-info mention helpful but incomplete.

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

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

Schema description coverage is 0% and there is one parameter ('actfile_id'). The description says 'par id', which confirms the parameter is an identifier, but adds no format or type details beyond the schema. With low coverage, the description should compensate more, but it's minimally acceptable.

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?

Clear verb ('Récupère') and resource ('actfile') with an explicit scope ('par id'). Distinguishes itself from list_actfiles and create/delete siblings, though it doesn't name alternatives explicitly. The description also mentions returning author info, a useful addition.

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

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

No guidance on when to use this tool versus alternatives like list_actfiles or get_community. There's no statement of prerequisites or context for retrieval. The agent must infer that this is for fetching a single actfile by its ID.

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 does not state whether the operation is read-only (implied by "Récupère," but not declared), whether missing IDs raise errors vs return null, or what authentication is required. Behavior beyond the shallow verb is undisclosed.

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 with no filler. Concise and front-loaded, though extremely short given the surrounding ambiguity.

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 lookup tool with zero annotation coverage, 0% parameter description, and no output schema, the description is too thin. It should at least clarify the read-only nature, the return shape or error behavior, and id/slug precedence.

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 only says lookup can be by "id ou par slug," which barely restates the parameter names. It does not clarify whether both parameters can be passed simultaneously, precedence rules, or expected formats.

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 verb and resource ("Récupère une communauté" - retrieves a community) and adds lookup keys (id or slug). It is clear what the tool does, but it offers no differentiation from the sibling mcp_list_communities or mcp_get_user, which an agent would need to disambiguate retrieval-by-identifier vs listing.

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

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

No guidance on when to use this tool versus mcp_list_communities (which lists all) or other get_* tools. The reader must infer usage entirely from the name; there are no exclusions, prerequisites, or alternatives named.

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

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

No annotations are provided, so the description carries the disclosure burden. It states the tool reflects the authenticated user's own subscription, which implies auth scoping, and 'le cas échéant' discloses it may return an empty/absent result. However, it does not address what happens if no subscription exists or the response shape. Adequate but not rich.

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

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

A single efficient sentence that front-loads the resource and scoping. Nothing to trim.

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 getter with no annotations and no output schema, the description covers the core intent and scope, but leaves open what a null result means and how to authenticate. Minimum viable.

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 and schema description coverage is 0%, so the description should compensate. It implies authentication by referring to 'l'utilisateur authentifié', which indirectly explains the auth_token requirement, but adds no format or acquisition details for the token.

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 active Iddet Plus subscription for the authenticated user. It is distinguishable from siblings like mcp_list_subscriptions (plural listing) and mcp_cancel_subscription (mutation), though the distinction is implicit rather than spelled out.

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

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

No guidance on when to use this tool versus mcp_list_subscriptions or mcp_grant_subscription. The 'le cas échéant' (if any) hints it may return nothing, but there is no explicit when/when-not context.

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

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

No annotations are provided, so the description carries the burden, and it manages the useful disclosure that only the 'profil public' is returned rather than private fields. It stops there, saying nothing about auth requirements, behavior when both or neither identifier is supplied, or error handling for missing users.

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; every element (verb, resource, both lookup keys) 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 annotations, no output schema, and 0% parameter coverage, the description is too thin for a tool with two optional identifiers. It neither documents the returned profile shape nor resolves which parameter wins, so an agent still has to guess on core invocation decisions.

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 both parameters are nullable with no required marker, so the schema gives the agent nothing. The description names the two lookup keys ('par id ou par username') but adds no format, precedence, or behavior when both/neither are passed, leaving the critical ambiguity unresolved.

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 (Récupère) and resource (profil public d'un utilisateur) with both lookup keys named, so the agent knows exactly what it returns. It doesn't explicitly contrast itself with siblings like mcp_search_users or mcp_update_user, but the read/retrieve framing is unmistakable.

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

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

No when-to-use guidance, no exclusions, and no mention of the obvious alternative mcp_search_users when the id/username is unknown. Usage is only implied by the verb.

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 carry full behavioral burden. It discloses admin-restriction and out-of-band grant semantics. But it doesn't state whether grant is idempotent, what happens if the user already has a subscription, the default value effect, or side effects on billing. These gaps are notable for a mutation 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?

Two well-structured sentences with the admin/scope constraints front-loaded. No padding.

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

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

No annotations, no output schema, 0% schema coverage, 3 parameters. The description covers the purpose and admin scope but leaves key behavioural and parameter details unspecified. For a privileged mutation tool, this is incomplete.

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

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

Schema description coverage is 0%, and the description provides no parameter guidance. The 'days' parameter with a default of 30 is never explained, 'auth_token' is undocumented, and 'target_user_id' is only implied by the verb. With three parameters at 0% coverage, the description fails to compensate.

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 (accorde manuellement), specific resource (abonnement Iddet Plus), and explicit scope exclusion (hors flux de paiement Chariow). Distinguishes from siblings like mcp_create_actfile, mcp_register, mcp_cancel_subscription, which all manipulate other resources or state.

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?

Clarifies when to use: manual grant outside the Chariow payment flow. Explicitly restricts to admins via MCP_ADMIN_USERNAMES. Doesn't say when to prefer alternatives, but sibling-tool name and scope make the boundary clear.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state whether auth is required (though the schema shows auth_token), whether joining is idempotent, whether permissions are needed, or what happens on success/failure.

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?

It is extremely short (three words), which is concise but under-specified. There is no front-loaded detail because there is almost no content at all.

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 zero parameter description coverage, the description is inadequate. It should at minimum state that an auth token and community ID are required and what joining entails.

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 schema provides no parameter meaning. The description does not explain auth_token or community_id beyond their names, leaving the agent to infer their 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 verb and resource ('Rejoint une communauté' = joins a community), so the purpose is identifiable. But there is no differentiation from siblings like mcp_leave_community, mcp_create_community, or mcp_get_community beyond the obvious join action.

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

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

No guidance on when to use this vs alternatives. It does not mention that the agent must already have an auth token, nor contrast with mcp_leave_community or mcp_get_community.

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 of behavioral disclosure. 'Quitte une communauté' implies a membership mutation but does not state whether it requires specific permissions, whether it is reversible, what happens to the user's data or posts, or whether it affects the community for other users. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single short sentence, which is concise but also under-specified for a mutation tool with two required parameters. It is front-loaded but does not earn its place by conveying useful operational detail.

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

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

The tool has no annotations, no output schema, and 0% schema description coverage for its two required parameters. The description fails to compensate for these gaps by omitting any behavioral, usage, or parameter 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 description coverage is 0%, and neither parameter (auth_token, community_id) is documented in the description. The description adds no meaning about parameter format, required values, or constraints, leaving the agent without guidance on what to supply.

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 ('Quitte' = leave) and resource ('une communauté'), so the action is unambiguous. It does not differentiate itself from the closest sibling mcp_delete_community or the reverse operation mcp_join_community, but the core purpose 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?

There is no guidance on when to use this tool versus alternatives such as mcp_delete_community or mcp_join_community. The description gives no prerequisites or context beyond the basic action, leaving the agent to infer usage.

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

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

With no annotations, the description carries the full burden, but it does disclose one genuinely useful trait: idempotency (no double-count if already liked). It omits auth requirements, error behavior for a nonexistent actfile, and any side effects beyond the counter.

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 the core action first and the idempotency qualifier in parentheses; no filler. It is terse to the point of under-specification, 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?

This is a mutation tool with no annotations, no output schema, and 0% parameter coverage, yet the description covers only the action and idempotency. An agent still lacks auth expectations, failure modes, and what the call returns or changes.

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 two required parameters, and the description says nothing about actfile_id or auth_token. It neither defines the id format nor explains how the token is obtained, 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?

States a specific verb and resource ('Like un actfile'), which cleanly separates it from the sibling mcp_unlike_actfile without needing the schema. It is clear but never explicitly names or contrasts the sibling, 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?

There is no when-to-use / when-not-to-use guidance and no mention of prerequisites such as needing a valid auth_token or an existing actfile. The idempotency note is a behavioral trait, not routing guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about pagination (despite a limit parameter), ordering, permissions, or result size. Only the read-only nature is weakly implied by "Liste".

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?

It is a single, front-loaded sentence with no filler, which is efficient. However, that brevity comes at the cost of substance rather than through tight editing.

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?

An output schema exists, so return values need not be explained, but the absence of annotations combined with 0% parameter documentation leaves the agent with too little to invoke this correctly and predictably.

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 the description documents neither parameter: it never defines actfile_id or explains what limit=50 controls. A single short sentence does not 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 names a specific verb ("Liste") and resource ("les commentaires d'un actfile"), so an agent knows this reads comments for one actfile. It is clear but offers no differentiation from neighbours such as mcp_comment_actfile or mcp_get_actfile.

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

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

There is no when-to-use guidance, no mention of when this is preferable to mcp_get_actfile or mcp_list_actfiles, and no stated prerequisites. The agent must infer usage entirely from the 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?

No annotations are provided, so the description carries the full burden. 'Récents' hints at default ordering, but the description says nothing about pagination behavior for limit/offset, auth requirements, or that this is a safe read-only listing. That is a substantial gap for a list tool with no 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 efficient sentence with the action and filters front-loaded and no wasted words. It is concise, though partly because it under-specifies rather than because it is optimally scoped.

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

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

The output schema covers return values, but with 0% parameter coverage, no annotations, and 4 parameters, the description is too thin. It does not tell an agent enough about pagination, filtering semantics, or read-only safety to invoke the tool confidently.

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% with 4 parameters. The description adds meaning for only two of them (community_id and category) via the filter phrase, and gives no syntax or format detail. limit and offset remain entirely 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?

The description states a specific verb (list/feed) and resource (actfiles) plus a scope qualifier (récents) and filter capability, which lets an agent distinguish it from get_actfile. However, 'actfile' is unexplained jargon and 'fil' is ambiguous (feed vs. thread), and no sibling is named.

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 guidance or alternative routing. The filter phrase 'filtrable par communauté ou catégorie' only implies a use case; it never says when to prefer this over get_actfile, mcp_list_actfile_comments, or a search tool.

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

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

No annotations are provided, so the description must disclose behavior itself. It implies a read/list operation, but does not state whether authentication is required, whether pagination is supported, or how public/private visibility affects results. It adds little beyond the obvious.

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

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

The description is a single short sentence, which is front-loaded but severely under-specified for a tool with four parameters and no annotations. This is not concise; it is incomplete, lacking the detail needed to call the tool correctly.

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?

An output schema exists, so return values need not be explained. However, with no annotations and 0% schema description coverage, the description should explain parameter usage and basic behavior. It does not, leaving significant gaps for an agent to 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 schema has four parameters (limit, query, offset, category) with 0% description coverage, and the description does not mention any of them. The word 'recherche' hints at a query parameter, but there are no details about filtering, pagination, or category usage, leaving the schema names to carry the full, undocumented burden.

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

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

The description states a clear resource (public communities) and two verbs (list/search), so the agent knows the general operation. It does not distinguish this tool from siblings like mcp_get_community or mcp_search_users, but the scope is still discernible.

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 mcp_get_community for a single community or mcp_search_users for user searches. The agent receives no exclusions, prerequisites, or context clues beyond the bare function.

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 must carry the behavioral burden. It discloses the return shape (names plus OpenGraph icons) and the account-scoping behavior, which is useful. However, it says nothing about read-only nature, permission/auth requirements, or result size/limits beyond what the schema implies.

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 that front-loads the action and resource, with the analogy trailing as supporting color. 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?

An output schema exists, so return values need not be re-explained, and the description correctly supplements it with the human-readable field list. For a simple read-only list tool this is nearly sufficient; only auth/permission context 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?

One parameter with 0% schema description coverage, so the description must compensate. "connectées à ce compte" weakly implies auth_token selects the account, but no meaning, format, or sourcing for auth_token is given. The parameter is self-evident by name, keeping this at the baseline rather than below 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 specific verb ("Liste") and resource ("apps clientes MCP connectées à ce compte"), plus the returned fields (nom + icône OpenGraph). The GitHub/Shopify analogy makes the concept immediately recognizable. It doesn't explicitly name or contrast a sibling (e.g. mcp_remove_connected_app), 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?

The analogy to GitHub 'Authorized OAuth Apps' implies the browsing/auditing use case, but there is no explicit when-to-use, prerequisite, or alternative-tool guidance. Usage is inferred rather than stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not state whether this is a read-only operation, whether it requires specific permissions beyond authentication, or how pagination works despite having limit/offset parameters. It also does not mention that the auth_token and other_user_id are required, though that is evident from the schema.

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

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

The description is a single, efficient sentence that is front-loaded with the core action. It avoids unnecessary detail, though it could benefit from clarifying the distinction from the plural sibling 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?

Given that there are four parameters (two required, two undocumented), no annotations, and an output schema exists, the description is incomplete. It does not cover pagination behavior, authentication requirements beyond the parameter existence, or the format of the returned messages. It should provide more context 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 0%, so the description must compensate. It mentions 'utilisateur authentifié' and 'un autre utilisateur', which maps to auth_token and other_user_id, but it does not explain the limit and offset parameters at all. With four parameters and no schema descriptions, this leaves significant gaps.

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

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

The description states a clear verb (Liste) and resource (messages exchanged between authenticated user and another user), which is more specific than the name alone. However, it does not distinguish itself from the sibling tool 'mcp_list_conversations' (plural), which likely lists conversation threads rather than messages. This ambiguity reduces clarity.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not explain when to choose listing messages over listing conversations, nor does it mention prerequisites like authentication. The description only states what it does, not when 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?

With no annotations, the description carries the full behavioral burden. It does disclose one useful trait — that results are aggregated to one row per contact showing the last message — but says nothing about ordering, pagination, limits, or what authentication requires beyond "utilisateur authentifié".

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 redundant filler. It is efficient, though so short that the brevity edges toward under-specification rather than crisp conciseness.

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?

An output schema exists, so return-value detail is not required. Still, for a listing tool with no annotations and an undocumented required auth parameter, the description omits pagination/ordering behavior and its relationship to the singular list_conversation sibling.

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 the sole required parameter, auth_token, is never described in the text. The phrase "utilisateur authentifié" only vaguely gestures at it, adding little meaning 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 ("Liste") and resource ("conversations"), scopes it to the authenticated user, and clarifies the payload shape with "dernier message par contact". It is distinguishable from the singular sibling mcp_list_conversation, though it never names that 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 statement of when to use this tool versus alternatives such as mcp_list_conversation or mcp_list_actfile_comments. Usage is only weakly implied by the verb "Liste"; no prerequisites or exclusions are 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?

With no annotations, the description carries the full behavioral burden. It adds important permission/visibility behavior, including the MCP_ADMIN_USERNAMES admin exception, but it does not confirm read-only status or explain limit/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 the core purpose front-loaded and no wasted words. The permission clarification follows naturally and directly.

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?

An output schema exists, so return values need not be described. The description adequately covers access control, but for a list tool with undocumented parameters it does not explain pagination limits or the required auth_token, leaving some invocation context incomplete.

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

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

Schema description coverage is 0% for all three parameters. The description partially clarifies user_id semantics by stating that admins may consult anyone's subscriptions, but it does not explain limit or auth_token, leaving most parameter meaning 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 operation on a specific resource: retrieving subscription history ('Historique des abonnements'). It is understandable without opening the schema, though it does not explicitly differentiate itself from sibling tools such as mcp_get_subscription_status or mcp_grant_subscription.

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

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

It provides useful access-context guidance: regular users only see their own subscriptions, while MCP admins can view anyone's. However, it does not say when to use this tool instead of related alternatives like mcp_get_subscription_status or mcp_grant_subscription.

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. It explains the key behavioral trait: the returned JWT should be reused in other tools. It also describes side effects when client_url is provided (registering in connected apps, OpenGraph fetching, silent ignoring if already registered). However, it doesn't cover authentication failure behavior, token expiration, security considerations (e.g., sensitive nature of passwords), or whether this is a read-only or mutating operation.

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

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

The description is reasonably concise across three sentences, front-loading the main purpose and then covering the optional parameter behavior. It could be slightly more structured, but it efficiently conveys the key information without redundancy.

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

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

Given no annotations, no output schema, and 0% schema description coverage, the description should provide more behavioral context. It covers the main purpose and the client_url side effect well, but omits important details such as error handling, token lifetime, and security expectations. For an authentication tool with no structured metadata, this is adequate but incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies the purpose of client_url (the URL of the connecting app, e.g., https://claude.ai, which is registered in connected apps with name/icon via OpenGraph, and ignored if already registered). It doesn't describe username and password beyond their obvious meaning, nor does it mention any format constraints. It adds some meaning for the optional parameter but leaves required parameters implicit.

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 in French: it authenticates a user and returns a JWT access_token for use in other MCP tools. This is distinct from the sibling mcp_register (presumably account creation) and clearly identifies this tool as the login/authentication entry point.

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

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

The description implies this tool is used to obtain credentials for subsequent tool calls by mentioning the auth_token should be reused in other MCP tools. However, it doesn't explicitly state when to use this vs mcp_register or what happens if authentication fails. The context of authentication is clear but not fully elaborated.

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 of behavioral disclosure. It does disclose key returns (created user and access_token) and the side effect of registering a client app when `client_url` is supplied, including that app name/icon are fetched via OpenGraph. However, it omits critical behavioral details for a mutation tool: whether this requires authentication, what happens on duplicate username/email, password constraints, and whether registration is reversible. This is a moderate but incomplete disclosure.

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

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

The description is two sentences, front-loaded with the primary action and return values, then a secondary conditional behavior. It is efficient and avoids repetition. Slightly more could be trimmed, but it earns its place by covering both the core action and the optional client registration.

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, no output schema, and 0% schema description coverage, the description is only partially complete. It explains the return values and one optional parameter's behavior, but does not cover authentication requirements, error cases, or constraints on required fields (`username`, `password`). An agent could invoke it but would lack context for robust use.

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

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

Schema description coverage is 0%, so the schema itself provides only parameter names and types. The description adds meaning for `client_url` by explaining its purpose (registering the client app and fetching OpenGraph metadata) but says nothing about `username`, `password`, or `email` — no formats, constraints, or validation rules. It partially compensates for the low schema coverage but leaves three of four parameters undocumented in natural language.

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 nouveau compte utilisateur' (creates a new user account) — and adds a secondary behavior (returns the user plus an access_token, and optionally registers a client app). This distinguishes it from sibling tools like mcp_login (which presumably authenticates an existing user) and mcp_create_* tools for other resources. It is clear but does not explicitly differentiate itself from mcp_login or mcp_create_community.

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

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

The description implies when to use it (to create a new account) and explains an optional behavior when `client_url` is provided, but it does not explicitly state when to use this tool vs alternatives such as mcp_login or mcp_update_user. No exclusions or prerequisites (e.g., 'use this only if you don't already have an account') are given, leaving the agent to infer usage context.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says the app is revoked/deleted but does not state irreversibility, whether the end user's access is cut off immediately, required permissions, or whether the operation can be undone — critical details for a destructive action.

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

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

A single short sentence with the verb and resource front-loaded and no filler. It is efficiently sized, though the sparse structure also reflects the missing detail rather than disciplined brevity.

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, no output schema, and 0% parameter coverage, the description is too thin. An agent lacks the safety context (irreversibility, prerequisites) and parameter sourcing needed to invoke it confidently.

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 the description adds no parameter detail. The names auth_token and app_id are suggestive, but nothing clarifies which app_id format is expected, whether app_id comes from mcp_list_connected_apps, or what auth_token should contain, leaving the description unable to 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 description names a specific verb (revoke/delete) and resource (MCP client app connected to this account), so an agent knows exactly what it does. It does not, however, reference the sibling mcp_list_connected_apps that would supply the app_id, so the operation isn't distinguished from its 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 when-to-use guidance, no prerequisite (e.g. that the app must already be connected), and no pointer to mcp_list_connected_apps for obtaining the app_id. The agent must infer all usage context from the tool name alone.

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, so the description carries full burden. It discloses the LIKE matching behavior, which is useful, but says nothing about whether it's read-only, rate limits, output shape, or pagination of the multi-result search.

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 with no filler; front-loads the action and resource. Could be a touch more informative without 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 output schema present, return values needn't be explained. But with no annotations, no param coverage, and a sibling that overlaps, the description is thin on the discrimination and behavioral context an agent needs.

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%, which is quite low. The description clarifies the 'query' parameter semantics (matches against username via LIKE), compensating partially for the undocumented 'query'. But 'limit' is undocumented in both schema and description. A 3 reflects that one parameter is explained while the other is left bare.

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?

Clear verb+resource: search users by username, with LIKE matching noted. But it doesn't distinguish itself from sibling mcp_get_user, which also retrieves a user, leaving the agent to infer the difference.

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 and no mention of the alternative mcp_get_user. The 'LIKE' hint is a small behavioral clue but not usage 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 no annotations, the description carries the full behavioral burden but only says the message is private. It does not disclose auth requirements (despite a required auth_token), rate limits, whether the message is editable/deletable afterwards, or that a type parameter exists. Only marginal behavioral context is added.

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

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

A single front-loaded sentence with no filler; the verb and object lead. It is appropriately sized for what it attempts, though it is thin rather than 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 4-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, one sentence is not enough. An agent lacks the auth, content-type, and return-value context needed to call it confidently.

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 4 parameters. The description implies receiver_id ("à un autre utilisateur") and content ("message") but says nothing about auth_token or the type parameter that defaults to "text", leaving half the surface 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 ("Envoie un message privé") plus the target ("à un autre utilisateur"), which separates it from mcp_delete_message and mcp_list_conversation by action. It is clear but does not explicitly name a sibling or scope the operation further.

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, no prerequisites, and no mention of when-not to use it (e.g., replying within an existing conversation). The agent must infer usage entirely from the verb.

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 confirms a removal/mutation but says nothing about idempotency when no like exists, permission or auth requirements, error behavior, or reversibility, leaving key traits undisclosed for a state-changing 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 short sentence that is front-loaded and contains no filler. Brevity is appropriate here, though the terseness borders on under-specification rather than tight economy.

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 two fully undocumented required parameters (including an auth token), one sentence is not enough. An agent lacks the auth expectations and edge-case behavior needed to invoke this reliably.

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 neither parameter is documented. The description hints that actfile_id targets an actfile, but gives no format or identity details, and says nothing at all about the required auth_token, so it fails to 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 states a specific verb ("Retire" / removes) and resource ("un like sur un actfile"), so the action is unambiguous. It does not explicitly differentiate itself from siblings or mention mcp_like_actfile as its inverse, but the name-plus-description pairing makes the counterpart relationship obvious.

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

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

There is no when-to-use, when-not-to-use, prerequisite, or alternative guidance. The agent must infer that this is the undo of mcp_like_actfile and that a like must already exist, with nothing in the text confirming either condition.

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 largely fails it. The ownership/auth constraint is useful ('appartenant à l'utilisateur authentifié'), but nothing is said about partial-update semantics (content and category default to null), reversibility, permission failures, or what happens to fields omitted from the call. For a mutation tool with zero annotation coverage this is a significant 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?

A single, front-loaded sentence with no filler or redundancy. It is efficiently sized, though the brevity is a symptom of under-specification rather than disciplined concision.

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 mutation tool with no annotations, no output schema, and 0% parameter description coverage needs far more than one sentence. The description also does not match the surrounding English tool naming convention, which may add friction. An agent cannot determine which fields are updatable or what a successful call returns.

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 4 parameters, so the description must compensate and does not. It never mentions content, category, actfile_id, or auth_token, leaving the two optional mutable fields and their null-default behavior completely unexplained. Only the implicit ownership of the actfile is conveyed.

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 ('Met à jour un actfile') plus a scoping constraint ('appartenant à l'utilisateur authentifié'). This distinguishes it from update_community and update_user by resource, though it never says which actfile fields are modifiable. Clear purpose, but thin on the what-changes detail that separates it from get_actfile/create_actfile in an agent's mind.

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 statement of when to use this tool versus alternatives. It does not point to get_actfile for reads, delete_actfile for removal, or create_actfile for new records, and gives no preconditions beyond the ownership hint. The agent must infer usage entirely from the 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 entire behavioral burden, and it only discloses the admin/moderator permission requirement. It says nothing about whether the update is partial or full-replacement (all optional fields default to null), whether existing values are overwritten, reversibility, or the response shape, which is a substantial gap 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?

A single front-loaded sentence with zero filler, so it is efficient. For a 7-parameter mutation tool it borders on under-specification rather than being genuinely well-structured, but it wastes nothing.

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 mutation tool with no annotations, no output schema, and 7 parameters at 0% coverage needs more than one sentence. The permission note helps, but update semantics, partial-vs-full behavior, and field meaning are all absent, so an agent cannot call it confidently without inspecting 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?

There are 7 parameters with 0% schema description coverage, so the schema contributes almost no semantics. The description compensates only for the action itself and mentions none of the updatable fields (name, category, icon_url, banner_url, description) or the required auth_token/community_id, leaving parameter meaning essentially 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 ('Met à jour une communauté'), which distinguishes it from sibling mutations like mcp_create_community and mcp_delete_community. It does not, however, indicate which attributes (name, category, icon, banner, description) can be updated, so the scope of the update is left to the schema.

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

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

The parenthetical '(admin/modérateur uniquement)' supplies a real access precondition that guides who can invoke it. There is no explicit routing against alternatives such as create vs update, nor any statement of when an update is preferable, so guidance is implied rather than complete.

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 partial-update semantics ('champs fournis uniquement'), which is genuinely useful, but it omits permission requirements, whether changes are reversible, and treatment of omitted/null 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?

A single short sentence with no filler and the key constraint (only provided fields) in parentheses. Efficient, though it is too brief to be complete.

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 mutation tool with no annotations, no output schema, and 0% parameter coverage – the description should do substantially more work than one sentence about partial updates. Critical context for 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% across 5 parameters, so the description must compensate. It only conveys the partial-update rule and never names or explains bio, email, avatar_url, phone_number, or the required auth_token, leaving field-level meaning to the 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 (met à jour) and resource (profil de l'utilisateur authentifié), which distinguishes it from sibling update tools like mcp_update_actfile and mcp_update_community. It does not, however, differentiate from mcp_get_user or mcp_delete_user beyond the verb.

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

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

No guidance on when to use this versus alternatives (e.g. mcp_register for creation, mcp_get_user for reads) and no prerequisites such as the auth requirement for editing one's own profile. The agent must infer usage entirely.

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