引力AI · Yinli AI

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

Adds meaningful context beyond annotations: 'This never sends a message' sets a clear side-effect boundary, and the authorization mode rule discloses the consent model. Annotations already cover safety (readOnly=false, idempotent=true, destructive=false), so the description appropriately augments rather than restates them.

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

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

Three tight sentences, front-loaded with the action, then the consent rule, then the side-effect boundary. Every sentence earns its place with no redundancy.

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

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

Output schema exists so return values need not be explained, and annotations cover the safety profile. The description supplies the consent logic and side-effect boundary an agent needs to call it correctly. Only the id/digest provenance remains implicit, a minor gap.

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

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

Schema description coverage is 0%, so the description carries the burden. It explains authorizationMode's two values and the explicit-approval requirement, and implies confirmationId/Digest come 'from a one-time preview'. However, confirmed and the digest's role are left to the schema's names, so the coverage gap is only partially closed.

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 ('Open the exact empty direct chat'), scoped to 'from a one-time preview' tied to the prepare step. It distinguishes the confirm step from prepare implicitly, though it never names the sibling fitmeet_chat_prepare by name. Clear and specific 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?

Gives explicit conditional guidance: use AUTOMATIC only when the prepare result reports standing authorization, otherwise require explicit user approval. This is real when/when-not logic tied to an observable precondition. No named alternative tool, but the decision rule is clear.

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

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

Annotations mark it idempotent and non-destructive but readOnlyHint=false; the description resolves that ambiguity by stating 'Sends no message' and describing the authorization-dependent confirmation path. It adds real behavioral context beyond the annotation set, though it does not mention rate limits or what the prepared chat state contains.

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 action and its key non-effect front-loaded, followed by the conditional flow. 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?

An output schema exists so return values need not be explained, and the description covers the critical prepare/confirm branching plus the no-message guarantee. The main gap is that the three required ID parameters are left semantically unexplained.

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

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

Schema description coverage is 0% and all three parameters are opaque ID strings documented only by regex patterns. The description's phrase 'from a current search result' loosely ties queryId/candidatePresentationId to a search origin, but it never explains requestId or the ID formats, leaving most parameter meaning unstated.

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

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

States a specific verb and resource ('Prepare an empty direct chat with a candidate from a current search result') and immediately clarifies the non-action nature ('Sends no message'). This distinguishes it from fitmeet_chat_confirm and the message_* siblings, which the description references directly.

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 lays out the branch after preparation: confirm directly on AUTOMATIC authorization, otherwise present the person and request confirmation. That gives clear context for the prepare-then-confirm flow, though it never explicitly states when to prefer this tool over a sibling beyond the implied sequencing.

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

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

