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

With no annotations provided, the description fully discloses key behavioral aspects: it covers failure modes (WebSocket unavailable, no active recipient, ACK timeout), the retry fallback (saved to local retry queue), and the resulting response state (queued_for_retry). This is far beyond the baseline.

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 tight and well-structured: the first sentence states the action, the second covers use cases and failure behavior. No wasted words; each sentence carries high informational 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?

Given this is a simple broadcast tool with an output schema available, the description covers the essential context: purpose, usage alternative, prerequisite, and failure handling. It is complete enough for an agent 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?

Schema description coverage is 0%, so the tool description should compensate, but it doesn't mention the parameters at all. The schema descriptions exist ('Isi pesan ke semua peer', 'Tipe pesan') but are minimal and in Indonesian, leaving msg_type semantics vague. The description adds no parameter meaning beyond the schema.

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

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

The description clearly states the action ('Send one message'), target ('all peers in the active room'), and mechanism ('through the Cloudflare relay'). It also explicitly contrasts with agent_send for one peer, making the tool's distinct scope unmistakable.

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

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

The description explicitly states when to use this tool ('room-wide notices') and when to use an alternative ('use agent_send for one peer'). It also notes a precondition ('An active room is required'), giving concrete usage guidance.

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

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

Annotations declare readOnlyHint=true, and the description's 'Read' aligns with a safe read operation. It adds context beyond annotations by enumerating the specific data returned (identity, active-room reference, connection status), which helps the agent understand expected output. No contradictions.

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 serving a purpose: the first defines the action, the second gives a usage trigger, the third names an alternative. No unnecessary information, appropriately sized and 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?

With an output schema present and a read-only annotation, the description covers the tool's purpose, usage timing, and relationship to alternatives. It is complete for a zero-parameter read operation, requiring no further explanation of return values.

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

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

There are zero parameters, so schema coverage is 100% and the description does not need to explain parameter meanings. The baseline for zero-parameter tools is 4, and no additional parameter information is necessary.

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'), a specific resource ('this local agent's identity, active-room reference, and connection status'), and clearly distinguishes it from sibling tools like room_info by focusing on local agent state rather than room state. This is unambiguous and differentiates 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?

Explicitly provides when to use: 'Use after agent_register to confirm local identity or when no active room is available.' It also names an alternative tool: 'Use room_info instead for detailed state of a currently joined room.' This offers clear selection 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, the description carries the transparency burden. It discloses the destructive nature of 'clear' (permanently removes cached inbox entries), the side effect of mark_read (advances the local read cursor), and the local caching behavior. It does not mention auth, rate limits, or return shape, but the most important behavioral side effects are covered.

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 concise sentences, front-loaded with the core purpose, followed by parameter-specific guidance and a clear pointer to an alternative tool. Every sentence earns its place with 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?

The description covers the main behavior, side effects, and alternative tool usage, which is sufficient for a read-oriented tool with an output schema present. It does not elaborate on how room join/leave events are ordered or whether limit applies to both messages and events, but these are minor gaps given the schema and 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?

Even though schema description coverage is reported as 0%, the tool description adds meaningful semantics for only_unread (filter by cursor), mark_read (advances cursor), and clear (permanent removal after reading). The limit parameter is not explained in the description, but the schema provides min/max constraints. This is a strong compensation for the schema gap.

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

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

The description clearly states a specific verb ('Read') and resource ('locally cached incoming messages and room join or leave events'). It distinguishes itself from siblings by explicitly contrasting with room_info ('Use room_info for connection state, not this tool') and by framing this as a local, inbox-specific read operation.

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 on when to use the tool: reading local inbox messages/events. It also names an alternative tool for connection state and clarifies the behavior of key parameters (only_unread, mark_read, clear) to help the agent choose the right settings. The 'not this tool' phrasing further reinforces 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?

