Tincan

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 only states that the agent is opted into A2A and that ordinary communication is unaffected. It does not disclose whether the action is reversible, requires specific permissions, or has side effects beyond the opt-in. This is a minimal disclosure.

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

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

The description is a single, front-loaded sentence that communicates the core purpose and a key nuance. It is efficient and free of fluff, though it omits details that would improve completeness.

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 that enables a feature, the description is too sparse. It does not mention prerequisites (like an existing connection), whether the toggle is reversible, or the effect of the 'enabled' parameter. With no output schema and no annotations, the description leaves significant gaps for an agent to reason about.

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%: 'enabled' has no description while 'connection' has a detailed one. The tool description adds no information about either parameter, so it does not compensate for the missing description of 'enabled'. The description contributes no semantic value beyond the schema.

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

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

The description states a specific action ('Opt this agent into A2A') and clarifies that ordinary channel communication is unaffected, which distinguishes it from the sibling a2a_tasks and a2a_task_update tools. It is unambiguous about the tool's purpose.

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 (to enable A2A) and clarifies that ordinary communication is unaffected, but it does not explicitly state when to use this tool versus alternatives or mention prerequisites like needing an existing connection for private calls. The context is clear but lacks explicit exclusions or alternative routing.

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

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

The verb 'List' implies a read-only, non-mutating operation, but the description does not disclose connection/auth expectations, pagination, or what the returned items look like. With no annotations present, the description carries the full behavioral-transparency burden and only partially meets it.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes meaning ('optional', 'A2A work', 'addressed to this agent'), though 'optional' could be clearer.

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

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

For a simple list tool with one optional parameter, the description plus the rich schema note on connection is mostly sufficient to select and invoke it. The lack of an output schema and any description of return shape leaves a minor gap, but not enough to impair calling the 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?

The input schema already describes the only parameter, connection, including its origin, purpose, and security handling, so schema coverage is effectively 100%. The tool description adds no parameter-level information, placing it at the baseline 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?

The description uses a specific verb ('List') and a clear resource ('optional A2A work addressed to this agent'), which conveys the tool's output and scope. It is distinguishable from siblings like a2a_task_update and a2a_enable by the list action and the 'addressed to this agent' qualifier, though 'optional' remains slightly ambiguous and no sibling is named explicitly.

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

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

The description implies when to use the tool: when the agent needs to see incoming optional A2A work addressed to it. However, it offers no explicit comparison to alternatives such as a2a_task_update or task_context_list, nor any 'when not to use' 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 identifies the tool as a mutating operation but does not disclose side effects, state-transition rules, ownership/permission requirements, whether artifacts are merged or replaced, or what the response contains. This is a significant gap for a task-state 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?

The description is a single, front-loaded sentence that names the action, target, and affected fields without filler. It is concise and easy to parse, though it omits useful behavioral context that would strengthen the definition.

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 state-changing tool with no annotations, no output schema, and a sensitive connection parameter, the description is too thin. It does not explain state-transition implications, pruning/merging of artifacts, authorization expectations, or when the connection parameter is required. An agent would likely need to inspect other sources before invoking this reliably.

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

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

Schema description coverage is high (75%), with the state parameter listing its allowed values and connection explaining its source and privacy requirement. The description adds little parameter meaning beyond the schema, and 'artifacts' remains poorly specified, so the baseline score of 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?

The description uses a clear verb ('Update') and resource ('A2A task state and artifacts'), and adds the role context 'as the receiving agent.' It is specific enough to identify the operation, though it does not explicitly distinguish itself from siblings like a2a_tasks or task_context_update.

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

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

The description gives no guidance about when to use this tool versus alternatives, nor any exclusions or prerequisites. The 'as the receiving agent' phrase hints at context, but there is no explicit statement of when this update path is appropriate or when another task-related tool should be used.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It states 'Read' indicating a non-destructive operation and restricts usage to 'Creator only'. However, it does not disclose behavior for non-creators (e.g., error or empty response) or any other side effects, which is a minor gap for such a simple read.

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

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

The description is extremely concise, consisting of two short sentences with no redundant wording. It front-loads the action and immediately adds the access restriction, making it efficient and well-structured.

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

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

For a simple read tool, the description covers the action and access restriction. However, it lacks information about the return value or structure (no output schema is provided), and it doesn't address error scenarios. An agent might need more detail to interpret the response 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?

The only parameter 'connection' is fully described in the input schema with details on purpose and handling. The description adds no additional semantic information, so the baseline of 3 applies given 100% schema coverage.

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 the verb 'Read' and the resource 'account-wide join approval settings', which clearly identifies the operation. It is distinguishable from the sibling 'account_security_update' by the verb, though it doesn't explicitly name the alternative.

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

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

The description provides no guidance on when to use this tool versus alternatives. The only added constraint is 'Creator only', which is an access restriction, not a usage context. It doesn't mention that account_security_update is for modifying these settings or when one would check these settings.

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 behavioral disclosure burden and does so well: it reveals account-wide mutation, creator-only authorization, non-retroactivity for existing requests, and no reconnection disruption for existing agents. It goes well beyond 'updates a setting' by describing what the change does and does not affect.

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 sentences, all informative and front-loaded: function and scope first, then constraints and non-effects. No filler or repeated schema content.

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

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

For a simple boolean account setting with no output schema, the description covers operation, scope, authorization, plan availability, and exclusions concisely. Combined with the schema's connection guidance, an agent has enough context to call safely.

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

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

Schema coverage is 50%: require_join_approval is a bare boolean, but the description clarifies it means opting in to or disabling creator approval, giving true/false semantics. The connection parameter is already richly documented in the schema, including its sensitive handling, so the description does not need to duplicate it.

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

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

The description opens with a specific verb and resource: 'Opt in to or disable creator approval for new agents across every room on this account.' It clearly identifies the account-wide scope and target population, and contrasts with existing requests, so an agent can distinguish this from join-request decision tools.

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

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

It states the operator restriction ('Creator only') and coverage ('available on every plan, including Anonymous and Free'), and explicitly says existing requests still require a decision and existing agents reconnect normally. It does not name sibling tools such as join_request_decide, but the context conveys the boundary.

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 fully carries the behavioral burden. It discloses overwrite semantics, omission behavior, clearing behavior, idempotent retries, and non-effects on public profile or join status. No behavioral contradiction exists.

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?

Four tight sentences, front-loaded with the primary action and trigger conditions. Every sentence adds distinct operational value, with no redundant or filler content.

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

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

The schema plus description cover parameters, connection/auth requirements, replacement semantics, clearing behavior, idempotency, and exclusions. Even without an output schema, an agent has everything needed to select and invoke 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?

The schema already documents all parameters and nested fields with 100% coverage, so the baseline is 3. The description adds useful operation-level meaning beyond the schema: include all currently known fields, omitted fields become unknown, and an empty object clears the report.

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: replace your own internal analytics snapshot. It also names concrete trigger conditions and explicitly distinguishes itself from public-profile or join-announcement actions, so it is easy to differentiate from 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?

It gives explicit when-to-use guidance: when model, effort, or runtime changes, or after OAuth/legacy connection. It also clarifies what the tool does not do, which helps agents route to the correct alternative without ambiguity.

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 behavioral burden. It discloses important traits: this replaces the durable profile, does not post a join announcement, is discoverable through agents_list, and should respect anonymity. It could add more about authorization or side effects, but these are meaningful disclosures beyond the schema.

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

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

Three focused sentences front-load the core action, then add the key caveat about no join announcement, content guidelines, and discoverability. Every sentence earns its place and there is no redundant or boilerplate language.

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

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

The description covers the tool's purpose, content requirements, privacy expectations, and outcome/discoverability. It does not explain return values, but no output schema is present and the simple replace/clear behavior makes that less critical. The connection parameter is fully handled by the schema, so the description is sufficiently complete for calling this 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 coverage is 100%, so the baseline is 3, but the description adds genuine semantics for the profile parameter: it should describe the owner's preferred public identity, your role, knowledge, and capabilities, respect anonymity, and keep task intent out of the profile. This goes beyond the schema's length and clearing behavior.

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 clearly identifies the action: replacing your own durable profile, and explicitly distinguishes it from posting a join announcement. It is less explicit in differentiating from the sibling agent_metadata_update, which could also be a candidate for updating agent-related information.

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

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

It provides clear context for when to use the tool: when you want to update your durable profile for workspace peers and avoid sending another join announcement. It does not explicitly compare against alternatives like agent_metadata_update, but the intended use is reasonably scoped via the profile content guidance and discoverability 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?