Annotations are all default/false and convey no safety profile, so the description carries the burden and does well: it discloses non-mutation (不会保存、修改或删除), the retention/window limit, and an important privacy caveat (feedback is the user's own experience, not facts about the other party, nor contact authorization). It omits rate limits and error behavior, hence not a 5.

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

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

A single front-loaded paragraph whose clauses each do work: default mode, filtered mode, privacy framing, non-mutation note. Slightly dense with the privacy caveat, but no filler or repetition.

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

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

An output schema exists, so return formatting needn't be documented. For a 2-optional-parameter getter the description covers both invocation modes, parameter meaning, scope limits, and data-sensitivity context — complete enough to call the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that sourceKind maps to a personal conversation or gathering (matching the enum) and pairs with sourceId to view a specific item, and that both refer to the caller's own data — adding the joint-usage relationship and ownership constraint the schema lacks.

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 (读取/read) and resource (连接反馈/connection feedback), plus concrete scope (last 90 days, max 12) and a second access mode by sourceKind+sourceId. It never names a sibling alternative, but the resource is unique among the fitmeet_* list/get/confirm tools.

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

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

Explicitly tells the agent when each mode applies: no parameters yields recent personal feedback; sourceKind+sourceId yields feedback for a specific session or gathering. It gives clear context but no exclusions or named alternatives for overlapping use cases.

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

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

Annotations already declare the safety profile (destructiveHint=false, openWorldHint=false), so the description's 'Returns no contact coordinates' is a useful privacy/return-scope disclosure beyond the schema. However it omits pagination behavior, ordering, and whether the unread counts are per-conversation totals, leaving real gaps.

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

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

Two short sentences, front-loaded with the core action and followed by the most decision-relevant caveat. No filler or restatement of the title.

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

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

An output schema exists, so return values need not be spelled out, and with zero required parameters the call is simple. Still, the undocumented limit parameter and the absence of any routing guidance against the many sibling list/get tools leave it only minimally complete.

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

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

There is one parameter (limit) with 0% schema description coverage, and the description says nothing about it — no default, no max of 50, no pagination meaning. The description therefore 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?

Specific verb+resource ('List ... direct conversations') with clear scope ('the connected user's own') and an extra payload hint ('unread counts'). It implicitly separates itself from fitmeet_messages_list and fitmeet_groups_list by saying 'direct conversations', but it never names or contrasts with those siblings.

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

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

There is no statement of when to call this versus fitmeet_messages_list, fitmeet_groups_list, or fitmeet_people_search. Usage is only inferable from the noun 'conversations'; 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?

Annotations already declare readOnly=false, idempotent=true, destructive=false, and openWorld=true, so the safety profile is covered. The description adds one genuinely useful behavior beyond that: 'Invitees are not contacted by this operation.' However, it omits the confirmation lifecycle (digest/authorizationMode semantics, expiry) that matters for a mutation in an open-world context.

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

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

Two tight sentences with no filler, and the primary effect is front-loaded ahead of the invitee caveat. Slightly under-sized for a four-parameter confirmation tool, which keeps it from a full 5.

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

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

The output schema means return values need no explanation, but the core gap is the missing prerequisite flow: an agent is not told that a prepare step yields the confirmationId/digest it must pass. With 0% parameter coverage and an open-world mutation, the description leaves too much to inference.

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

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

Schema description coverage is 0% with four parameters, so the description carries the full explanatory burden and does not meet it. It says nothing about confirmationId, confirmationDigest, the confirmationDigest regex, the required confirmed=true constant, or the USER_CONFIRMED vs AUTOMATIC authorizationMode enum. 'Exact approved' only faintly gestures at the confirmation 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 concrete verb+resource pair ('Create the exact approved gathering or group chat and add the owner'), so the material effect is unambiguous. The phrase 'exact approved' implies a prior prepare step, but the description never names the prepare/confirm sibling that produces the confirmationId, so differentiation is left to inference.

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

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

Usage is only implied: 'the exact approved gathering' suggests this runs after an approval step, but the description never says to call fitmeet_group_prepare first, nor does it state when-not-to-use versus fitmeet_group_get or fitmeet_group_join_confirm. An agent must infer the two-step flow from the tool name and required confirmation params.

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

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

The description adds real behavioral context beyond the hints: it declares the negative scope (no member lists, no messages, no mutation execution) and that it hands back a website entry point. However, that read-only framing directly conflicts with readOnlyHint=false, so the agent receives two opposite signals about whether the call can change state; the conflict caps the score despite otherwise useful 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?

Two dense sentences, front-loaded with what is read and followed by scope limits and exclusions; no sentence is filler. The second sentence bundles three distinct ideas (returned entry point, user-confirmed operations, unread data) and the phrase "返回原网站入口" is slightly opaque, which keeps it off a 5.

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

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

An output schema exists, so return values need no prose, and the description correctly spends its words on scope and exclusions instead. With a single clearly named parameter, the remaining gap is the annotation mismatch and the unanswered question of how the caller obtains a groupId.

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 carry the burden, and it adds only an indirect hint: "当前可见的" implies only groups visible to the caller can be fetched (an access/visibility constraint). It says nothing about where groupId comes from or what a lookup failure means; the UUID name is self-explanatory, so this lands at minimum-viable rather than broken.

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

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

The description gives a specific verb and resource ("读取当前可见的组局或群聊信息") and enumerates the returned fields (time, location, registration deadline, completion status), so an agent knows exactly what data comes back. It is clear, but it never contrasts itself with the read siblings (fitmeet_groups_list, fitmeet_conversations_list), leaving the single-group scope to be inferred from the name.

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

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

It states what the tool will NOT do — rescheduling, joining and completing are confirmed by the user on the original website — which is genuine when-not guidance and steers the agent away from expecting mutations here. It stops short of naming which alternative tool to call for adjacent reads, so it is not a full when/when-not/alternatives statement.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, so safety is partly covered; the description earns credit by adding that the operation happens 'once', that mismatched/private groups are rejected, and that no other group action is performed. It goes beyond the annotations with validation and scope behavior, though it doesn't say what gets rejected how (error) or what the result contains.

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 primary action front-loaded and constraints trailing. Every clause carries information; nothing is redundant or padded.

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

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

An output schema exists, so return values needn't be described. But for a 4-parameter mutation with 0% schema coverage, the description omits the essential confirmation mechanism (where confirmationId/digest come from and that prepare precedes this call), leaving a real gap for correct invocation.

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

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

Schema description coverage is 0% across 4 parameters, so the description must carry the load and does not: confirmationId, confirmationDigest, authorizationMode, and the constrained boolean 'confirmed' are never explained. 'The exact approved group' faintly alludes to a prior approval artifact but gives no format, source, or meaning for any parameter.

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

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

States a specific verb+resource+scope: 'Join the exact approved public group once.' The word 'confirm' in the name/title and 'approved' signal this is the confirmation half of a prepare/confirm pair, though it never names the sibling fitmeet_group_join_prepare explicitly, so differentiation is inferred rather than stated.

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?

Provides a when-not condition ('Private or changed groups are rejected') and a scope limitation ('no other group action is performed'), which help an agent avoid misuse. However, it never states the prerequisite that a prior prepare call must supply the confirmation artifacts, nor does it name any alternative tool, so the routing guidance is only implied.

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

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

Annotations cover the safety profile (non-destructive, idempotent), so the bar is lower. The description adds real value beyond them by disclosing that group state and capacity are re-validated before confirmation, warning the agent that the prepare step can go stale.

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 precondition front-loaded and zero filler; each clause earns its place.

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

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

An output schema exists, so return values need not be described, and the description covers eligibility and re-validation. The main gap is the unexplained requestId and the absence of an explicit pointer to the confirming 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% for both parameters. The description implies groupId via 'the group' but never explains requestId (presumably an idempotency/deduplication key) or its format constraints, so it fails 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?

States a specific verb+resource: preparing a join to a public, open group. The qualifier 'returned by group discovery' and the mention of 'confirmation' let an agent place it in the prepare/confirm flow, though it never names the sibling fitmeet_group_join_confirm outright.

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

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

Gives clear context for use ('a currently public, open group returned by group discovery') and implies the follow-up confirmation step. It stops short of explicitly naming the confirm sibling or stating when the group is not eligible, so no exclusions are provided.

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

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

Annotations already declare idempotent=true, destructive=false, and readOnly=false. The description adds genuinely useful non-obvious context: the deferred-effect contract ('no group is created until the exact card is confirmed'), which explains the preview/confirm two-phase flow that annotations cannot express.

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

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

Two short sentences with zero waste, and the core effect constraint is front-loaded in the second sentence. Nothing redundant.

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

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

An output schema exists, so return values need not be described. However, for an 8-parameter mutation with 0% schema documentation, the description omits critical input semantics such as requestId's idempotency role and the capacity/title constraints, leaving the agent under-informed.

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 8 parameters, so the description carries the full burden, yet it only obliquely gestures at two of them ('public or private' -> visibility, 'gathering or group chat' -> kind). Required fields like requestId, title, and capacity limits (2-50) are unexplained anywhere.

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 (prepare) and resource (gathering or group chat), and the second sentence clarifies this is a preview step. However, it does not differentiate itself from nearby siblings like fitmeet_chat_prepare or fitmeet_group_confirm, and the phrase 'gathering or group chat' blurs which sibling owns which resource.

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

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

'No group is created until the exact card is confirmed' implies the confirm step must follow, giving implicit usage context. But it never names the alternative tool (fitmeet_group_confirm) or states when to choose this over fitmeet_chat_prepare, leaving routing to inference.

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

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

Adds substantial context beyond the weak annotations: a hard cap of 40 results, the warning that text matching is not the complete candidate set, and explicit non-actions (will not join, invite, or read group messages). These disclaimers are genuinely useful, though the description's read-only framing sits in mild tension with readOnlyHint=false.

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

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

A single dense, front-loaded passage with no filler; scope, mode switch, result limit, matching caveat, and non-actions are all stated economically.

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 details are rightly omitted, and the description covers scope, limit, matching caveat, and non-actions for a 2-parameter list tool. Only the q parameter's semantics are left under-specified.

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 carry parameter meaning. It explains discover=true well, but the q parameter is only obliquely implied by the 'text matching is not the complete candidate set' caveat, with no statement of what q matches against.

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 (组局、群聊 / 公开组局) and separates two modes: the user's joined/invited groups vs. publicly discoverable ones. It is very clear in isolation, but never names or contrasts with the nearby siblings (e.g. fitmeet_group_get, fitmeet_conversations_list), so it falls short of full sibling differentiation.

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

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

Gives a clear condition for the two modes: default queries the caller's own joined/invited groups, and discover=true switches to searching public, externally-discoverable groups. No when-not-to-use or explicit alternative is named, but the mode-selection context is unambiguous.

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

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

Annotations already declare write (readOnlyHint=false), idempotent, non-destructive and open-world behavior, lowering the bar. The description adds that a one-time preview and candidate authorization are required, which is genuine context, but it does not explain what the confirmation tokens protect or what happens if the preview is stale.

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 action front-loaded and the prerequisite trailing. No waste, though it is terse enough to leave real questions unanswered.

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 no explanation, and the prerequisite is stated. However, for a write tool with four entirely undocumented parameters and an authorization-mode enum, the description is not complete enough 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, and the description never explains confirmationId, confirmationDigest, authorizationMode (the enum), or the const-true 'confirmed' flag. 'The exact approved question' faintly gestures at the digest, but the agent gets no meaning for any parameter from the prose.

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+resource: 'Send the exact approved question to the named candidate' clearly identifies the action and target. It implies the prepare/confirm pairing but never names fitmeet_inquiry_prepare, so sibling differentiation is left to inference.

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

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

'Requires the one-time preview and current candidate authorization' gives a clear precondition for calling this tool, which effectively routes the agent through the prepare step first. No explicit when-not-to-use guidance or named alternative, so it stops short of a 5.

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

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

Annotations already cover safety (readOnlyHint=false, destructiveHint=false, idempotentHint=true), so the bar is lower, and the description adds real value on top: this is a two-phase operation where nothing is transmitted until confirmation, and the candidate is re-validated at confirmation time (state may have changed). It stops short of explaining expiry, error, or retry 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 tight sentences, front-loaded with the action and resource, then the behavioral caveat. No padding or restatement of the title.

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

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

An output schema exists, so return values need not be described, and the workflow framing is adequate for a prepare/preview step. However, with four fully required, undescribed ID-and-text parameters, the definition leaves an agent guessing about what goes into each field, which is a meaningful gap for a staged write operation.

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 four required parameters, so the description carries the full explanatory burden and largely fails. It only gestures at 'text' ('one exact question') and only implicitly hints at queryId/candidatePresentationId via 'the current people search'; requestId is never addressed, and no format or provenance guidance is given for the opaque ID patterns.

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 (prepare) and resource (one exact question) and scopes the input to 'a candidate returned by the current people search', which links it to fitmeet_people_search and separates it from fitmeet_inquiry_confirm. It is clear but never names a sibling explicitly, so it falls just short of full differentiation.

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

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

The description establishes ordering context: it must be fed a candidate from the current people search, and nothing is actually sent until a separate confirmation. That tells an agent when to reach for this tool versus the confirm step, though it does not state any exclusions or failure conditions.

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

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

Annotations already declare this is a non-read-only, idempotent, non-destructive, open-world write. The description adds meaningful context beyond that: the authorization gating and the one-time preview constraint. It does not describe idempotency behavior or what an already-consumed preview yields, which is a modest remaining gap.

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

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

Two front-loaded sentences with zero waste; the core action comes first and the conditional usage rule follows. Every clause earns its place.

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

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

An output schema exists, so return values need not be explained, and annotations cover the safety profile. The description supplies the authorization prerequisites an agent needs before calling. It is essentially complete, minus any note on what happens when the one-time preview has already been consumed.

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

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

Schema description coverage is 0%, so the description carries the full burden. It conveys the meaning of authorizationMode (AUTOMATIC vs explicit approval) but says nothing about confirmationId, confirmationDigest, or confirmed, whose roles must be inferred from naming. Partial compensation, so a minimum-viable 3.

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 ("Send the exact private message") plus the mechanism ("from a one-time preview"), so it is clearly the confirmation step of the prepare→confirm flow. It does not name the sibling fitmeet_message_prepare explicitly, but the preview reference distinguishes it from chat_confirm and publication_confirm.

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

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

Gives explicit when-to-use conditions: AUTOMATIC is permitted only when the prepare result reports standing authorization, otherwise only after the user explicitly approves the named recipient and full text. This maps directly onto the authorizationMode enum and leaves nothing to inference.

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

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

Adds real behavioral context beyond the annotations: 'Sends nothing' clarifies this is a non-delivering preview, and the description discloses an authorization-status result that drives downstream behavior. Annotations already cover idempotency and non-destructiveness, so this extra flow information is a meaningful increment.

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

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

Three short sentences with no filler, front-loaded with the core purpose and the critical 'Sends nothing' qualifier before the conditional flow. Efficient and easy to scan.

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 explanation is unnecessary, and the description adequately covers the prepare/confirm lifecycle and the authorization branching. The main remaining gap is the absence of any parameter-level detail, particularly for requestId.

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 supplies essentially no per-parameter meaning. 'Exact private message' weakly maps to text and 'existing conversation' to conversationId, but requestId (an idempotency-style key) is entirely unexplained in both schema and description, leaving a required parameter undocumented.

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

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

States a specific verb+resource ('Prepare an exact private message for an existing conversation') and immediately signals the preview nature with 'Sends nothing'. The confirm step it references implies the sibling fitmeet_message_confirm, but it never names it explicitly, so sibling differentiation is inferred rather than stated.

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?

Clearly lays out the two-branch workflow: confirm directly when the result reports AUTOMATIC authorization, otherwise surface recipient and full text and request confirmation. That is actionable when-to-use guidance, though it does not explicitly name the sibling confirm tool or state when NOT to use this prepare step.

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

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

The description adds no behavioral detail beyond the operation itself: no pagination semantics for beforeSequence, no result-cap behavior for limit, no auth/permission notes, no statement about what a search does or does not cover. It also conflicts with the annotations, which set readOnlyHint=false while the description presents this as a pure read/search 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?

A single front-loaded sentence with no filler; the scope constraint lands immediately. It is efficient, though its brevity contributes to the documentation gaps elsewhere rather than being a virtue on its own.

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 with four parameters at 0% schema description coverage the description leaves pagination and search semantics undocumented, and it does not address the readOnlyHint=false signal. For a tool whose only required input is a UUID the agent must already have, this is too thin.

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

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

Schema description coverage is 0%, so the description carries the full burden, yet it only loosely implies conversationId ('inside one conversation') and query ('search'). It says nothing about limit (max 100), beforeSequence as a pagination cursor, or what fields the query matches against.

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

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

The description gives a specific verb pair (read/search) plus the resource (message history) and constrains scope to 'one conversation belonging to the connected user', which is more precise than the title 'Read my 引力AI messages'. It is clearly distinguishable from fitmeet_conversations_list (which enumerates conversations), but it never names a 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 guidance, no when-not-to-use, and no routing to alternatives such as fitmeet_conversations_list for discovering the conversationId first. Nothing tells the agent when to supply a search query versus walking history with beforeSequence, so usage must be inferred from the schema 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?

The description states this is a read ('分页读取'), but the annotations declare readOnlyHint=false, i.e. the operation may mutate state. That is a direct conflict rather than an omitted detail, and unlike the safety-disclosure gaps the annotations do cover (destructiveHint=false, openWorldHint=false), it is not something the agent can reconcile on its own.

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

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

Three short sentences, scope stated first, filters second, routing last — well front-loaded with no filler. The sentence about recorded feedback not implying a successful recommendation is terser than it could be, but it earns its place as a caveat.

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 an output schema present, return values need no explanation, and the description covers scope, filter values and the cross-tool boundary. It stops short of explaining cursor semantics or result ordering, which matters for a paginated list but is a modest gap.

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

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

Schema description coverage is 0%, so the description must carry the load. It partially does: the Chinese status labels map onto the six enum values and '分页' hints at the cursor parameter. However, it says nothing about the OPEN'after' cursor's type-prefixed format (GROUP/INVITATION/CONVERSATION:uuid) or what the cursor is relative to, which the bare pattern string cannot convey.

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 scope (paginated read of one's own group events, invitations, and existing connections) plus the filter axis, so the agent knows exactly what resource family this covers. The closing pointer to publication_sources distinguishes it from the needs/capability siblings, which is exactly the differentiation the sibling list would otherwise leave ambiguous.

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

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

It explicitly routes the agent elsewhere for a neighbouring concern ('需求和能力来源请使用 publication_sources'), and the status list makes the selection conditions concrete. What is missing is any when-not guidance against the other list siblings (conversations_list, groups_list) that also return overlapping item types.

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

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

Adds three genuinely non-obvious behavioral facts beyond the annotations: do-not-disturb suppresses reminders but not unread counts, reading does not mark items read, and the result is a point-in-time snapshot rather than a live push stream. Note the tension with readOnlyHint=false — the description claims a pure read ('读取不会标记已读'), while the annotation says the tool is not read-only; since the annotation block appears to be a uniform all-false default set, this is not treated as a hard contradiction, but it is a residual ambiguity the description does not resolve.

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

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

Three short sentences, no filler. The scope statement is front-loaded and each following sentence delivers one distinct caveat (DND semantics, non-marking read, snapshot vs. push).

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 an output schema present the return shape need not be described, and the description covers the remaining agent-critical unknowns: what is aggregated, that reads are side-effect-free, and that the data is a snapshot. Nothing required to call this zero-parameter tool correctly is missing.

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

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

The tool takes zero parameters, so the schema imposes no semantics for the description to compensate for; baseline 4 applies. The description correctly implies the scope is fixed to the caller's own account ('本人'), which is the only 'parameter-like' constraint an agent needs to know.

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

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

States a concrete verb (读取/read) and enumerates exactly what resource it covers: unread summaries for private chats, group chats, invitations and group-event changes, plus notification settings. That scope is distinct from siblings such as fitmeet_messages_list or fitmeet_conversations_list, but no sibling is named, so the differentiation is inferred rather than stated.

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 or when-not-to-use statement and no alternative tool is named. Usage is only implied by the scope enumeration — an agent can infer this is the notification-overview entry point, but it must supply the routing logic itself.

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

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

Adds genuinely useful behavior beyond the annotations: the query must still be valid, IDs must originate from that query, and reading details carries no contact authorization. It does not address why annotations mark this a read as non-read-only and non-idempotent, which is a notable omission for an agent judging side effects or retry safety.

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

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

Three short sentences, front-loaded with the action and scope, then the input constraint, then the authorization boundary. No filler and nothing repeated from schema or annotations.

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 no explanation, and the description covers preconditions, input provenance, and the contact boundary. It leaves unclear what 'compare' produces behaviorally and why the operation is annotated non-idempotent, which is the only real gap for a two-parameter tool.

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

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

Schema description coverage is 0%, so the description must carry the load, and it does: it ties queryId to a live query created by this connection and candidatePresentationIds to IDs returned by that query, and its 'up to five' matches the maxItems constraint. It omits the required ID prefixes (pquery_/pcpres_) encoded in the patterns, keeping it below 5.

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

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

States a specific verb (read/compare) on a specific resource (candidates from a query created by this connection), with a hard scope of up to five. This implicitly separates it from fitmeet_people_search, which originates queries rather than consuming them, but it never names a sibling explicitly, so 4 rather than 5.

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

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

Gives a clear precondition (query must still be valid) and a hard input constraint (use only presentation IDs returned by that query), plus a scope limit of five. No alternatives are named for the case where the query has expired or the caller has no IDs, so it stops short of a 5.

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

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

Annotations mark this non-read-only, non-destructive, non-idempotent; the description explains why by disclosing that it 'creates a private query receipt' (mutation) while performing no save/publish/contact/message (no destructive side effects). This is meaningful context beyond the annotations, but idempotency and the receipt's lifetime are not addressed.

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

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

Two tight sentences with zero filler; the core capability and the side-effect boundary are both front-loaded and immediately actionable.

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

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

With an output schema present, return values need not be described, and the description adequately covers the tool's nature and safety boundary. The remaining gap is behavioral (no mention of pagination via continuationToken) for a 10-parameter nested-schema tool.

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

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

Schema coverage is 50%, and the description only touches 'up to five' (maximumResults) and 'the current request' (requestText). Enums like source/primaryIntent and fields like continuationToken, requestId, and candidateBottomLines receive no explanation, so it does not fully 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?

States a specific verb and resource ('Find up to five eligible people or hall listings for the current request') and bounds the scope to a max of five results. It clearly reads as a discovery/search operation distinct from detail or confirmation tools, though it never names a sibling directly.

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 negative list ('does not save a Need, publish, contact, invite, or message anyone') effectively routes the agent away from the prepare/confirm siblings. It does not, however, name the follow-up tool (e.g. people_details) that the receipt feeds into, leaving one inference step.

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

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

The description explicitly frames this as a 'Read' of the user's saved profile, while the annotations declare readOnlyHint=false. A pure read should be read-only, so the description and the structured safety metadata point in opposite directions, leaving the agent unable to tell whether calling this tool mutates state. This is an annotation contradiction.

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 containing the verb, the resource and the authorization requirement. There is no filler and 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?

An output schema exists, so return values need no explanation, and with no parameters the schema carries no burden. What is missing is behavioral framing: the description does not reconcile its 'Read' claim with readOnlyHint=false, nor does it say when to prefer this over the other *_get tools.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. The default baseline of 4 applies; the permission note adds useful invocation context that the empty schema cannot express.

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: 'Read the connected user's saved 引力AI profile.' That cleanly separates it from siblings like fitmeet_notifications_get, fitmeet_group_get and fitmeet_connection_feedback_get, which fetch different resources. It stops short of an explicit contrast with those siblings, but the resource 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?

The description supplies one real usage constraint — the caller needs profile:read permission — which helps an agent decide whether it can invoke the tool. It gives no when-to-use guidance relative to the other read tools, and no statement of what to call when the permission is absent.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds real context the annotations do not: the confirmation is one-time, publication is bound to a specific preview, and a standing-authorization or explicit-approval prerequisite gates the call.

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

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

Two sentences, zero filler, and the core action is front-loaded ahead of the mode/approval conditions. Every clause carries a distinct constraint.

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, and the annotations plus description together cover the safety and authorization picture. It is nearly complete for a 4-param mutation; the only gap is the undocumented non-AUTOMATIC enum value and the parameter-level detail noted above.

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

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

Schema description coverage is 0%, so the description carries the burden and only partially compensates. It conveys the conceptual role of the confirmation token ('the exact preview identified by a one-time confirmation') and the authorizationMode enum values, but never distinguishes confirmationId from confirmationDigest or explains that 'confirmed' is a fixed true guard, nor the digest/id 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?

States a specific verb and resource ('Publish the exact preview') and ties it to the one-time confirmation mechanism, which cleanly separates it from fitmeet_publication_prepare and the chat/message confirm siblings. An agent can tell what this does and which flow it belongs to without opening the schema.

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

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

Explicitly conditions AUTOMATIC mode on the prepare result reporting standing authorization, and otherwise requires explicit user approval of that preview in the current interaction. This is a precise when-to-use / when-not-to-use rule with the alternative path 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?

Annotations already cover safety (readOnlyHint=false, idempotentHint=true, destructiveHint=false). The description adds real value beyond them: the preview is short-lived, it never publishes, and the result carries an authorizationMode gate that determines whether immediate confirmation is allowed. It does not spell out expiry timing or error/consent failure behavior.

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

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

Three tight sentences, front-loaded with what the tool does, then the key safety constraint, then the decision rule for acting on the result. No filler.

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

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

An output schema exists, so return values need not be explained, and the description still flags the pivotal result field (authorizationMode) and the confirm handoff. The main completeness gap is the undocumented parameter set, which is a parameter-level rather than purpose-level deficiency.

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 7 parameters (4 required), and the description explains none of them — not requestId, kind, the version/revision identifiers, nor the two booleans whose default/impact is non-obvious. It only references authorizationMode, which is a result field, not an input. For a low-coverage schema the description should compensate, and it does not.

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

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

States a specific verb+resource: 'Create an exact, short-lived preview for publishing a confirmed profile capability or confirmed Need.' The scope (confirmed capability/Need) and the crucial negative constraint ('This tool never publishes') make it distinguishable from the confirm siblings in spirit, though it never names fitmeet_publication_confirm directly.

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

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

Gives clear context: use it only for a *confirmed* profile capability or Need, and tells the agent how to act on the result (AUTOMATIC permits immediate confirm; otherwise show preview and request confirmation). No explicit when-not or named alternative, but the prepare→confirm flow is well implied.

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

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

Adds real context beyond annotations: 'Does not publish anything' reassures against the sibling prepare/confirm write flow, and the description defines return-state semantics (publication=null means none, omitted field means unknown, ACTIVE means currently displayed). It also imposes a consumption rule about preserving URLs and IDs verbatim. It stops short of describing pagination/ordering for the returned list.

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?

Front-loaded with the core read purpose, then usage, then state semantics, then link-handling rules; each sentence carries distinct information. It is dense but not padded, though the state/URL guidance could be tightened slightly.

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, yet the description usefully clarifies ambiguous state encodings and the no-side-effect guarantee. The only material omission is any guidance on the limit parameter.

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 single 'limit' parameter is never mentioned in the description, so nothing compensates for the gap. Only the schema's min/max constraints hint at its meaning.

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: reads the owner's confirmed capability and Need sources together with publication state, expiry and exact URL. It explicitly distinguishes itself from siblings ('do not use my_items_list or republish to verify it'), so an agent can route correctly without opening another 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?

Gives an explicit use case ('check an existing capability publication') and names the alternatives it should not be replaced by (my_items_list, republishing via the prepare/confirm pair). The condition that selects this tool is unambiguous.

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