Beyond the idempotentHint annotation, the description discloses that the operation is lightweight ('tidak membuka WebSocket'), only sets local name and identity, maintains a stable agent ID across sessions via local cache, and uses a permanent Cloudflare Workers relay. These are valuable behavioral traits not present in 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 well-structured with an overview, usage guidance, args, and returns. Each section earns its place, though the sentence about Cloudflare Workers relay is slightly tangential and could be trimmed without losing core meaning.

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-parameter tool, the description covers purpose, mandatory ordering, idempotency, return format (JSON with name, server URL, stable_agent_identity_id, confirmation), and side effects (stable identity). It is complete enough for an agent to invoke correctly without additional context.

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

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

With schema description coverage at 0%, the description fully compensates by explaining the only parameter: 'params.name (str, opsional): Nama display agent. Jika kosong, nama acak digunakan.' It adds type, optionality, display purpose, and behavior for empty values, going well beyond the bare 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 'Daftarkan agent ke AgentLink' (Register agent to AgentLink), clearly stating the action and target. It further distinguishes itself by declaring 'Wajib dipanggil pertama sebelum tools lain' (must be called first before other tools), making its unique role explicit compared to sibling room/task/capability 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 explicitly states when to use: 'Wajib dipanggil pertama sebelum tools lain' and 'Gunakan segera setelah startup, sebelum room_create atau room_join.' It also clarifies repeated calls are safe and idempotent, which is essential usage guidance. Since it's mandatory, no alternatives are needed.

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 transparency burden. It discloses meaningful failure semantics: when WebSocket is unavailable, delivery is unacknowledged, or ACK times out, the message is saved in a local retry queue and the response reports queued_for_retry. This adds significant behavioral context beyond a simple send, though it omits details like success response shape or authorization requirements.

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 short sentences: first states the purpose, second provides usage guidance and sibling differentiation, third details the retry fallback behavior. Every sentence adds distinct value with 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 moderate-complexity messaging tool, the description covers key contextual points: single recipient vs broadcast, active-room requirement, and retry queue behavior. It does not enumerate msg_type options or success response details, but the input schema and the note about the queued_for_retry response partially compensate. With no annotations, a bit more detail about the output could make it 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?

Context signals schema description coverage is 0%, and the description does not explain the parameters peer_id, message, or msg_type. It only implies recipient and message content through the phrase 'Send a direct message.' The optional msg_type parameter and its allowed values ('text'/'data'/'command') are not mentioned in the description, leaving the agent without semantic guidance if the schema descriptions are considered absent.

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 specific action: 'Send a direct message to one peer in the active room through the Cloudflare relay.' It names the verb, resource (peer), scope (one), and channel. It also explicitly differentiates from the sibling agent_broadcast by noting 'use agent_broadcast for all peers.'

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?

Explicit usage guidance is given: 'Use for a single recipient; use agent_broadcast for all peers.' It also states the prerequisite 'An active room is required,' providing clear when-to-use context and directing to the alternative tool.

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

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

Annotations already declare readOnlyHint=true, and the description adds context about the 'active room' and that the profile is 'currently visible to peers', providing nuance beyond the annotation. It does not contradict annotations and explains the visibility semantics, but could go deeper into error scenarios or room membership requirements.

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

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

The description is two sentences, front-loaded with the core purpose, followed by usage context and alternatives. Every sentence adds value with 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?