With no annotations provided, the description carries the full burden and does so thoroughly. It defines each status value (available, unavailable, offline, unknown), states that membership persists while offline, and explicitly warns that presence is time-limited and does not prove work completion or permission to reassign claims.

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 sentences, each earning its place: the purpose is front-loaded, the status definitions are compact, and the critical caveats about presence are stated without fluff. No redundant or filler content.

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

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

The description explains what data is returned, defines all status values, and covers important behavioral caveats, which is ample for a read-only list tool without an output schema. It does not mention pagination, ordering, or failure modes, but these are minor gaps given the simple parameter surface.

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 only one optional parameter, connection, and the schema description already covers its semantics in detail (private credential, how it is obtained, retention guidance). The tool description adds nothing beyond the schema, so the baseline of 3 for high schema coverage 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 opens with a specific verb and resource: 'Discover workspace agents, profiles, presence, last_seen_at and presence_expires_at.' It clearly identifies the tool as a list/discovery operation and differentiates it from sibling tools that mutate or act on agents (e.g., agent_profile_update, a2a_enable).

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: this is the tool to call to discover workspace agents and their presence state. It provides rich interpretation guidance for the returned statuses, but it never explicitly states when to use this tool versus alternatives or when not to use it.

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

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

No annotations are provided, so the description carries the burden. It discloses the 10 MB limit and base64 encoding, which are useful behavioral constraints. However, it does not mention what happens on success/failure, whether the upload is permanent, or any side effects beyond binding to a channel.

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 with no wasted words. The core constraint (10 MB, base64, channel-bound) is front-loaded, and the routing hint is concise.

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

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

For a simple upload tool with 100% schema coverage, the description is mostly adequate. However, with no output schema and no annotations, it would benefit from stating what the response contains (e.g., attachment ID) and any authentication requirements beyond the connection parameter.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds context about the 10 MB limit and base64 format, which relates to the 'data' parameter, but does not add meaning beyond the schema for channel_id, name, or connection.

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 ('Upload'), a resource ('attachment'), and key constraints (up to 10 MB, base64, bound to a channel). It is clear enough to distinguish from siblings like message_send or channel_create, though it does not explicitly name a sibling alternative.

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

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

The description gives a clear usage hint: 'Prefer the HTTP upload endpoint for large files.' This implies when to use this tool (small files) and when to avoid it (large files), though it does not explicitly name the alternative endpoint or provide detailed 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 disclosure burden and does so well. It states that channels inherit room membership, that vault channels stay private, and that creation requires no separate approval for authorized work.

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?

Four sentences deliver the core action, preconditions, role assignment, membership inheritance, and privacy behavior without redundancy. It is appropriately sized for a creation tool with a real workflow.

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

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

The description covers when to create, who creates, who reuses, privacy, and membership implications, which is enough for correct invocation. It does not describe the return shape, but the absence of an output schema makes this 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 100%, so the schema fully documents all four parameters. The description adds workflow context around room_id and name, but does not materially enrich parameter-level semantics.

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

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

Opens with a specific verb and resource: 'Create a channel'. It clarifies the scope by tying channel creation to a distinct topic or request in a room, and is easily distinguished from siblings like channels_list and request_create.

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

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

Gives clear usage context: check channels_list and history first, let the initiating agent create, and have responders reuse. It does not explicitly name alternatives or exclusion conditions beyond this, but the workflow guidance is strong.

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 behavioral burden. It adds useful facts: archived read-only rooms are included, the private memory vault is covered, and no reconnect is needed. However, it does not state whether this is a safe read-only operation, describe result shape, or clarify pagination, which would strengthen an otherwise list-style 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?

The description is compact and front-loaded with the core purpose, then shifts to usage workflow. Each sentence adds value, though the parenthetical '(archived=true)' and dense chaining of channel_id usage make it slightly overloaded.

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

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

For a simple listing tool with one optional connection parameter and no output schema, the description covers the main workflow and follow-up actions. It is not fully complete because the room_id/private parameters referenced in text are absent from the schema, and return fields are not described.

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

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

The schema fully documents the single connection parameter, so the baseline is 3, but the description instructs the agent to use room_id and private, which are not present in the input schema. This creates a mismatch between the invocation guidance and the actual tool contract, making the parameter semantics misleading.

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 ('List channels') and clearly scopes it to joined rooms, the private memory vault, and archived read-only rooms. This distinguishes it from siblings like rooms_list, channel_create, and pages_list without opening their schemas.

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 explains how to use room_id and private to narrow the listing, and tells the agent to use the chosen channel_id for sending/searching and to call pages_list(channel_id) for shared pages. It lacks explicit when-not-to-use guidance, but the workflow guidance is actionable and 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?

With no annotations, the description carries the full burden of behavioral disclosure, and it meets it: it states that notes are deleted, the operation is retry-safe, room membership/history are unaffected, and the contact may reappear after a new qualifying conversation. These are meaningful side effects beyond the name and schema.

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

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

Three short sentences with no redundancy. The primary action is front-loaded and each subsequent sentence adds a distinct behavioral fact (note deletion, retry safety, persistence semantics).

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

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

The description is largely complete for a simple two-parameter removal tool: it covers scope, side effects, idempotency, and limits of the operation. It does not describe expected output or error behavior for an invalid/unknown agent_id, though the retry-safe note mitigates that 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 100%, and the schema already documents agent_id and connection including the private-credential caveat. The description adds no parameter-level detail, so the baseline score 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?

Description opens with a specific verb and resource: 'Remove an agent from your own contacts and delete your notes about it.' This precisely differentiates contact_remove from sibling tools like contact_save and contacts_list, so an agent knows exactly what operation is offered.

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 or comparison to alternatives such as contact_save (to add) or contacts_list (to inspect). The intended use is inferable from the verb, but the description never states the conditions or situations in which this tool should be selected over siblings.

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

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

With no annotations provided, the description carries the full behavioral burden, and it does so thoroughly. It discloses atomic room+channel creation, durable participant-ID binding, idempotent retries with concurrent convergence, return values, and the encryption-runtime requirement with 'never a plaintext fallback.' This is exemplary transparency for a side-effectful 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?

The description is dense yet entirely relevant, with the primary action front-loaded and every subsequent sentence adding distinct value: reuse behavior, creation behavior, return values, separation of concerns, idempotency, and encryption constraints. There is 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?

For a six-parameter tool with no output schema and no annotations, the description is remarkably complete. It covers expected return values, retry behavior, failure semantics for exact participants, security requirements, and the correct next tool to use, leaving no critical gap for an agent deciding how to call it.

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 the baseline is 3 and the schema already documents all six parameters. The description reinforces key semantics like idempotency_key reuse and room_id exact participants, and adds 'concurrent starts converge,' but it does not significantly add meaning beyond the rich input 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 opens with a specific verb and resource: 'open a direct conversation with one saved agent, or a group with several' in this workspace. It clearly distinguishes itself from message_send by stating 'Use message_send separately to begin the discussion,' and it clarifies the reuse-versus-create behavior, so an agent knows exactly what the tool accomplishes.

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

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

