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

With no annotations, the description carries the full burden, and it does disclose the two main effects: content hidden in public topics/rooms and interaction blocked between both parties. However, it omits reversibility (the sibling unblock_public_actor suggests this can be undone), required permissions, and whether the block is one-way or mutual in enforcement terms.

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

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

A single dense sentence that front-loads the action and its consequences with no filler. Slightly compact to the point that the two-ID relationship is glossed over, but structurally efficient.

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

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

For a two-parameter mutation tool with no annotations and no output schema, the description covers the observable effects but leaves gaps on parameter semantics, permissions, and reversibility. Adequate as a minimum viable definition, not complete.

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

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

Schema description coverage is 0% for two required parameters, so the description must compensate. It only vaguely refers to 'the specified participant' and 'both parties', never clarifying who actor_id is versus blocked_actor_id or whether the caller must be one of them. The distinction between the two IDs is left entirely to inference.

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 action (block a public actor) and, importantly, its two concrete effects: hiding the participant's content in public topics and rooms, and preventing mutual interaction. That is more informative than the bare name, though it never distinguishes itself from siblings like report_public_content or unblock_public_actor.

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

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

No when-to-use guidance at all. It does not say when blocking is preferable to report_public_content or review_public_report, nor does it mention the existing unblock_public_actor tool for reversing this action. The agent must infer usage entirely from the name.

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

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

With no annotations, the description carries the full burden. "读取...当前状态" does convey that this is a non-mutating state read, which is useful given the name continue_experience could imply mutation. But it says nothing about whether reading resumes/activates the session, what happens on an invalid or expired session_id, or error behavior.

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

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

A single, tightly written sentence that front-loads the action and resource before the usage context. There is no filler or redundancy.

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

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

For a one-parameter read tool with no annotations and no output schema, the description should ideally say what the returned state contains and how it should be used. "当前状态" is vague, so the agent knows the shape of the call but not the shape of the result.

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

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

Schema description coverage is 100%; the single session_id parameter is already documented in the schema as the id returned by launch_experience. The description adds no syntax, format, or constraint detail beyond what the schema provides, so the baseline of 3 applies.

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

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

The description states a specific verb (读取) and resource (体验会话的当前状态), and clarifies that the purpose is resuming an experience across conversations or web pages. This differentiates it in spirit from launch_experience and finish_experience, though it never names a sibling explicitly.

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

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

It gives a usage context — continuing an experience between conversations or web pages — which implies when to call it. However, it names no alternative tool and states no exclusion or precondition (e.g., what to do if the session is expired or was never launched).

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

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

With no annotations, the description carries the full burden. It usefully discloses a privacy-relevant behavior — scope is limited to explicitly selected material, not the host's complete history — but says nothing about what gets persisted, whether the envelope is durable or ephemeral, consent requirements, or side effects. This is meaningful but partial disclosure for an 8-param mutation-adjacent tool.

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

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

Two short sentences with no waste; the positive action is front-loaded and the 'does not read history' caveat follows immediately. Slightly terse given the parameter surface, but structurally sound.

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

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

For a tool with 8 undocumented parameters, no annotations and no output schema, the description covers only about half the surface. An agent can tell roughly what the tool does but not how to populate intent, locale, game_preferences or social_preference, nor what the resulting envelope contains.

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. The description names interests, time and content excerpts, which loosely maps to interests, available_time_minutes/expires_in_minutes and selected_excerpts, but intent, locale, game_preferences and social_preference remain undocumented in both schema and description. It compensates for only part of the gap.

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

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