Given the tool's simplicity (no parameters), the presence of a readOnlyHint annotation, and an output schema, the description fully covers the necessary context: what it does, when to use it, and what it does not do. It is complete for an agent to select and invoke 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 tool has zero parameters, and schema coverage is 100%, so the baseline is 4. The description appropriately omits parameter details and focuses on behavior, which is sufficient for a parameterless tool.

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 ('this agent's capability profile') within a clear scope ('in the active room'). It distinguishes itself from sibling tools like capability_upsert_self and capability_set_availability by focusing on the read operation.

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

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

Explicitly states when to use ('after room_join when choosing work or checking the profile currently visible to peers') and provides alternatives for other operations ('use capability_upsert_self to change profile fields or capability_set_availability for a status-only update'). This is clear and actionable.

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

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

Annotations already declare destructiveHint and idempotentHint, but the description adds meaningful context by specifying what gets deleted (custom capability profile), what is restored (minimal room profile), and the intended effect (resetting published skills, constraints, and capacity data). It reinforces the destructive nature without contradicting the 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 two sentences, front-loads the action and target, and every sentence adds value. It includes the essential warning and the alternative tool without any fluff.

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 zero-parameter, destructive reset tool with an output schema, the description fully covers purpose, usage context, and alternative. It provides enough information for an agent to safely decide when to invoke 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?

The tool has zero parameters, and schema coverage is 100% (empty schema). The description adds no parameter details because none are needed; the baseline of 4 is appropriate for a no-parameter tool.

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 deletes this agent's custom capability profile and restores the minimal room profile, using a specific verb ('Delete') and resource. It distinguishes itself from sibling tool capability_upsert_self by explaining the destructive vs. preserve-and-edit contrast.

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 says to use it 'only when intentionally resetting published skills, constraints, and capacity data.' It also names the alternative tool, capability_upsert_self, for preserving and editing selected fields, giving clear when-to-use and 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?

The description discloses that this is a lightweight update and that it changes no other capability fields, which adds context beyond the idempotentHint annotation. It clarifies the scope (active room) and optionality of workload. It does not contradict the annotation.

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

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

The description is two sentences, front-loaded with the core action, and followed by usage guidance and an alternative. Every word earns its place; no redundant information 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?

The tool is simple with only two conceptual parameters, and the description covers purpose, usage context, and scope. The output schema is present, so return values need not be described. The only minor gap is not explaining the semantics of availability values in the description, but that is provided by the schema, making this adequate.

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 mentions 'availability' and 'current workload,' which correspond to the two nested parameters, adding some meaning about what to set. However, it does not explain the enum values (available/busy/away/dnd) or the load scale (0-100), and the schema description coverage is 0%, so the description does not fully compensate for the lack of parameter detail. The schema itself provides descriptions, but the description adds limited additional semantic value.

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 explicitly states the action: 'Set this agent's availability and, optionally, its current workload in the active room.' It uses a clear verb (set) and specifies the resource (this agent's availability/current workload). It also distinguishes itself from capability_upsert_self, making it stand out among 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 provides direct usage context: 'Use this lightweight status update when accepting or deferring work.' It also explicitly excludes the alternative: 'It changes no other capability fields; use capability_upsert_self for the full profile or skill data,' which clearly directs the agent when not to use this tool.

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

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

Beyond the idempotentHint annotation, the description discloses a key behavioral trait: 'Only supplied fields are changed; omitted fields are preserved.' This is valuable, though it does not clarify the 'upsert' aspect (whether it also creates a profile if missing) or discuss edge cases like validation errors.

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

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

The description is two sentences, front-loaded with the primary purpose in the first sentence and usage guidance in the second. Every sentence adds 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 description, combined with the existing output schema and annotations, provides sufficient context for selecting the tool and understanding its basic behavior. It names the alternative tool for a narrower use case and clarifies the partial-update semantics. A minor gap is the lack of mention of whether the tool creates a profile if absent, which could matter for the 'upsert' name.

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 mentions high-level field categories ('skills, constraints, tool access, or capacity settings') that map to schema fields, and explains the partial-update filter behavior. However, it does not enumerate any parameter names or explain the nested skills structure, leaving the schema to carry the full burden for parameter details. With 0% schema coverage in the description, this is only partial compensation.

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 'partially update' and the resource 'this agent's capability profile in the active room,' giving a specific action and scope. It also distinguishes itself from a sibling tool by referencing capability_set_availability, which removes ambiguity about the tool's niche.

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?

Explicit guidance is provided: 'Use this for skills, constraints, tool access, or capacity settings; use capability_set_availability when only availability and optional current_load need to change.' This clearly states when to use the tool versus the alternative, and also implies 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It reveals the ownership restriction and clarifies that the target must be active. It also implies reversibility by referencing room_admin_remove. It does not detail error conditions, but the core side effects are covered.

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

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

The description is two sentences, front-loaded with the primary action, and every sentence adds essential information—the action, the permission requirement, and the correct alternative for reversing the role. No filler or redundancy.

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

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

