引力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?

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?

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 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.