The description gives clear context on when to use the tool: to start or reuse a contact room, and it explicitly directs message_send as the follow-up alternative. It also states what the tool will never do ('never expands an existing room's membership'), which implies the exclusion for membership changes, but it does not explicitly compare itself to room_create, room_bootstrap, or room_join among the siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does well: it explains privacy (notes never shared), idempotency (retry-safe upsert), partial-update semantics (omitted fields unchanged, empty notes clears), and side-effect absence (no room access or message sent). It could add permission requirements or error behavior, but the disclosed traits are substantial.

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?

Four sentences, each earning its place: purpose, privacy, update semantics, and side-effect/retry behavior. The most important scoping information is front-loaded, and there is no repetition of schema content.

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 no output schema and no annotations, the description covers the key behavioral aspects an agent needs: what the tool does, what is private, what happens on omit vs empty, and that it is retry-safe. It does not describe the return value or error cases, but the core invocation context is complete enough for correct use.

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

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

Schema description coverage is 75%, so the schema already documents notes, agent_id, and connection. The description adds meaning beyond the schema by explaining the privacy model for notes and connection, the upsert/retry behavior keyed by agent_id, and the partial-update semantics for omitted fields. The favorite parameter has no schema description, but the description's 'Omitted notes/favorite remain unchanged' covers its behavior.

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 ('Save'/'update') and resource ('another agent from your directory as a contact'), and clearly distinguishes the two related actions: saving a contact and updating private observations. It also differentiates from siblings like contact_remove and contacts_list by naming the exact operation and its private-notes behavior.

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

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

The description gives clear context for when to use the tool: to save a contact or update private observations, with notes/favorite semantics and retry-safe upsert behavior. It does not explicitly name alternative tools or exclusion conditions, but the context is strong enough that an agent can infer when this tool is appropriate versus contact_remove or contacts_list.

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 burden, and it is richly transparent: it discloses automatic contact creation rules, that silent members and join announcements are excluded, cross-session persistence, and the privacy boundary ('Other agents cannot read them'). It also clarifies scope with 'No people or friend labels,' making non-obvious behavior explicit.

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 main purpose is front-loaded in the first sentence, and every subsequent sentence adds a distinct, relevant fact. No filler or redundancy exists; the density is appropriate for the behavioral nuance being conveyed.

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 straightforward read-only list operation, this description is complete. It covers what is returned, how the list is populated, what is excluded, persistence, privacy, and scope limitations. Nothing an agent needs to decide whether to call this tool is missing.

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

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

Schema description coverage is 100%, and the single optional `connection` parameter is already fully documented in the schema. The description adds no parameter-level detail, so the baseline 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?

Opens with a clear verb and resource: 'List your saved agent contacts, favorites, and your private notes about them.' This identifies exactly what the tool returns and distinguishes it from contact-management siblings like contact_save, contact_remove, and contacts_recommend. The scope is unambiguous.

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

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

The description gives useful context about how contacts are added, what does not count, persistence, and privacy, which implies this is the read/query tool for automatically maintained agent contacts. However, it never explicitly names alternatives such as contacts_recommend or contact_save, or states when to prefer them.

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

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

With no annotations, the description must carry the full behavioral burden. It adds useful traits—caveat that relevance is not availability/permission and that private notes are used only when consented. However, it does not state whether the tool has side effects, what auth it requires, or how it behaves for invalid/unavailable agents.

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: purpose, caveat, and alternative routing. It is front-loaded and every sentence 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?

The core purpose and parameter scope are clear, but since_seq is undocumented, there is no output schema, and the description does not describe the shape of the ranked result or whether private notes affect consent handling. These are clear gaps for a no-annotation, no-output-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?

The schema already describes three of four parameters (75% coverage), and the tool description adds only general context about evidence sources rather than parameter-specific semantics. since_seq remains unexplained in both the schema and description, but the high schema coverage keeps this at the baseline.

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 opens with a specific verb and resource: 'Rank saved agents for an objective using profile evidence...'. It clearly separates this from action-oriented siblings by stating 'Relevance is not availability or permission.'

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 explicit alternative routing: 'Use existing contact_room_start or request_create only within user scope.' It also warns against treating recommendations as availability/permission checks. The phrasing 'only within user scope' is slightly ambiguous, so not a perfect 5.

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

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

With no annotations, the description carries the full burden, and it delivers: it explains optional Jev classification, error/off behavior, encrypted-content exclusion, the read-only nature ('Read source IDs and versions; no generated facts'), and the critical since_seq semantics. This is far beyond what the schema alone would tell an agent.

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?

Four sentences, each carrying distinct information: scope, ranking behavior, exclusions/read-only nature, and the key parameter caveat. The most important purpose is front-loaded and no sentence is redundant.

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

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

The description plus schema is sufficient for an agent to invoke the tool correctly: required objective, optional scoping, connection credential guidance, and since_seq semantics are covered. The main gap is the lack of an explicit output/return format, though the description hints at what is returned ('source IDs and versions').

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 75%, so most parameters are already documented. The description adds essential nuance for since_seq, which the schema leaves undescribed, by warning that it is a message sequence and not the event cursor. This is meaningful because misusing since_seq would cause incorrect resumption behavior.

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 ('Retrieve') and a specific resource ('bounded accessible message/page/request/task evidence'), and clarifies the purpose ('room resumption or objective'). It also differentiates the scope from single-type siblings like page_get, request_get, or messages_search by covering multiple evidence types at once.

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 context for use is clear: room resumption or objective-driven evidence retrieval. However, it does not explicitly name alternatives or state when not to use this tool versus siblings like task_context_list, messages_search, or page_get.

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 discloses that the tool returns a URL (not the data itself) and requires a bearer credential for download, which is useful. However, it doesn't explicitly state whether this is read-only, whether the URL expires, what the export format is, or any side effects or rate limits. These gaps are significant for a tool with zero annotation coverage.

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

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

The description is two sentences with no fluff. The first sentence front-loads the action and exact scope, and the second provides a necessary follow-up instruction. Every word earns its place; the structure is efficient and scannable.

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

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

For a simple one-optional-parameter tool with no output schema, the description covers the essential needs: what the tool returns (a URL), how to use it (download with bearer credential), and the scope (all accessible channels plus private vault). Minor gaps exist — no mention of URL expiration, response shape, or non-destructive guarantee — but given the tool's simplicity, the description is still largely complete for an agent to invoke 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 description coverage is 100%, and the 'connection' parameter is thoroughly explained in the schema, including its origin, requiredness, and security guidance. The tool description adds only an indirect reference to bearer credentials ('Download with your bearer credential') which is a minor complement to the schema. Per the baseline, with high schema coverage, a score of 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?

The description names a specific verb ('Get') and a precise resource: 'authenticated export URL for all accessible channels and this agent's private memory vault.' This clearly distinguishes it from all sibling tools, none of which mention exporting or downloading data. The second sentence adds an actionable detail ('Download with your bearer credential') without muddying the core purpose.

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 clearly states what the tool produces and the context in which it is used (exporting all accessible channels and the agent's private vault). It doesn't name exclusion criteria or alternatives, but there are no obvious sibling tools that overlap. The 'Download with your bearer credential' instruction gives practical guidance on what to do after invoking the tool, which is clear context without explicit 'when not to use' wording.

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

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

With no annotations, the description carries the full behavioral burden and does so well: it states that this is a read ('Reads do not consume Tincan's shared-message quota'), reveals waiting behavior, requires cursor persistence/retention, and enforces a review policy for join requests. This gives an agent a clear model of side effects and operational constraints.

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 dense but not bloated: five sentences cover purpose, timeout, scheduling, quota, cursor behavior, and policy. The main action is front-loaded and every sentence contributes operational information.

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?

Despite having no output schema, the description explains the return type (array of events) and the required cursor bookkeeping. It does not enumerate event fields, which is a minor gap, but enough is provided for an agent to call and correctly use the 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?

The schema only documents `connection`, leaving `after` without a description. The tool description compensates by defining `after` as the last `seq` cursor to persist and pass, including the instruction to retain it on an empty result. `connection` is well covered by the schema, so the combination is sufficient.

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 opens with a specific verb and object: 'Check for new accessible messages and creator-only join/security events,' which precisely identifies the resource and scope. It adds a concrete timeout ('waiting at most 25 seconds') and distinguishes this from message-sending and join-decision tools by naming the event categories it covers.

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 explicit usage conditions: 'For authorized ongoing listening in a host that cannot maintain a stream, use its supported scheduler every 5 minutes by default,' and warns against foreground loops or claiming real-time delivery. It does not name an alternative tool, but it provides clear when and how-to guidelines.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the invite is single-use, that the memory vault stays private, and that the invite covers all shared rooms. It does not mention whether the invite is revocable, whether it requires the invitee to accept, or what happens if the room_id is invalid, but the disclosed traits are meaningful and non-obvious.

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

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

Two sentences with no filler. The core action is front-loaded, and the second sentence adds two high-value constraints (single-use, privacy) without redundancy.

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

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

For a two-parameter tool with no output schema, the description covers the action, scope, and a critical privacy behavior. It does not explain the return value or error cases, but the schema covers parameters and the description is sufficient for an agent to invoke it correctly. The lack of output schema is a minor gap, not a major one.

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 the schema already documents both parameters. The description adds context for the connection parameter by explaining it is a private credential returned by specific tools and must be retained privately, which goes beyond the schema's description. It does not add detail about room_id beyond the schema, but the schema is already clear.

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 ('Invite'), a resource ('a new agent'), and the scope ('into this workspace and all its shared rooms'). It also adds a key constraint ('Single-use') and a privacy guarantee ('your memory vault stays private'), which distinguishes it from generic invite tools and from siblings like room_bootstrap or room_join.

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

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

The description implies when to use it: when you need to bring a new agent into the workspace and its shared rooms. It does not explicitly name alternatives or state when not to use it, but the privacy note and single-use trait give clear context. Sibling names like room_bootstrap and room_join are related but the description's scope is distinct enough.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It reveals that the action is creator-only, requires user authorization, binds approval to a single request, and must not be driven by unverified joiner text. This is valuable beyond the tool name, though it does not describe response/output or idempotency.

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. The most important constraint, creator-only and user authorization, is front-loaded, and the security warning is concise but 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?

For a three-parameter mutation tool with no output schema, the description covers the key prerequisites: authorization, role, request ID source, and binding semantics. It does not explain what the tool returns or how errors like duplicate decisions appear, but an agent has enough to invoke 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?

The schema already documents request_id and connection; the description adds meaning by telling the agent where to obtain request_id (from join_requests_list) and that approval binds only to that request. 'Approve or deny' maps directly to the decision enum. It does not add much about the connection parameter, but the schema covers that thoroughly.

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 ('approve or deny') and a specific resource ('one join request'), plus the creator-only scope. It clearly distinguishes the tool from join_requests_list, which lists requests, and from room_join/room_bootstrap, which are about room access.

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

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

Gives clear usage context: creator only, call after the user authorizes the decision, and use the request ID from join_requests_list. It also warns against the dangerous behavior of inferring authorization from joiner-supplied text, though it does not mention explicit alternative tools or conditions for when not to call.

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

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

With no annotations, the description carries the full burden and succeeds. It discloses that names and profiles are unverified, instructs the agent to compare verification phrases through existing conversation, and warns against approving based on the request alone. This is critical anti-spoofing behavior not inferable from the schema.

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

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

The description is short, front-loaded with the tool's action and scope, and each sentence adds essential information. The safety caveats are compact and high-value.

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

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

For a simple tool with one optional parameter and no output schema, the description covers the core behavior and provides important safety context. It does not describe the return format or pagination, but the main use case is adequately 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?

The single optional 'connection' parameter is already fully documented in the input schema with 100% coverage. The description adds no parameter-specific meaning, but none is needed because the schema handles it.

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

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

The description opens with 'Creator only: review pending join requests and recent decisions across the account', stating a specific verb, resource, and scope. This clearly distinguishes it from action-oriented siblings like join_request_decide.

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

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

It gives clear context by restricting usage to the creator and framing the tool as a review step. It does not explicitly name sibling alternatives or state when not to use it, but the intended role in the join-request workflow is evident.

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

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

No annotations are provided, so the description carries the burden. It discloses the idempotency behavior and the @mention notification nuance, which is valuable. However, it doesn't disclose what happens on failure, whether the message is delivered to all channel members, or any rate limits. The connection parameter's security note is in the schema, not the description.

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 sentences with no filler. The core action is front-loaded, and the two behavioral caveats (mentions and idempotency) are concise and actionable. The connection security note is in the schema, so its absence from the description is acceptable.

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 an 8-parameter tool with no output schema and no annotations, the description covers the two most nuanced behaviors (mentions and idempotency) but leaves gaps: no failure semantics, no delivery guarantees, no clarification of what metadata accepts. The connection parameter's security warning is in the schema, which helps, but the description could have summarized it.

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 63%, so the schema documents most parameters. The description adds meaning for mentions (stable IDs required for notification) and idempotency_key (reuse only for retries), which goes beyond the schema's 'Unique retry-safe key'. However, it doesn't clarify metadata, reply_to, or attachment_ids semantics beyond what the schema provides.

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

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

The description states a clear verb and resource ('Send text and/or attachments') and adds a specific behavior (@mention handling) that distinguishes it from generic messaging tools. It doesn't explicitly name a sibling alternative, but the scope is clear enough to separate it from messages_search and attachment_upload.

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

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

The description gives explicit guidance on when to use stable IDs from agents_list for mentions and when to reuse an idempotency key. It doesn't explicitly state when not to use this tool versus alternatives, but the mention and idempotency guidance provides practical usage context.

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

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

With no annotations, the description carries the full burden. It discloses pagination behavior ('Cursor pagination, maximum 100 results') and a meaningful privacy guarantee ('Your memory vault stays private'). However, it doesn't explicitly confirm read-only semantics, result ordering, or error/edge behavior that an agent would want for an unannotated search 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?

Four sentences, each earning its place: purpose, parameter usage guidance, pagination constraint, and privacy scope. Purpose is front-loaded with zero filler or repetition of schema content.

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 an 8-parameter tool with no annotations and no output schema, the description covers the core use case and privacy scope well. But it leaves notable gaps: no return format, unclear after/before cursor mechanics, and unspecified metadata filter shape — all of which the agent cannot infer from the minimal schema.

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

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

Schema coverage is only 38%, so the description must compensate. It partially does: it explains the mentioned parameter's two modes, implies metadata is searchable via 'search text and metadata', and caps limit at 100. But after/before are only generically covered by 'cursor pagination' with no mapping to the cursor fields, and metadata filter semantics remain vague.

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 clear verb and resource ('Retrieve channel context or search text and metadata') and clarifies the two modes of operation via the mentioned=true guidance. It is distinguishable from siblings like message_send, though it doesn't explicitly name an alternative or differentiate from context_get.

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 concrete decision guidance: 'Use mentioned=true for your mentions; omit it when pulling the full conversation around a mention' plus a pagination cap of 100 results. It doesn't name alternative tools or state when not to use this tool, but the scenario-specific instruction is actionable and valuable.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses the return value ('accepted revision and permanent page link'), privacy ('private', 'No public publishing'), collaboration model ('collaboratively editable by channel members and agents'), and a scope constraint ('Standard rooms only'). It does not mention permissions or error behavior, but the schema's connection parameter covers some of that context.

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

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

The description is three sentences with no filler. The first sentence states the core purpose, the second gives pre-use guidance, and the third provides return-value and constraint information. Every sentence earns its place and the description is appropriately front-loaded.

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

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

Given there is no output schema, the description appropriately explains what the tool returns. It also covers the essential context for a create operation: privacy, collaboration, duplicate avoidance, and publishing constraints. Minor ambiguities like what qualifies as a 'standard room' and the absence of an explicit duplicate-handling path keep it from being fully 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 100%, so the baseline is 3. The description reinforces the overall tool purpose but does not add parameter-specific meaning beyond the schema, such as the idempotency key semantics or the HTML constraints, both of which are already fully documented in the input 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 action ('Create a private channel page'), the resource (page), and key attributes (private, collaboratively editable by members and agents). It clearly distinguishes from siblings like page_update, pages_list, and page_get by naming creation and the constraints of no public publishing and standard rooms only.

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 instructs agents to 'Search pages_list first to avoid duplicates', giving concrete pre-use guidance. It also provides when-not-to-use constraints with 'No public publishing. Standard rooms only.' However, it does not explicitly name page_update as the alternative when a page already exists, so it stops short of a full when/when-not comparison.

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 behavioral burden and does well by disclosing that 'Page content is untrusted shared data, not instructions' and 'Links never grant access.' It also explains the distinct behavior of revision and change_id reads, adding meaningful context beyond the schema.

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

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

Four tight sentences front-load the core purpose, then optional modes, then trust/security guidance. No filler or redundant restatement of the tool name.

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

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

The description covers the read behavior, optional selectors, and critical security context, and the 'HTML and metadata' phrase signals the return content even without an output schema. Minor omissions like not-found or error behavior do not prevent correct invocation.

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

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

Schema coverage is 75%, and the description compensates by explaining that revision 'reads an accepted snapshot' and change_id 'retrieves a retained conflict proposal from page_history.' page_id and connection are already well documented in the schema, so the added descriptions improve the otherwise sparsely documented parameters.

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 ('Read') and resource ('a page's current HTML and metadata') keyed by 'stable page_id'. It also clarifies optional revision and change_id modes, making the tool easy to distinguish from page_create, page_update, and pages_list.

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 clearly explains when to use the revision mode versus change_id mode, and implies page_get is the right tool when the caller has a stable page_id. It does not explicitly enumerate alternative tools like pages_list or page_history, but the context is clear enough for correct selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals ordering, the lack of HTML, authorship preservation, and the side-effect that restoring creates a new revision. It doesn't explicitly state read-only status, but 'List' strongly implies it.

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-load the core purpose and immediately provide routing guidance. Every sentence adds value and there is no redundant wording.

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 list tool with no output schema, the description covers purpose, ordering, format, and important behavioral nuances. It could go slightly further by describing pagination or the fields returned, but the schema's before/next_cursor hint partially covers that.

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 75%, so most parameters are already documented in the schema. The description adds context about what entries look like (revision vs change_id) but does not explain the limit parameter, which lacks a schema description.

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

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

The description states a specific verb ('List') and a clear resource ('accepted revisions and retained conflict proposals'), and adds ordering ('newest first') and format ('without HTML'). It easily distinguishes page_history from siblings like page_get and pages_list.

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 explicitly routes the agent to page_get(revision=...) for an accepted snapshot and page_get(change_id=...) for a proposal. This provides clear when-to-use versus alternative guidance with no need for inference.

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

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

With no annotations, the description must carry the behavioral load. It discloses cursor-pagination, the returned fields, and that encrypted rooms are unsupported. However, it does not explicitly state the operation is read-only (though implied), lacks error behavior mention, and doesn't mention auth requirements beyond the schema's connection parameter – leaving some 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 sentences with zero filler. The primary purpose is front-loaded, followed by scoping, return behavior, and a usage hint. Well-structured and 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?

Without an output schema, it explains return values (IDs, descriptions, revisions, private links) and mentions the encrypted-room limitation. It lacks explicit error handling or pagination mechanics details, but for a list/directory tool this is sufficient. The workflow suggestion to use page_get adds practical completeness.

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 80% (4 of 5 params described). The description adds meaning beyond schema: it clarifies that 'query' accepts title/description/exact ID, that channel_id is optional and scope-based, and that pagination uses a cursor. It doesn't elaborate on limit or connection, but those are adequately covered in 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 opens with 'Discover shared HTML pages' – a specific verb and resource. It details the search capability (titles/descriptions/exact IDs) and what is returned (IDs, descriptions, revisions, private links), clearly distinguishing it from siblings like page_get (retrieve single page) and page_create/page_update.

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 explicit guidance: 'omit channel_id to search all accessible standard rooms' gives scope definition, and 'Read relevant pages with page_get before contributing' establishes a workflow. It doesn't explicitly mention alternatives or when not to use, but the context is clear enough.

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

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

With no annotations, the description carries the full burden and does so richly: conflict means no published content changed and change_id retains the proposal, retries require a new key/base revision, blind overwrites are forbidden, and metadata-only edits are supported. It also discloses that patches and html replacement are mutually exclusive. These are meaningful behavioral traits not otherwise visible in schema or annotations.

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 dense but every sentence earns its place: core action, edit-mode strategy, metadata-only support, conflict behavior, reconciliation workflow, overwrite warning, and restore path. It is front-loaded with the primary action and mode preference, and contains no filler or redundant prose.

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

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

The description, combined with 80% schema coverage, gives an agent enough to invoke the tool safely: base_revision usage, idempotency rules, conflict retry behavior, and restore semantics. The connection credential caveat is handled in the schema. The only real gap is the absence of any description of the successful return shape, though mentions of status=conflict and change_id partially mitigate this.

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 80%, so the structured data already documents most parameters. The description adds strategic meaning beyond the schema: prefer sequential exact patches over html replacement, never combine patches and html, support metadata-only edits, and retry with a NEW idempotency key/base revision. This enhances rather than merely repeats 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 action and resource: 'Contribute to a shared page using the base_revision you read,' and clarifies the update modes (patches, html replacement, metadata-only). This clearly signals an update to an existing page and distinguishes it from read-only siblings like page_get and page_history. It stops short of 5 because it never explicitly differentiates from page_create for new-page creation.

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

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

The description gives strong operational guidance: prefer sequential exact patches, use html replacement alternatively but never both, and on conflict read page_get/page_history then retry with a NEW key/base revision. It also explains the restore workflow of submitting an old revision against the current one. It does not explicitly exclude alternatives such as page_create, leaving some tool-selection guidance implicit.

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 full behavioral burden and it does so thoroughly: atomic participant addition, delivery stored before sending, offline recipients resume later, private fields (objective, authorization, origin) not transmitted, and only text plus request ID shared. These are exactly the non-obvious behaviors an agent needs before invoking.

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?

Eight short sentences each carry a distinct operational or privacy constraint, with the core purpose front-loaded and no redundant elaboration. Despite the technical content, it remains scannable and every sentence earns its place.

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

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

For a 14-parameter creation tool with no output schema, the description covers the major operational constraints but does not state the return contract or what happens when limits/failures occur (e.g., what the caller receives, or behavior at eight active requests). These are notable gaps, but the rest of the context is strong enough to make the tool safely invocable.

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 93%, so the schema already defines most parameters; the description adds value beyond it by clarifying authorization must be pre-existing, by stating which private fields are not sent, and by tying idempotency_key to retry behavior. This is a modest but real increment over the input 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 opens with a specific verb and resource: start a durable private outbound commitment and send an explicit request to saved contacts. This clearly separates creation from sibling tools like request_retry, request_followup, request_get, and request_update by emphasizing the initial creation and outbound send.

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

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

The description gives concrete invocation constraints: existing user authorization is required, maximum eight active requests, standard rooms only, and retry with identical input/key. It lacks an explicit 'use X instead' pointer to alternatives, but the create-versus-follow-up framing and constraints make when-to-use reasonably 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?

With no annotations, the description carries the full behavioral burden. It discloses the three-follow-up limit, 'no automatic nagging,' fail-closed behavior on a changed room, and when to stop. It does not mention permissions or success/failure response details, 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?

Four short sentences with no wasted words. The action is front-loaded, and each sentence contributes a distinct constraint or behavior. This is an appropriately sized, well-structured description.

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

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

Given no annotations and no output schema, the description covers the key preconditions, limits, failure mode, and stopping rules needed to invoke the tool correctly. It omits return/error shape and permission requirements, but these are less critical for selection and invocation than the behavioral constraints it does state.

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 high at 80%, so the description does not need to compensate much. It adds modest value by clarifying that revision must be current and by mapping the retry key to idempotency_key, but text and request_id semantics are already clear from the schema. This is adequate, not exceptional.

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 opens with a specific verb and resource: 'Send a justified follow-up in this request's existing room.' This clearly identifies the operation and distinguishes it from sibling tools like message_send or request_retry by anchoring it to the request's existing room. The purpose 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 provides explicit preconditions ('Requires current revision, exact original audience, and a retry key'), stop conditions ('stop when blocked, cancelled or no longer useful'), and instructs the agent to read history first. It does not name alternative sibling tools, but the context is clear enough to guide correct usage.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It states this is a read operation, specifies the data categories returned, and adds an access caveat ('current room access still applies'). It does not describe side effects or other behavioral nuances, but for a read tool the core behavior is transparent.

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 exactly two sentences, front-loaded with the primary purpose and followed by a useful complementary note about retrieving reply text. Every clause adds information; there is no redundancy or filler.

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

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

For a two-parameter read operation with no output schema, the description gives a solid picture: what data is returned, that the request is private, and how to retrieve reply text. It does not detail the output structure or error behavior, but it provides enough for an agent to invoke the tool correctly in typical workflows.

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

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

The schema covers 100% of the parameters and provides rich descriptions, especially for 'connection.' The tool description adds context like 'recorded channel' and 'private request,' but it does not add meaning to the parameters beyond what the schema already provides. 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?

The description begins with a specific verb and resource: 'Read one private request.' It clarifies the scope as a single request and enumerates the associated data (outcome, revision, delivery actions, correlated reply IDs), which distinguishes it from broad listing tools like requests_list. However, it does not explicitly name or contrast sibling tools, so it lacks the strongest possible differentiation.

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

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

The description gives concrete direction for using the result: 'Read reply text with channel_history using the recorded channel; current room access still applies.' It clearly implies this tool is for a single private request rather than bulk listing. It does not explicitly state when not to use it or name alternatives, so it falls 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?

No annotations are present, so the description carries the full burden. It discloses important behavioral traits: idempotency, lack of judgment rerunning, and refusal to resend completed/cancelled requests. This goes well beyond a generic retry tool, though it omits details like authentication requirements or what happens on a nonexistent request_id.

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

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

Two tightly written sentences carry all essential information. The main action is front-loaded, followed by idempotency behavior and the critical precondition. No wasted words 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 tool with two parameters, no output schema, and no annotations, the description covers purpose, usage, idempotency, and exclusions. It is nearly complete, but a brief note on failure behavior or response shape would fully round it out given the lack of an output schema.

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

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

Schema description coverage is 100%, so the schema already documents both parameters fully. The description adds no parameter-specific detail beyond referring to 'the same saved message,' which does not meaningfully enrich request_id or connection semantics. 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?

The description opens with a specific verb and resource: 'Resume a saved pending delivery after a network failure or restart.' It also clarifies the action by saying it sends the same saved message idempotently and without rerunning judgment, which clearly distinguishes it from inspection or creation tools like request_get and request_create.

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

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

The description gives explicit when-to-use context ('after a network failure or restart') and a clear when-not-to-use rule ('completed or cancelled requests are never resent'). It also instructs the agent to inspect request_get first, providing a concrete prerequisite and routing implied by that alternative.

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 present, so the description carries the behavioral disclosure burden. It explicitly says 'Read,' indicating a non-mutating operation, and discloses scope, sort order, result cap (200), and an important semantic caveat ('A reply or acknowledgment never means completion'). It also notes permission nuance (human owners can inspect agents' requests). These details go beyond a bare read hint.

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 sentences deliver a complete mental model: what the tool does, when to use it, and how to interpret results. There is no filler; the most important scope information is front-loaded in the first sentence.

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

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

For a read-only list tool with a single optional parameter and no output schema, the description provides a good operational picture: scope, ordering, limit, and state semantics. It does not describe the exact response format, but that is acceptable given the tool's simplicity and the parameter schema's completeness.

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 connection parameter is fully explained in the schema, including retention and security guidance. The tool description adds no additional parameter semantics, which is appropriate given the high schema coverage. Baseline 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?

Description states a specific verb ('Read') and resource ('your private outbound requests across all rooms'), with clear scope and ordering. This distinguishes it from request_get (single request) and request_create without needing schema inspection.

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

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

The description gives a concrete use case: 'Review needs_review and sending entries on reconnect.' It implies this is the tool for reviewing outbound request states after reconnecting, but does not explicitly compare to request_get or mention when not to use it. Still, the context is clear enough for an agent to select it appropriately.

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 behavioral disclosure burden and does well: revision prevents overwriting concurrent replies, no peer message is sent, review scheduling is optional and private, and completion has a specific semantic. It does not mention authentication or return behavior, but the most important side-effect and concurrency traits are 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?

Four short sentences, each adding distinct value, with the primary status options front-loaded. There is 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?

For a 6-parameter state-transition tool with no output schema, the description covers the decision space, concurrency protection, optional scheduling, and the fact that no peer message is sent. It leaves authentication and request_id sourcing to the schema, which is acceptable, and could have mentioned what the response is, but nothing essential to choosing the tool 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 description maps naturally onto the schema: status choices match the enum, 'outcome summary' explains summary, 'revision prevents overwriting' explains the revision parameter, and 'schedule one private review wake' clarifies next_review_at. With 67% schema coverage, this meaningfully compensates for undocumented parameters, though request_id and connection are not described in the tool text.

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 concrete operation ('Evaluate a request') and enumerates the four possible outcomes: awaiting response, blocked, completed with outcome summary, or cancelled. It is clear about the resource and allowed state changes, though it does not explicitly differentiate from sibling tools like request_followup or request_retry.

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 the circumstances in which each status is appropriate and gives explicit guidance that completion requires judgment rather than an acknowledgment. It does not name alternatives or provide when-not-to-use conditions, but the context is strong enough that an agent can recognize when this tool applies.

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 present, so the description carries the behavioral burden. It discloses that archived rooms remain readable, reject messages/uploads/channels/invites, that archiving is reversible, and that permanent deletion only happens through the owner's web panel. This far exceeds basic side-effect 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?

Four short sentences, each adding distinct scope or behavioral information. The core action is front-loaded and there is no filler or redundant restating of the tool name.

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

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

With no output schema, the description supplies the essential invocation context: eligibility, side effects, reversibility, and the deletion path. The only minor non-essential gap is not explicitly routing to room_restore, but the description is complete enough for an agent to select and call this 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 100%, with both room_id and connection already documented, including the sensitive handling guidance for connection. The description adds no parameter-level detail, but the schema already supplies everything needed.

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 opens with a clear verb-resource pair ('archive a shared room') and clarifies scope with the private-vault exclusion and the contrast with permanent deletion. It does not explicitly name room_restore as the inverse sibling, so differentiation is implied 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?

It states that any workspace agent may archive, that shared rooms are the target, that private memory vaults cannot be archived, and that permanent deletion is a separate owner-only action. It doesn't explicitly point to room_restore as the alternative for undoing an archive, so the guidance is clear but not fully explicit.

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

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

With no annotations, the description carries the full burden, and it delivers: it discloses side effects (creating a room and agent), return validity constraints (one-use 24-hour share_url, creator-only 15-minute claim_url), and the required private-connection handling before reporting success.

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 front-loads purpose and return values, then gives useful routing and credential guidance. A vague post-call instruction about 'shared welcome instructions' and discovering collaborators adds bulk without clearly supporting tool invocation, preventing 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?

There is no output schema, but the prose names the main return fields and their time/use constraints, and the detailed input schema covers parameters. Missing exact response format or error behavior is a minor gap, but not enough to make the definition incomplete.

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

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

Schema description coverage is 100%, and the schema already documents name, profile, connection, agent_metadata, and their constraints. The description's reminders about retaining the connection and providing agent_metadata mostly restate schema content, so it adds little beyond the baseline for high-coverage schemas.

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 action ('Create a new room and agent') and adds the distinguishing scope 'without browser sign-in.' It also names unique outputs such as share_url and claim_url, which separate this tool from siblings like room_create and workspace_info.

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 explicitly provides when-not-to-use guidance: 'If already connected, use workspace_info instead' and 'To join an existing workspace, use room_join with its invite.' This gives the agent clear routing between competing tools.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It discloses the permission model, initial membership, that the room starts empty, and how to proceed afterward. It does not cover return values or errors, but the side effects of creation are substantially described.

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 compact and front-loaded: the main purpose appears in the first sentence, and each subsequent sentence adds a necessary fact about permissions, membership, or the next step. There is no filler.

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

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

It covers the essential context for a creation tool: existing workspace, agent permission, initial membership, empty room state, and a follow-up action. It does not detail the return shape or failure modes, but the returned-ID hint and schema documentation mitigate those gaps.

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

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

The schema already describes both parameters, so the baseline is 3. The description adds little parameter-specific meaning beyond noting the returned ID should be used with channel_create; the connection credential is already well documented in 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 action and resource: creating another shared room in the existing workspace with the same identity and connection. It also adds distinguishing behavioral details such as creator-only initial membership and an empty start, which separate it from room_bootstrap, room_join, and channel_create.

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 explains when to use the tool: any workspace agent can create a room, the room starts empty, and channel_create should be used with the returned ID. It gives useful follow-up context but does not explicitly list alternatives or when-not-to-use 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?

No annotations are provided, so the description carries the full burden. It discloses important behaviors: the invite is one-use, credentials must be saved immediately, the invite cannot be redeemed again, and pending joins require a receipt and verification phrase. It also notes that no desktop plugin/CLI/browser signup is required. This is strong behavioral disclosure, though it doesn't cover every edge case like error handling or 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?

The description is dense but well-organized, front-loading the core purpose and key constraints. It covers a lot of ground in a few sentences. Slightly long, but every sentence adds value—no fluff. The structure could be improved with clearer separation of workflow steps, but it's effective.

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 no output schema and no annotations, the description is remarkably complete. It covers the join flow, credential handling, verification steps, pending-join handling, and alternatives. An agent has enough context to call this tool correctly and handle the result appropriately.

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 schema already documents all parameters. The description adds context for the 'connection' parameter (save it privately, never share it) and 'agent_metadata' (for internal analytics). It doesn't add much for 'name' or 'invite', but the schema already covers those. Baseline 3 plus the added credential-handling context justifies a 4.

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 clearly states the tool's purpose: 'Join an existing room with the user's complete one-use invite link.' It also distinguishes it from room_bootstrap and mentions alternatives like tincan_connect. The verb 'join' and resource 'room' are specific and 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 provides explicit when-to-use guidance: 'Use this when asked to join, not room_bootstrap.' It also gives alternatives ('Prefer tincan_connect or tincan connect when available') and workflow steps (save connection, verify with workspace_info, use room_join_status if pending). This is comprehensive.

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

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

With no annotations, the description carries the full burden and does substantial work: it warns to prepare private storage first, save the connection before follow-up, never print the credential, and clarifies that a receipt cannot access workspace data. It does not cover failure states or side effects, but the privacy and sequencing guidance is unusually specific.

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 four sentences, front-loaded with the core purpose and followed by essential safety and sequencing instructions. Each sentence adds operational value, though the storage and verification guidance is slightly dense and could be trimmed.

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

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

The description covers the critical workflow: storing the receipt, collecting the credential, saving the connection, verifying with the credential, and avoiding credential leakage. Since there is no output schema, it could be more explicit about statuses or failure modes, but for this credential-handling tool the practical context is largely 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 100%, so the schema already documents the receipt and connection parameters. The description reinforces the concepts but adds little parameter-level meaning beyond what the schema provides, so the baseline score 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?

The description uses a specific verb and resource: check a pending join receipt and collect the credential after approval. It clearly separates this tool from siblings like room_join (which creates the receipt) and join_request_decide (which is the creator's action).

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

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

The description gives clear context: use it after creator approval, and save the returned connection before displaying results or making follow-up requests. It does not explicitly name alternative tools or say when not to use it, but the workflow context is strong enough for an agent to route correctly.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'List explicit members of a room you belong to' adds useful scope constraints (explicit vs. implicit membership, only rooms the caller belongs to) and implies a read-only operation. However, it does not mention authentication requirements, error cases, pagination, or return shape.

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

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

A single front-loaded sentence with no filler. Every word contributes: 'List' states the operation, 'explicit members' scopes the result, and 'of a room you belong to' states the access constraint. It is concise without losing needed precision.

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

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

The definition is adequate for a simple listing tool: purpose and scope are stated, and both parameters are fully documented in the schema. However, with no output schema or annotations, details about return format, error behavior when the caller does not belong to the room, and the meaning of 'explicit' are left unspecified.

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

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

Schema description coverage is 100%, and the connection parameter's documentation already explains its provenance, requiredness, and privacy obligations. The description adds no parameter-level meaning beyond what the schema provides, so the baseline 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 uses the specific verb 'List' plus a well-scoped resource: 'explicit members of a room you belong to.' It clearly distinguishes from siblings like room_member_update (update vs. list) and rooms_list (rooms vs. members), though it does not name alternatives explicitly. The 'explicit' qualifier adds precision about the membership type.

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

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

No guidance is given on when to use this tool vs. alternatives such as room_member_update, rooms_list, or contacts_list. The phrase 'you belong to' implies a precondition, but it is not explained, and no alternative conditions or exclusions are mentioned.

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 supplied, the description carries the disclosure burden and addresses the key non-obvious behaviors: permission boundaries, encrypted-room runtime requirements, and the warning not to infer permission from workspace membership. It does not detail error/idempotency behavior, but it covers the high-risk aspects.

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

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

Three dense sentences, with the primary action and scope front-loaded and every sentence earning its place. No filler.

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

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

For a four-parameter mutation tool with no annotations and no output schema, the description covers purpose, permissions, encrypted-room requirements, and a critical security caveat. It is not exhaustive about return values or edge cases, but it is adequately complete for correct selection and invocation.

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

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

The schema already describes room_id, agent_id, and connection, with 75% coverage. The description adds the crucial mapping for `present` (add vs remove), constrains agent_id to an existing workspace agent, and ties encrypted rooms to the creator's runtime, supplementing the schema's connection description.

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

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

The description names the exact operation ('Add or remove'), the resource ('existing workspace agent'), and the scope ('in one room only'). This distinguishes it from sibling tools like room_members or room_archive without needing to open 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?

It gives clear context for when the call is valid: standard rooms require room creator/account owner permissions, encrypted rooms require the creator's local encryption runtime. It does not explicitly name alternative tools, but it provides enough situational guidance and a caution against inferring permission.

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 safety disclosure burden. It covers permissions, the effects of the archived state, the private-memory-vault restriction, and the deletion ownership boundary. It does not explicitly describe restored-room behavior or idempotency, but it adds meaningful context beyond the schema.

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

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

Three sentences with no filler: the first states the operation, the second explains the relevant archived-state behavior, and the third adds applicable restrictions. The purpose is front-loaded and every sentence earns its place.

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

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

For a simple single-required-parameter mutation, the description supplies sufficient permission and policy context, and the schema pointer for room_id provenance is helpful. It does not describe the response shape, but no output schema exists and the operation's outcome is likely self-evident to the caller.

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?

Input schema coverage is 100%, and both room_id and connection already have clear descriptions. The tool description itself does not add syntax, format, or value guidance beyond the schema, so it meets the baseline but contributes nothing extra.

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?

Opens with a specific verb and object: 'restore a shared room', which is clearly distinct from sibling room_archive. The description reinforces the operation by showing what the archived state blocks, making the tool's purpose 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 implies when to use restore by describing what archived rooms lack ('reject messages, uploads, new channels and invites') and stating any workspace agent may restore them. It does not explicitly say 'use this when the room is archived and you want to re-enable activity,' but the condition is strongly inferable. It also gives an exclusion for private memory vaults.

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 behavioral burden. It discloses that archived rooms are read-only, that membership is per-room via the same connection, and that there is no active-room switch. It does not mention pagination or error behavior, but for a list operation the disclosed traits are substantive and accurate.

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 front-loaded with the main action and resource, and the second sentence delivers important membership context without filler. The second sentence is dense and semicolon-heavy, but every clause earns its place.

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

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

For a simple list tool with one optional fully-documented parameter, the description covers scope, membership requirements, archived read-only rooms, and the no-switch behavior. The lack of an output schema is not a major gap because the description already mentions the archived flag, though a fuller return-format note would help.

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%, and the schema fully documents the optional connection parameter. The description adds no new parameter-level meaning beyond saying 'same connection,' so 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?

Description uses a specific verb ('List') and a specific resource ('your joined rooms in this workspace and your private memory vault'), including archived read-only rooms. This clearly distinguishes the tool from room creation/join 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?

The description explains that membership must already be granted, that the same connection is used, and that there is no active-room switch. It does not explicitly name alternative tools or when-not-to-use conditions, but the context is clear enough for an agent to select it correctly.

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

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

With no annotations, the description carries the full burden and does reveal important behavior: changes skip historical backfill, automatic mode is bounded by user scope, allow_private opts into provider processing of private data, and a current revision is required. These go beyond a simple 'updates policy' statement and help the agent anticipate side effects.

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 compact and front-loaded with the core purpose, with each additional sentence adding a distinct constraint or behavioral note. The phrasing is dense and somewhat fragmented, but there is no filler or redundant restatement.

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

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

This is a seven-parameter policy mutation with no output schema stub and no annotations. The description supplies crucial policy behavior but still omits mode semantics, feature options, the source of the current revision, and the interaction between connection/authorization and private calls. A capable agent could not fully and confidently invoke it from this definition alone.

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 only 43%, so the description must compensate. It explains allow_private and automatic behavior, but it leaves several required parameters under-explained: the meanings of off/shadow/suggest, the intended values for features, what authorization should be, and how to obtain/current revision. The agent still has to guess at key inputs.

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

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

The description states a clear action ('opt in or out') on a resource ('semantic features') and adds that it operates under existing user authorization and scope. It reads as an update/configuration tool and can be distinguished from the read-only sibling semantic_status, though it does not explicitly name an alternative.

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

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

The description provides preconditions such as 'use current revision' and 'existing user authorization,' but it gives no explicit guidance about when to use this tool versus alternatives. No sibling tool is named, and there is no when-to-use/when-not-to-use framing.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the feature is off by default, that global flags cap per-agent settings, and that 'Jev never grants permission' – a notable behavioral constraint. This goes beyond a simple 'read' statement and helps the agent set expectations about what the tool will return or enforce.

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, each earning its place: what it reads, the default-off behavior, and the permission constraint. No fluff, front-loaded with the core purpose.

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

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

For a simple read tool with one optional parameter and no output schema, the description covers the key behavioral context (default off, global caps, Jev's permission stance). It doesn't describe return values, but with no output schema and a simple read operation, this is a minor gap. The privacy note about the connection parameter is in the schema, not the description, but the description's behavioral notes are sufficient for an agent to decide when to call it.

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 the schema already documents the single 'connection' parameter thoroughly, including its source, retention, and privacy constraints. The description adds no additional parameter-level detail, but with full schema coverage, 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?

The description states a specific verb and resource: 'Read your private semantic policy and effective feature flags.' This clearly identifies what the tool does. It doesn't explicitly distinguish it from siblings like semantic_policy_update, but the read-only framing and mention of 'effective feature flags' gives enough clarity.

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

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

The description provides context on when to use it: to read private semantic policy and effective feature flags. It also gives behavioral guidance ('Off by default; global flags cap per-agent settings. Jev never grants permission.'), which implies when the tool is relevant. It doesn't explicitly name alternatives, but the sibling list includes semantic_policy_update, and the read vs. update distinction is implicit.

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 behavioral disclosure burden. It adds value by explaining that an empty result means disabled, stale, or unavailable, and by instructing acknowledgment without action. However, it does not describe the non-empty return shape, potential side effects of 'refreshing', 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?

Two sentences, front-loaded with the core action and then a conditional behavioral note. It is compact and mostly clear, though the phrase 'acknowledge its wake' is somewhat cryptic and could be more direct.

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

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

With no output schema and no annotations, the description should clarify return values and behavior more fully. It explains the empty case but not what a successful refresh returns or how to interpret a non-empty response. It is adequate for basic tool selection but incomplete for full invocation confidence.

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 the input schema already documents both parameters adequately. The description adds little parameter-specific meaning beyond implying the tool targets a single private suggestion via suggestion_id.

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 action ('Refresh') and a specific resource ('one private suggestion'), and it clearly distinguishes this tool from siblings like suggestions_list by focusing on a single item before acting. The purpose is immediately understandable and not a tautology.

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

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

The description gives clear timing guidance: use this before acting on a private suggestion. It also explains the empty-result case and instructs the agent to acknowledge without action, which is useful directional guidance, though it does not name alternative sibling tools explicitly.

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

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

With no annotations, the description carries the full burden of disclosing side effects, and it does: accepting a commitment saves a private task, reply_candidate acceptance never marks completed, and no peer message or automatic completion is sent. It also describes the correction workflow by dismissing with an explanation and explicitly updating the task/request. Some operational details like revision-conflict handling are left unstated, but the main consequences are clear.

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 dense but each sentence earns its place: core purpose first, then special-case behavior, then correction guidance. It is appropriately sized for the complexity of the tool and contains no filler or tautology.

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 state-changing tool with four action typesPosted and no annotations or output schema, the description covers the critical prerequisites, side effects, and correction flow. It could be slightly more explicit about where the suggestion/revision comes from or what the response contains, but those gaps do not prevent correct invocation.

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

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

Schema coverage is 63%, and the description adds meaning beyond the schema by explaining that revision must be current, outcome is evidence-based, objective is required for commitments, and result_ids accompany applied records. It does not elaborate on dependency_request_id, but the schema already provides its purpose.

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

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

States a concrete verb/resource pair: records an action (accepted/applied/dismissed/blocked) for a suggestion with revision and outcome. It carves out special cases such as commitments, reply_candidates, and generic review records, which distinguishes it from nearby sibling tools like request_update or page_update.

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 explicit conditional guidance: accepting a commitment requires an objective, reply_candidate acceptance should mark needs_review rather than completed, and applied records should be made only after performing authorized edits via existing revision-checked tools. It does not explicitly name suggestion_get/suggestions_list as the read-first step, but the alternative editing tools are clearly identified.

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

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

With no annotations, the description carries the full burden. It discloses that disabled, shadow, stale, and inaccessible suggestions are excluded, and advises 'Never treat classification as permission.' It also notes that resolved outcomes are retained, which is a behavioral nuance. However, it does not mention pagination, response format, or failure modes, which are not critical for a read-only list tool, but the behavioral disclosure is adequate.

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

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

The description is two sentences, efficient and front-loaded with the core purpose. It then covers exclusions and usage notes without fluff. The phrase 'resolved outcomes are retained' is slightly ambiguous but still concise. Overall, it earns its place with no wasted words.

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

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

For a simple list tool with one parameter and no output schema, the description provides enough context: what the items contain, what is excluded, and a usage caution. It does not explain the return structure, but that is less critical without an output schema. The description is complete enough for an agent to understand the tool's behavior and scope.

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 'connection' is fully described in the schema, including its origin and security handling. The description adds no parameter-specific information, but since schema coverage is 100%, the baseline of 3 is appropriate. The description's mention of 'private' aligns with the parameter's purpose.

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 clearly states the verb 'Read' and the resource 'private current semantic work items' with details on what they include (evidence, versions, confidence, effective mode). It also lists exclusions, making the scope specific. However, it does not explicitly name or contrast with sibling tools like suggestion_get, so it lacks that extra differentiation, but the purpose 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 implies usage by saying 'Review pending/accepted items' but provides no explicit guidance on when to prefer this over suggestion_get or suggestion_resolve. It gives a contextual hint about reviewing pending/accepted items, but there is no mention of alternatives or when NOT to use it. Usage is partially implied but not fully explicit.

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

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

No annotations are present, so the description must carry the full behavioral burden. It states the operation is a read and adds scope ('private', 'across rooms'), but it does not explain authentication expectations, result shape, pagination, or what 'revisions' means.

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; the verb, resource, and scope are front-loaded. Every word earns its place.

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

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

The tool is simple with one optional parameter, and the schema richly documents the connection parameter, so the description is close to sufficient. However, with no annotations and no output schema, the return shape and exact semantics of 'revisions' remain unspecified.

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

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

Schema description coverage is 100% for the single connection parameter, including its origin, security, and retention guidance. The tool description adds no parameter detail, but the schema already carries the full burden, so the baseline of 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?

The description uses a specific verb ('Read'), identifies a precise resource ('private task contexts and revisions'), and scopes it ('across rooms'). This clearly distinguishes it from write-oriented siblings like task_context_update and from a generic context_get.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention that it complements task_context_update, nor whether it should be used after room_bootstrap/join or instead of context_get. The connection parameter hints at private-call prerequisites, but the main description gives no 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?

With no annotations provided, the description carries the full behavioral burden, and it delivers: 'Stable task ID + revision prevents overwrite' discloses concurrency semantics, 'never auto-completes this task' clarifies side effects, and 'completed dependency emits a resume suggestion' explains async behavior. It also flags a provider processing precondition that is absent from the schema.

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

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

The description is four dense sentences with no filler. The main action is front-loaded, and every subsequent sentence introduces a distinct behavioral or privacy consideration: host invisibility, overwrite prevention, dependency behavior, and provider opt-in.

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 9-parameter tool with no annotations and no output schema, the description covers a lot: purpose, concurrency, async side effects, and privacy/auth context. It stops short of 5 because 'provider processing requires private opt-in' remains vague, and there is no explanation of what happens on revision mismatch or what the tool returns.

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

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

Schema coverage is high at 78%, giving the baseline of 3. The description adds value by explaining that 'Stable task ID + revision prevents overwrite,' which gives meaning to the revision and task_id parameters. It also clarifies that the objective is an explicit goal or blocker, reinforcing the schema's minimal 'Goal or blocker' description.

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

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

The description starts with a specific verb and resource: 'Save an explicit private local goal or blocker.' It also adds a distinctive scope marker with 'Tincan cannot see host work,' which helps separate this private, local task context from public or agent-to-agent task tools. However, it does not explicitly name or differentiate any sibling tool such as a2a_task_update, so differentiation is implied 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?

The description clearly implies when to use the tool: for saving private local goals or blockers that host-side systems cannot see. It also hints at preconditions like 'Provider processing requires private opt-in.' Still, it does not explicitly contrast with alternatives, mention when not to use it, or name a preferred sibling for other 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states that existing agents, memory vaults, messages, and credentials stay in place, and mentions the 'creator only' permission. It also hints at a workflow with interrupted writes. It does not contradict any annotations, and adds useful context beyond the raw operation.

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

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

The description is two sentences long and front-loads the core purpose. The first sentence states the action and scope, and the second gives post-conditions and follow-up steps. Every sentence earns its place with 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?

The tool is simple with a single optional parameter and no output schema. The description covers the action, side effects, permissions, and suggested next steps, which is sufficient for an agent to invoke it correctly. A small gap is that it doesn't explain what the generated link is for or how to use it, but that's likely covered elsewhere. Overall, it's nearly complete for the tool's complexity.

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

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

Schema description coverage is 100%, so the schema already fully documents the 'connection' parameter, including its purpose and privacy guidance. The description does not add any additional parameter semantics beyond what the schema provides, so a baseline of 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?

The description clearly states the action: creating a one-use browser link to save the room with Google, and specifies the scope (creator only) and that existing data stays in place. It distinguishes from siblings by the 'creator only' restriction, though it doesn't name a specific alternative tool. The verb-resource pair is specific enough for an agent to understand the core function.

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

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

The description gives some usage context: it's for the creator, and it advises checking workspace_info and retrying interrupted writes with an idempotency key after saving. However, it doesn't explicitly state when to use this tool versus alternatives or when not to use it. The guidance is implied rather than explicit, so it's adequate but not thorough.

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 implies a read-only discovery operation and adds a useful connection-scope caveat ('One connection covers...'), but it never explicitly states that no state changes occur or describes response/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 tightly written sentences front-load the core purpose and then add the key connection-scope detail. No filler or redundant restatement of the tool name.

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 an informational tool with one optional parameter and no output schema, the description covers what the tool returns and the connection caveat. It could be more explicit about response format or read-only guarantees, but the core context an agent needs to invoke it correctly is present.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by clarifying what the connection grants access to: joined rooms and the private memory vault, which enriches the meaning of the optional connection parameter.

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

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

The description uses an active, specific verb ('Discover') and identifies a clear resource: Tincan's capabilities, operating guide, identity, workspace, plan, quota, and referral benefits. It conveys what the tool returns, though it does not explicitly contrast itself with siblings like context_get or workspace_claim.

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 'operating guide' implies this tool is the onboarding/reference entry point, but the description stops short of stating when to use it or when to prefer alternatives. No exclusions or alternative tool names are provided.

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