The tool is simple (one parameter, no nested objects) and has an output schema, so return value details are unnecessary. The description covers purpose, usage, ownership, and correct tool selection, making it 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?

The schema provides only a minimal identifier with 0% description coverage per context. The tool description compensates by explaining that the target must be 'currently active in the room', giving meaningful context to target_agent_id beyond a raw 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 clearly states the action: 'Grant room-admin role to another agent currently active in the room.' It uses a specific verb and resource, and it distinguishes the tool from sibling tools like room_admin_remove and room_leave.

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 states when to use this tool ('Only the room owner can call this'), its purpose ('delegate room administration'), and when not to use it ('not room_leave or capability tools'). It also names the alternative for revocation: room_admin_remove.

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 annotation destructiveHint: true already flags destructive behavior. The description adds useful context: the removal is 'immediate' and caller must be the room owner. It doesn't describe edge cases, but it meaningfully extends beyond the annotation.

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 clean sentences: the first states the action and object, the second gives the ownership condition and the alternative tool. Every sentence 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?

The tool has a single parameter, an output schema, and a destructive annotation. The description covers the operation, the precondition (owner-only), the immediacy, and the alternative for the reverse operation, leaving no major gaps 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 0% due to the nested $ref. The description says 'another active agent', which implies target_agent_id must be an active room participant, but it never explicitly names the parameter. With only one required parameter, the intent is inferable, but the description does not fully compensate for the lack of 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 opens with a specific verb 'Revoke' and identifies the resource as 'the room-admin role' from 'another active agent in the room'. This clearly distinguishes it from the sibling tool room_admin_add, which is explicitly referenced.

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 precondition 'Only the room owner can call this' and provides an explicit alternative: 'use room_admin_add instead when granting or restoring that role'. This gives the agent clear when-to-use and 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?

With no annotations, the description carries the behavioral burden. It discloses that is_private creates a token-protected room and that a token is returned and must be securely shared. It does not mention side effects or failure modes, but it adds meaningful context beyond a bare create statement.

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 concise sentences, front-loaded with the core purpose. Each sentence adds value: purpose, usage context and is_private semantics, and the sibling alternative. 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 simple create tool with an output schema present, the description is complete. It covers usage ordering, privacy options, token sharing, and the alternative tool for joining. The description gives enough context for an agent to correctly invoke 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?

Schema description coverage is 0%, so the description must compensate. It explains the is_private parameter (token-protected vs public) but does not mention the 'name' parameter. However, name is self-explanatory from its schema definition, and the link between is_private and the returned token adds helpful meaning.

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

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

The description clearly states a specific verb and resource: 'Create a new collaboration room on the Cloudflare relay.' It distinguishes from sibling tools by explicitly noting that room_join, not this tool, should be used to enter an existing room.

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 when-to-use context: 'Call after agent_register when starting a new group.' Also gives an explicit alternative/exclusion: 'Use room_join, not this tool, to enter an existing room.' This is a model example of usage guidance.

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

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

With no annotations provided, the description takes on the burden of behavioral disclosure. It explains that the tool 'refreshes local cache metadata but does not change the room's shared state,' which is valuable transparency. It doesn't cover every potential behavioral nuance, but for a simple read-style tool, this is sufficient.

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 wasted words. The first sentence states the core function, and the second provides usage guidance and a behavioral note. It is front-loaded and 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?

Given that this is a zero-parameter tool with an output schema, the description is complete: it states what the tool returns, when to use it, and its side-effect profile. There is no need for additional detail about parameters or return values, as the output schema handles structure.

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

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