The description states a specific verb+resource: packaging user-explicitly-selected interests, time and content excerpts into a portable Context Envelope. It also states a negative scope ('does not read the host's full history'), which helps distinguish it from full-history tools. It stops short of differentiating itself from siblings like create_experience_draft or create_public_topic.

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

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

The description implies when the tool applies (only when the user has explicitly opted to share context) and rules out one alternative behavior (reading full history). It never names a sibling tool or states explicit when-not conditions, so usage is implied rather than directed.

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

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

No annotations are supplied, so the description carries the full burden. It does add a genuine behavioral disclosure – the draft is declarative, describes only capabilities and boundaries, and does not execute user code – which is valuable safety context, but it omits authorization requirements, draft persistence/lifecycle, and what the caller receives back.

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 that are front-loaded with the action and follow with the key constraint. No filler, though the second sentence partly restates the safety framing already implied by '声明式模板'.

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 5 parameters, 4 required, no output schema, and no annotations, the description covers the purpose and safety stance but does not indicate what a successful call returns (draft id, status) or how the draft is subsequently used. Adequate but with clear gaps for a creation 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 100%, so the baseline is 3. The line '只描述能力和边界,不执行用户提供的代码' reinforces the requested_capabilities semantics ('希望使用的能力名称,而不是可执行代码'), adding a little meaning, but the remaining parameters are left entirely to the schema.

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

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

The description states a specific verb and resource: generating a private ('私人') experience draft from a declarative template. The 'private' qualifier usefully separates it from public-create siblings like create_public_topic, though it does not name any alternative 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?

There is no explicit when-to-use or when-not-to-use guidance. It never explains how this draft relates to the launch flow (prepare_experience_launch, launch_experience) that sibling tools imply, so the agent must infer the sequencing entirely.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does disclose two real behavioral traits — the content becomes publicly visible and a moderation-rules disclosure step is required beforehand — which is more than a plain restatement. However it is silent on permissions/actor authorization, whether the topic is immediately live or moderated first, reversibility, and error behavior.

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

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

Two short sentences, zero filler, with the core action stated first and the precondition second. It is efficient and well front-loaded; the brevity is a symptom of under-specification rather than verbosity.

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

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

For a write tool that publishes publicly visible content, with no annotations, no output schema and 0% parameter coverage, the description does too little. It flags the moderation/visibility gate but omits parameter meaning, authorization expectations, what happens after success, and how moderators may act on the topic.

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 parameters (actor_id, title, body, tags) and the description says nothing about any of them — no hint about who actor_id is, how title/body lengths behave, or how tags affect discoverability or moderation. With no structured documentation to fall back on, this leaves the required inputs entirely unexplained.

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 first sentence gives a specific verb+resource (\"创建一个公开话题\" / create a public topic), so the agent can tell what will happen. It does not differentiate from the read-side sibling discover_public_topics or explain how a topic relates to rooms/messages, so it stops short of a 5.

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

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

The second sentence supplies a genuine precondition: before publishing, the public visibility scope and content moderation rules must be shown to the user. That is useful implied-usage guidance, but it never says when to choose this over a sibling (e.g. post_public_message or prepare_experience_launch), nor any exclusion 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?

With no annotations, the description carries the full burden. It usefully discloses that the host must prepare authorization and obtain user consent before launching, which is real behavioral context. However it never states that this tool itself only recommends (read-only) and does not itself launch or mutate, nor does it disclose rate limits or return characteristics.

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

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

Two short sentences, purpose front-loaded ahead of the consent/host caveat. Efficient with no filler, though the second sentence mixes an operational precondition with the tool's own behavior.

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

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

For a 3-parameter, no-output-schema recommendation tool this is minimally adequate: purpose and the consent prerequisite are covered. It leaves gaps around what is returned and how results relate to the downstream launch tools, which an agent would need for sequencing.

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 67% — intent and known_interests are documented in the schema, while max_results relies only on default/range constraints. The description adds no syntax, format, or meaning beyond the schema, so the baseline 3 is appropriate.

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

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

States a specific verb (推荐/recommend) and resource (体验模块/experience modules), plus the scoping condition that they be immediately startable and grounded in the user's explicit intent. It is distinguishable from siblings like launch_experience or prepare_experience_launch, though it does not name them 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 phrase '用户当前明确表达的意图' implies the trigger condition (user has expressed an explicit intent) and the consent prerequisite is mentioned, but there is no explicit when-not guidance or named alternative tool. Usage is inferable rather than spelled out.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose a meaningful scope trait — results exclude private matching and automatic direct messages — which is genuinely useful. But it says nothing about permissions, whether this is a safe read-only operation, result limits/pagination, or what happens for unknown actors.

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

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

A single compact sentence, front-loaded with the resource and the governing input. No filler, though the negative clause could be tightened.

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

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

For a 4-parameter tool with zero schema descriptions, no annotations, and no output schema, the description is too thin. It omits parameter meaning, return shape, and the boundary against sibling discovery tools, leaving an agent unable 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, so the description must compensate. It only illuminates one concept — "interests" — and says nothing about query, actor_id, or max_results, leaving three parameters with no semantic guidance 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?

The description names a specific verb (discover) and resource (公开话题 / public topics), and adds a scoping condition (based on interests the user explicitly provided). It stops short of differentiating itself from close siblings such as discover_experiences or create_public_topic, leaving the agent to infer the distinction.

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

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

"根据用户明确提供的兴趣" implies a precondition for use (the user must have stated interests), and the negative clause rules out private-match and auto-DM scenarios. However, there is no explicit when-to-use-vs-alternative guidance naming discover_experiences or create_public_topic, so usage remains implied rather than stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It notes that a final state is returned but does not disclose whether ending a session is irreversible, what happens to in-progress state or submitted events, or what permissions are required for this mutation.

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

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

A single compact sentence with the action front-loaded and no filler. It is appropriately sized, though it omits any detail that would make the brevity genuinely informative.

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

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

For a session-terminating mutation with no annotations, no output schema, and an undocumented parameter, the description is too thin. An agent lacks the information needed to know when this is safe or correct to invoke.

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

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

The single parameter session_id has 0% schema description coverage and is never mentioned in the description. With low coverage the description is expected to compensate by explaining the parameter's origin or format, which 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?

The description states a specific verb (结束/finish) and resource (体验会话/experience session), making the action distinguishable from siblings like launch_experience or continue_experience. It does not, however, explicitly contrast itself 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 guidance on when to call this tool versus alternatives such as continue_experience or submit_experience_event, and no prerequisites or preconditions are stated. Usage is only implied by the tool name.

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

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

With no annotations, the description carries the full disclosure burden. It usefully discloses one behavioral trait — that no bearer token is returned — which prevents the agent from expecting credentials. However, auth requirements, error behavior, and whether the query is side-effect free are left unstated.

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

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

One compact sentence with zero filler; the core purpose leads and the negative constraint (no bearer token) is placed last as a qualifier. 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?

No output schema exists, but the description compensates by naming the returned fields (status, modules, permission scope). The remaining gap is the undocumented receipt id and lack of guidance on how the status values should be interpreted.

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 parameter consent_receipt_id is undocumented in both schema and description. The phrase '一次体验授权' implies a single consent is addressed by the id, but there is no explanation of the id's format or where to obtain it, so the coverage gap is only marginally compensated.

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 enumerates the returned facets: current status, modules, and permission scope. It also carves out a boundary versus the sibling revoke_consent by clarifying this is a read that does not return a bearer token, though it never names an alternative explicitly.

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

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

There is no when-to-use, when-not-to-use, or prerequisite guidance. The existence of sibling tools such as revoke_consent and launch_experience means an agent could benefit from knowing when to check status versus revoke, but nothing is offered.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that content from blocked participants is not returned and that only currently visible messages are read, but it omits access/permission requirements, pagination, and whether the operation is strictly read-only.

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

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

Two compact sentences, front-loading the core read operation and then the visibility caveat. Every sentence earns its place with no waste.

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

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

No annotations and no output schema, combined with 0% parameter coverage, leave important gaps. The description conveys the read purpose and one filtering rule but does not explain actor_id or access requirements, so an agent lacks enough context 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% for two required parameters (room_id, actor_id). The description implies a room must be identified but never explains room_id, and it says nothing about actor_id, so it only partially compensates for the missing schema documentation.

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

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

States a specific verb (读取) and resource (公开讨论房间及当前可见消息), making the operation clear. It does not differentiate from sibling tools like discover_public_topics or join_public_room, 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?

No when-to-use or when-not-to-use guidance is given. It does not name alternatives such as join_public_room for joining or discover_public_topics for listing, leaving the agent to infer that this is simply the read-room tool.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It does add one genuine constraint not present in the schema — the room permits only public speech and no private messaging — which is useful for an agent reasoning about disclosure. However, it omits idempotency (what happens if the actor is already in the room), authorization requirements, and any state changes caused by joining, leaving notable gaps for a mutation tool.

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

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

A single compact sentence with no filler, and the core action is front-loaded before the behavioral caveat. It is under-specified rather than bloated, so conciseness itself is not the weakness.

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

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

For a two-required-parameter mutation tool with no annotations and no output schema, the description should cover prerequisites, post-join state, and parameter meaning. It supplies only the room's public-speech constraint, leaving the agent without enough to invoke it confidently in edge cases.

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 both actor_id and topic_id are undocumented in the structured schema. The description only alludes to the topic (公开话题) and says nothing about actor_id, its format, or the relationship between the two required parameters, failing 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 (加入/join) and resource (公开话题的讨论房间), so the agent knows the operation is joining a topic's discussion room. It does not, however, distinguish itself from the sibling get_public_room, which plausibly reads the same resource, so the boundary is left implicit.

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

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

The phrase 按需 (as needed) gestures at on-demand use but gives no concrete condition, prerequisite, or alternative. With siblings like get_public_room, create_public_topic, and post_public_message in scope, the description never says when joining is the right call versus reading or posting.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the token is one-time (一次性) and that the call creates a stateful local session, but it omits failure modes, token-reuse behavior, and session lifecycle details an agent would need.

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 that combines the action with its prerequisite and side effect. No wasted words, though it could be slightly more explicit about the trigger condition.

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

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

For a two-parameter tool with full schema coverage and no output schema, the description supplies the missing workflow context (token provenance and session side effect). It is adequate, with only minor gaps around error and lifecycle behavior.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema; the description only re-frames consent_token as a one-time authorization token. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description names a specific verb and resource (启动体验 / launch an experience) and adds a concrete outcome (创建一个有状态的本地会话). It distinguishes itself from the sibling prepare_experience_launch by naming it as the token source, though it doesn't contrast with continue_experience or finish_experience.

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

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

It clearly establishes the prerequisite: the one-time token must come from prepare_experience_launch, implying the correct call order. No explicit when-not conditions are given, so it stops short of full routing guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read operation via '展示' but does not explicitly state read-only safety, side effects, authentication requirements, rate limits, or pagination behavior. The inclusion of field names is return-value context, not behavioral trait disclosure.

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

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

The single sentence is front-loaded with the purpose and efficiently lists the fields returned. It avoids boilerplate or redundancy, though it could be slightly tighter by omitting some field enumerations if they were documented elsewhere.

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

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

For a tool with three undocumented parameters, no annotations, and no output schema, the description is incomplete. It does not compensate for the 0% schema coverage or explain how the 'local registry' scope relates to the rest of the public experience workflow. An agent lacks enough context to invoke it confidently with correct parameters.

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 three parameters, and the description mentions none of them. It does not explain what 'category', 'max_results', or 'require_trusted_signature' do, their defaults, or their allowed values. The description adds no meaning beyond the raw schema names.

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

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

States a specific verb ('展示' / display) and resource ('公开体验模块' / public experience modules), and details the returned fields (version, permissions, risk, publisher, signature status). However, it does not differentiate itself from sibling tools like discover_experiences or list_public_reports, so an agent cannot tell when to choose this over alternatives without further 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?

Provides no when-to-use, when-not-to-use, or alternative-tool guidance. The description only says what it lists, not under what conditions an agent should select it versus discover_experiences or other listing tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It mentions authorization context but does not state whether this is read-only, whether data is cached locally, how many reports are returned, pagination behavior, or whether calling it has side effects. The one behavioral hint about authorization is useful but thin.

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

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

The description is a single short sentence that front-loads the resource and audience. It is concise and has no filler, though it is arguably too brief to carry the needed behavioral detail.

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

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

For a listing tool with no annotations, no output schema, and a 0%-covered enum parameter, the description is incomplete. It omits return format, ordering, pagination, and filter semantics, which an agent needs to call it correctly.

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

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

Schema coverage is 0% and the single status parameter has an enum but no descriptions. The description does not explain the status filter, its allowed values, or whether omitting it returns all reports. With one parameter and zero coverage, the description should compensate but 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?

The Chinese description states it reads the local public content moderation queue for explicitly authorized reviewers. This gives a verb (read/list) and resource (moderation queue), but it is vague about scope compared to the English title 'List public moderation reports'. Siblings like report_public_content, review_public_report, and list_public_modules are not distinguished, so an agent cannot easily route between queue-listing and report-reviewing 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?

The description implies usage context by limiting access to 'explicitly authorized reviewers' for the 'public moderation queue', but it does not say when to use this versus review_public_report or report_public_content. No explicit when-to-use or when-not-to-use guidance is 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?

With no annotations at all, the description carries the full burden. It does disclose a genuinely useful behavioral trait — posted content enters a public moderation queue, so delivery may be gated — but omits permission/auth requirements, whether posts can be edited or deleted, and any rate limits.

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

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

Two short sentences with no filler, and the core action is front-loaded before the moderation caveat. It is terse rather than padded, though it is arguably too sparse for a three-parameter write tool.

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

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

For a write tool with no annotations, no output schema, and zero schema documentation, the description should do more. It covers the notable moderation-queue behavior but leaves actor identity, room resolution, and the response contract entirely 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% across three required parameters, and the description compensates for none of it: it never explains what actor_id identifies, how room_id is obtained, or that body is capped at 2000 characters. The purpose sentence only loosely implies room and message.

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 first sentence states a specific verb (发言/post) and resource (公开讨论房间/public discussion room), so an agent can tell it apart from siblings like create_public_topic or join_public_room. It stops short of explicitly naming how it differs from those siblings, but the action 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?

Usage is implied by the verb-plus-room framing, and the closing clause '当前不提供私信' rules out the private-messaging case. However, there is no explicit guidance on when to choose this over create_public_topic or join_public_room, and no prerequisites for posting are given.

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

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

With no annotations, the description carries the full behavioral burden and delivers meaningful context: the authorization is one-time and time-limited, and explicit user consent is a precondition. It still omits what the returned request looks like, how long it lives, and whether it can be reused or must be regenerated, so it is strong but not exhaustive.

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

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

Two sentences, zero filler. The consent precondition is front-loaded and the follow-up call is named last, matching the order in which the agent must reason about them.

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

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

For a three-parameter consent-flow tool with a nested context_envelope and no output schema, the description covers purpose, precondition, and next step adequately. The main gap is return-value behavior — no output schema exists, yet the description does not explain what the generated authorization request contains or how it is handed to launch_experience.

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

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

Schema description coverage is 100%, so experience_id, context_envelope, and requested_scopes are already documented in the schema. The description only alludes to scopes and the experience module at a conceptual level and adds no syntax, selection, or constraint detail beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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 — generating a one-time, time-limited authorization request for the user-selected experience module — and names the sibling it precedes (launch_experience). An agent can distinguish this preparatory step from launch_experience without opening either 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 sequencing rule: the host must show scopes to the user, obtain explicit consent, then call launch_experience. This tells the agent both when to use this tool and what must happen before the follow-up call. It does not, however, mention alternatives such as get_consent_status or revoke_consent, so it stops short of full when-not guidance.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that the report goes into a review queue and does not automatically mark the content as violating, which clarifies the side effect and non-immediacy. It still omits permission requirements, duplicate-report behavior, and what the caller gets back.

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

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

A single compact sentence pair, front-loaded with the action and immediately followed by the important outcome semantics. 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?

With no annotations, no output schema, and 0% parameter description coverage, the description should do more, especially around the four required parameters and what happens after submission. It covers the action and the moderation-queue outcome adequately but leaves parameter and return expectations 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% across four required parameters. The description only indirectly implies target_type by naming topics and messages, and does not explain reporter_id, target_id, or the reason field's constraints (3-500 chars). It compensates only partially for a large documentation gap.

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

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

The description gives a specific verb+resource: report a public topic or public message (举报公开话题或公开消息). That is clearly distinguishable from moderation siblings such as review_public_report and list_public_reports. It stops short of naming an alternative or boundary explicitly, so it is clear but not maximally 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?

Usage is implied by the verb 'report' and the outcome note that the report enters a moderation queue, which tells the agent this is a submission rather than a review action. However, there is no explicit when-to-use guidance, no statement of prerequisites, and no reference to siblings like review_public_report or block_public_actor.

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

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

No annotations are provided, so the description carries the full burden. It implies a mutation with three outcomes, but never states whether hide/restore are reversible, what happens to the reported content or reporter, or any permission requirements. Only the bare decision set is disclosed.

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 actor, resource, and outcome set all appear in one clause. It is appropriately terse for the operation, though the brevity leaves gaps rather than being wasteful.

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

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

For a three-parameter mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is too sparse. Side effects, authorization, reversibility, and expected outcomes are all missing, leaving the agent to guess at consequences.

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%, three required parameters. The description partially compensates by naming the actor (审核者 → reviewer_id), the target (公开内容举报 → report_id), and the three decision values that match the enum. However, it adds no constraint details (length bounds, ID format) beyond what the schema already enforces.

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

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

The description names a specific verb (作出...决定 - makes a decision) and resource (公开内容举报 - public content report) carried out by a reviewer, and enumerates the three possible outcomes (驳回/隐藏/恢复). This clearly distinguishes it from siblings like report_public_content (filing) and list_public_reports (reading), though it never names those siblings explicitly.

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

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

There is no guidance on when to invoke this tool versus report_public_content or list_public_reports, nor any stated preconditions such as required reviewer privileges or which decisions are permitted in which state. The agent must infer the workflow entirely from the name.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It hints at a limitation regarding used sessions ('已使用的会话不会被此工具伪装成未使用'), but this phrasing is opaque and does not clarify permissions required, reversibility, or side effects on the consent record.

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

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

The description is two short sentences with the primary purpose front-loaded and no wasted words. The second sentence is somewhat awkwardly phrased, slightly reducing clarity, but overall it is appropriately sized.

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

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

For a mutation tool with no annotations, no output schema, and an undocumented parameter, the description is incomplete. It states the core action and one ambiguous behavioral note, but omits necessary details about authentication, effects on existing consents, and how to supply the required receipt ID.

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 never mentions the single required parameter 'consent_receipt_id' nor explains how to obtain or format it. The only hint is the abstract concept of an authorization, which does not compensate for the complete lack of parameter documentation.

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

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

The description uses a specific verb (撤销/revoke) and resource (尚未使用的体验授权/unused experience authorization), making the core operation clear. It does not explicitly name or contrast with any sibling tool such as get_consent_status, so it stops 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 qualifier '尚未使用的' (not yet used) implies the tool should be used only for unused authorizations, which is useful context. However, it does not state when to choose this over alternatives like get_consent_status, nor does it clearly describe prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It hints that the operation targets a stateful session and that events are 'restricted' (受限), but does not disclose side effects, permission requirements, error behavior for invalid event/session combinations, or what state change occurs.

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

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

A single front-loaded sentence with the action first, no filler, and an immediately useful example list. It is efficient, though its brevity is partly under-specification rather than economy.

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

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

With no annotations, no output schema, 0% schema coverage, an opaque nested payload object, and an undocumented enum value, the definition is too thin for an agent to call correctly. It should at least explain payload contents and the full set of valid event types.

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

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

Schema description coverage is 0%, and there is a nested free-form 'payload' object plus an enum whose meaning is non-obvious. The description names three of the four enum values (answer, hint, restart) but omits 'finish', and says nothing about session_id or the shape of payload, leaving the schema largely unexplained.

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 ('向有状态的体验提交一个受限事件' = submit a restricted event to a stateful experience) and enumerates representative event examples (answer, hint request, restart). This distinguishes it reasonably from discovery/launch siblings, though it does not explicitly contrast with continue_experience or finish_experience.

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

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

No when-to-use guidance is given. It never states the preconditions (an active session), nor when this should be chosen over continue_experience, finish_experience, or prepare_experience_launch, all of which are near neighbours. The event examples hint at context but do not constitute usage rules.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the outcome (viewing and participation are restored) but says nothing about required permissions, idempotency when the actor is not blocked, or whether the action is reversible. This is thin for an unannotated mutation tool.

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

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

A single sentence with no filler, and the operative effect is front-loaded. It is efficient, though its brevity contributes to the specification gaps captured elsewhere.

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

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

For a two-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, the description is too sparse. It neither disambiguates the two identically-typed ID parameters nor covers permissions, side effects, or error conditions.

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

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

Schema description coverage is 0% for two required parameters, so the description must compensate and it does not. It refers only to a single 'specified public actor', leaving the crucial distinction between actor_id (the caller) and blocked_actor_id (the target being unblocked) completely unexplained.

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

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

The description states a specific verb-effect and resource: restoring the ability to view and participate in the content of a specified public actor. An agent can understand this is the inverse of block_public_actor, though the sibling relationship is only implicit and never named.

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

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

There is no guidance on when to invoke this versus other tools, no mention of the counterpart block_public_actor, and no preconditions such as 'the actor must currently be blocked'. Usage must be inferred entirely from the name.

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