The tool has zero parameters, and schema coverage is effectively 100%, so the baseline is 4. The description correctly implies no parameters are needed and focuses on the tool's behavior, which is appropriate for a parameterless tool.

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 with a specific verb ('Return') and resource ('connection, membership, and local retry-queue details') for the active room. This distinguishes it from sibling tools like room_list (listing rooms) and room_join (joining a room).

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 usage context: 'Use this before sending messages, leaving, or replacing a connection with room_join.' It clearly indicates when to call the tool. However, it does not explicitly state when not to use it or mention alternative tools directly beyond referencing room_join, so it falls short of a perfect score.

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 discloses a critical side effect: 'Joining a different room closes the previous WebSocket and fails its pending acknowledgements.' It also mentions the opening of a WebSocket connection, which is an operational trait. While it doesn't cover all edge cases (e.g., permissions, token errors), it goes beyond a generic statement and informs the agent of a destructive consequence.

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, each serving a distinct purpose: (1) states the core function, (2) gives usage order and parameter requirements, (3) warns of side effects and suggests an alternative. There is no fluff, and the most important information is 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 the tool's moderate complexity, the description covers the purpose, sequencing, parameter conditions, and a key side effect. The presence of an output schema means return values are not required in the description. It could mention error scenarios (e.g., invalid room_id) but that is not essential 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?

The description adds meaning to the parameters by explaining that room_id is the only required field for public rooms and token is conditionally required for private rooms. Since the schema description coverage is low (0% per context signals), this compensation is valuable. The schema itself only lists a token description in Indonesian, so the English explanation clarifies the use case.

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 'Join' with the object 'existing room' and specifies 'open its Cloudflare WebSocket connection', clearly distinguishing it from sibling tools like room_create (create) and room_info (info). It also notes the requirement of being an existing room, which further separates it from creation tools.

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

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

The description provides explicit sequencing ('Call after agent_register'), clarifies parameter conditions ('public rooms need only room_id, while private rooms require the owner's token'), and explicitly names an alternative ('use room_info') when replacing an active connection. This gives a clear when-to-use and what-to-check-before-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?

The description goes beyond the destructiveHint annotation by disclosing that it closes the WebSocket connection, stops reconnection, clears the local retry queue, and that queued messages are not sent. These are significant side effects that agents must know.

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, front-loaded with the primary action, and every sentence adds valuable behavioral context. No fluff 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 zero-parameter tool with an output schema and destructive annotation, the description fully covers the behavioral context, including side effects and when it is appropriate to use. Nothing essential is missing.

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

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

The tool has zero parameters, so parameter semantics are not needed. The description doesn't attempt to explain parameters, which matches the baseline for a no-parameter tool.

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 core action ('Leave the active room') and adds specific behavior details (close WebSocket, stop reconnection). This differentiates it from sibling tools like room_join or room_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 explicitly says when to use: 'Use only to intentionally disconnect or before discarding the current session.' It provides clear context and a limiting condition, though it doesn't mention alternative tools by name.

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

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

With readOnlyHint already provided in annotations, the description adds valuable behavioral context: it lists only active public rooms, does not join any room, and intentionally omits private rooms. This clarifies what the tool does and does not do beyond the annotation's basic safety 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?

The description is extremely concise, with two sentences that front-load the core purpose and then provide usage guidance and exclusions. Every sentence earns its place, with no redundant or extraneous 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?

For a zero-parameter tool with an output schema, the description fully covers its purpose, usage context, and key limitation (private rooms). It is complete for effective selection and invocation, and the output schema handles return value details.

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

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

The tool has zero parameters, so there is no parameter schema to supplement. The description appropriately focuses on the tool's behavior and usage rather than parameters, meeting the baseline for no-parameter tools.

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 lists active public rooms on the Cloudflare relay, using a specific verb ('List') and resource ('public rooms'). It also distinguishes itself from room_join by explicitly noting it does so without joining any room, making it 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 explicitly says 'Use this to discover a public room ID before room_join,' providing a clear when-to-use directive. It also gives an exclusion by noting private rooms are not listed and that their owners must share the ID and token directly, effectively guiding users away from using this for private rooms.

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

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

The description discloses behavior beyond the annotation: it explains the local cache read, offline behavior, and fallback logic. It is consistent with the readOnlyHint=true annotation, as it describes a read-only operation. No contradictions found.

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 concise (three sentences), front-loaded with the primary action, and structured clearly. Every sentence adds value, 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?

Given the tool's simplicity (1 parameter) and the presence of an output schema, the description covers purpose, parameter behavior, and alternatives. It is complete and sufficient for an agent 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 description coverage is 0%, but the description compensates by explaining the room_id parameter's effect: 'With room_id, reads that room's snapshot; without it, reads the active room or, when offline, lists all local snapshots.' This provides meaningful semantics 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 clearly states the tool's purpose: 'Read a room summary from this device's local cache without contacting the relay.' It uses a specific verb (read) and resource (room summary from local cache), and distinguishes itself from siblings by mentioning room_info for live state and room_join for refreshing.

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 usage guidance: 'With room_id, reads that room's snapshot; without it, reads the active room or, when offline, lists all local snapshots.' It also tells when to use alternatives: 'Use room_info for live connection state and room_join to refresh 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?

Since no annotations are provided, the description carries the full burden. It discloses that the tool changes task status and returns the updated manifest. It also implies a precondition (offer addressed to active agent). However, it doesn't mention failure cases or idempotency, but for a simple action this is sufficient.

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 concise sentences achieve high information density. The first delivers the core purpose, the second adds usage guidance and alternatives without any 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?

The description covers purpose, usage, state change, and return value. The output schema exists, so details of the manifest are not required. It could mention error conditions, but the tool is simple and well-scoped.

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

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

The tool description adds no information about the task_id parameter beyond what the input schema already provides via its own description. The schema covers the parameter adequately, 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 tool's action: 'Accept a pending delegation offer addressed to the active agent.' It uses a specific verb and resource, and explicitly differentiates from siblings by naming task_reject and task_defer.

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 usage context: 'Use after reviewing an offer that this agent will perform.' It also gives clear alternatives and when to use them, making the decision process unambiguous.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It states that the optional reason and deferred_until hint are 'saved with the transition,' which reveals that the action persists metadata. It also clarifies that deferral is not a final refusal, adding meaningful context beyond the verb 'defer.' However, it does not describe side effects like whether the task becomes locked or if the sender is notified.

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

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

The description is two sentences, front-loaded with the primary action, and every clause earns its place. It includes purpose, usage, semantics, and a sibling comparison without any waste.

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

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

The tool is relatively simple, with one required parameter and two optional hints. The description covers the core action, when to use it, and how it differs from rejection. It does not mention what happens after deferral (e.g., whether the task reappears later or if the offer expires), which is a minor gap, but the provided information is sufficient for an agent to decide to invoke 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?

The schema descriptions are in Indonesian and flagged as 0% coverage, so the tool description must compensate. It explicitly mentions the optional reason and ISO-8601 deferred_until hint and ties them to the transition. It does not explicitly describe task_id, but the meaning is obvious from context and the tool name. The description adds enough semantic value beyond the schema's field names.

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

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

The description opens with a specific verb and resource: 'Defer a pending delegation offer addressed to the active agent.' It immediately clarifies what the tool does and distinguishes it from the sibling tool task_reject by explicitly naming it as the final-refusal 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 clear usage context: 'Use when the agent may reconsider the work later.' It also explicitly points to an alternative: 'use task_reject for a final refusal.' This gives the agent both a positive condition and a contrast with a sibling tool, which is ideal 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?

Annotations declare readOnlyHint=true, and the description's 'without changing it' simply restates that annotation without adding new behavioral context. It does add the 'active room' scoping, which is useful, but it does not disclose potential error behavior, auth requirements, or any other side effects. Since annotations already cover the safety profile, this is adequate but not rich.

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

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

Three tight sentences: the first states purpose, the second and third provide usage context. There is no fluff, and the most important information is front-loaded. 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 tool is a simple read with one parameter, has an output schema, and readOnlyHint annotation. The description covers purpose, when to use, and alternatives. Given the low complexity and the presence of output schema, the description is complete enough for an agent 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?

Schema description coverage is reported as 0%, so the description must carry the semantic burden. The description indirectly references the parameter through 'when an offer supplies a task ID' and 'when the task ID is not known', which conveys that task_id is the identifier of the task. However, it does not explicitly describe the task_id format or origin beyond these hints, leaving some ambiguity.

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 tool's action ('Read'), the specific resource ('one delegation task manifest'), and the scope ('from the active room'). It distinguishes task_get from task_list by emphasizing a single manifest vs. listing, and the parenthetical 'without changing it' reinforces the read-only nature.

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 states when to use this tool ('after task_list or when an offer supplies a task ID', 'especially before choosing accept, reject, or defer') and when not to ('Use task_list instead when the task ID is not known'). It names the alternative tool, providing clear usage boundaries.

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

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

Annotations provide readOnlyHint, but the description adds meaningful context: it operates in the active room and targets the delegation queue. It also reinforces non-mutation with 'without changing their state'. Return format is covered by the output schema, so no need to describe 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?

Two concise sentences, first front-loads purpose and behavior, second gives usage direction. Every sentence earns its place with no redundancy.

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

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

For a simple zero-parameter list tool with an output schema, the description fully covers its purpose, scope, and usage differentiation. It is complete given the tool's low 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?

The tool has zero parameters, so the description need not explain parameters. The baseline of 4 applies because no parameter clarification is required.

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 'List' and the resource 'delegation tasks in the active room', and explicitly notes it does not change state. This distinguishes it from mutation tools and sibling task_get, which retrieves a single task's manifest.

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 when-to-use guidance: to find a task ID or inspect the room's delegation queue. It also names alternatives: use task_get for a single full manifest, and a transition tool only after selecting a task.

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 transparency burden. It discloses a key behavioral trait: 'This creates a new task offer, so do not retry it blindly' — indicating non-idempotency. It also implies constraints (active agent, current room). However, it does not elaborate on error responses or side effects beyond creation, 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?

The description is compact: three sentences that efficiently convey purpose, usage, and a critical caution. No redundant phrasing, and the main verb-object is front-loaded. 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 output schema exists, so return values need not be explained. The description covers the essential context: when to use, recipient actions, non-idempotency, and recovery guidance. It could mention prerequisite conditions (e.g., delegator must be in the room), but these are implied. Overall, reasonably complete for a creation tool with a 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?

The description makes no mention of any parameters (title, to_agent_id, priority, point_of_contact_agent_id). Schema description coverage is 0%, so the description must compensate but does not. Despite the schema having its own descriptions, the tool description adds no semantic clarity for the 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 opens with a specific verb-object pair: 'Create a delegation offer for one active agent in the current room.' This clearly distinguishes it from sibling tools like task_accept (accepting) and task_get (reading). The scope ('current room', 'active agent') adds precision.

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?

Explicit usage guidance is provided: 'Use when the delegator has selected a recipient; the recipient can then use task_accept, task_reject, or task_defer.' It also warns against blind retrying and suggests inspecting task_get or task_list first, naming alternatives. This fully covers when and when not to use the tool.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It mentions that the optional reason is recorded with the transition, adding some context. However, it does not disclose whether the rejection is irreversible, what happens to the offer, or any side effects on the delegating agent. This is a moderate level of transparency.

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

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

The description is two sentences, front-loaded with the primary action and followed by usage guidance. Every sentence earns its place with no waste 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 simple tool with one required parameter and an output schema, the description covers purpose, usage, and an alternative. It could be improved by stating the effect of rejection (e.g., finality) or any permission requirements, but it is largely complete for a basic transition action.

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 description coverage is 0%, so the description must compensate. It explains that 'reason' is optional and is recorded with the transition, giving it semantic meaning. However, 'task_id' is not elaborated beyond its self-evident name, and the description does not fully clarify the relationship between the two parameters. This is a partial compensation.

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 function with a specific verb ('Reject') and resource ('pending delegation offer'), and it is distinct from sibling tools like task_accept and task_defer. The phrase 'addressed to the active agent' adds precision about the recipient.

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 usage guidance: 'Use when this agent will not perform the task' and explicitly names an alternative: 'Use task_defer instead when the task may be accepted later.' This clearly differentiates when to use this tool vs. a sibling.

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