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

With no annotations, the description must disclose behavioral traits, but it only states 'archive one fully handled inbox message.' It does not mention side effects (e.g., whether the message is deleted or moved), authorization needs, or reversibility. This is insufficient for a mutation tool.

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

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

The description is a single sentence with no wasted words, but it is too terse. It sacrifices necessary detail for brevity, making it under-specified for an AI agent to understand proper usage.

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 existence of an output schema, return values are covered. However, the description fails to explain the archiving behavior, prerequisites, or constraints. With one parameter and no explanatory context, it is 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?

The sole parameter 'message_id' has no description in the schema (0% coverage). The tool's description does not explain what message_id is, how to obtain it, or its format, so it adds almost no value beyond the schema's type.

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 specifies the verb 'archive' and resource 'inbox message' clearly. The qualifier 'fully handled' adds context. However, it doesn't define what archiving entails (e.g., moving to archive folder), but it is distinct from sibling tools like iam_read or iam_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?

No guidance is provided on when to use archive versus alternatives like iam_inbox or iam_read. There is no mention of conditions, prerequisites, 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?

Discloses that joining another channel leaves the prior one, indicating a single active channel behavior. Also mentions the DM creation case. However, it does not mention permissions or side effects beyond switching, and annotations are absent so the description carries full burden.

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 purpose and behavior; the conditional DM note is placed second. 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?

Covers the core joining behavior and the DM special case, and an output schema exists so return format is handled. However, it leaves the meaning of the channel parameter and allowed channel_type values unclear, which is a gap given no schema descriptions.

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 explains the purpose of channel_type and with_agent in the context of creating a DM, but offers no definition for the channel parameter. With 0% schema coverage, it partially compensates for the lack of parameter documentation.

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

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

States it joins a live channel and makes it active, with a clear note that joining another switches active channel. This distinguishes it from siblings like iam_chat_leave and iam_chat_subscriptions.

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

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

Provides a specific usage condition for creating DMs ('Use channel_type=private and with_agent only to create a new DM') but does not state when to prefer this over alternatives like iam_chat_leave or iam_chat_tail. No explicit when-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 provided, the description carries the full burden of behavioral disclosure. It transparently states the primary effect (leaving the chat) and an additional effect (stopping supervisor notifications). However, it does not disclose potential prerequisites (e.g., must be in an active chat), idempotency, or what happens if the user is not currently in a chat. For a simple action, this is adequate 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?

The description is a single, efficient sentence that front-loads the primary action ('Leave') and then provides the secondary effect. There is no filler or redundant wording. Every word contributes meaning, making it highly concise 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 zero-parameter tool with an output schema present, the description covers the essential behavior: leaving the chat and stopping notifications. It does not explain return values, but since an output schema exists, that information is available structurally. It also doesn't mention edge cases like whether the tool fails if not in a chat, but the description is sufficiently complete for a simple action in 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?

The tool has zero parameters, so there is no parameter information to add. The schema description coverage is effectively 100% (no properties to document). According to the rubric, a zero-parameter tool gets a baseline of 4, and the description does not need to compensate for missing parameter details. The description adds nothing about parameters because none exist.

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 ('Leave') and resource ('this mailbox's active live chat channel'), and additionally specifies the secondary effect ('stop its supervisor notifications'). It clearly distinguishes from siblings like iam_chat_join (opposite action) and iam_chat_seen (marking as seen), 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 usage context: the tool is for exiting the active live chat of the current mailbox. While it doesn't explicitly mention alternatives or exclusions, the clear action and the presence of iam_chat_join as a sibling makes the appropriate usage obvious. No explicit 'when not to use' is given, 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 behavioral burden. It adds useful context by explaining the channel must be active/joined and cannot be passed as an argument, but it does not disclose effects, failure behavior when no channel is joined, or any permissions/limits.

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

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

Two short sentences, front-loaded with the action and followed by the key constraint. No filler or redundant restatement of the schema.

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 two-parameter tool with an output schema, the description gives the essential invocation context: target, prerequisite, and a critical limitation. It is slightly incomplete only in parameter semantics, which is covered by the schema titles.

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 clarifies only that the channel is not supplied, while the two actual parameters (message and date) are not explained at all.

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: 'Post to this mailbox's active chat channel.' It also notes the channel cannot be supplied, which differentiates it from channel-management siblings like iam_chat_join and from send/reply 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 gives a clear prerequisite: 'Join a channel first.' It explains the target is the mailbox's active channel rather than a user-supplied one, but it does not explicitly name alternative tools or state 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?

No annotations are present, so the description must fully disclose behavior. It only states a state change ('mark as seen') without discussing permissions, reversibility, or 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 a single, very concise sentence. While efficient, it sacrifices completeness for brevity.

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 three parameters and no annotations, the description is insufficient. It omits return value details (output schema exists but unused), parameter roles, and behavioral constraints.

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 does not mention any parameters despite 0% schema description coverage. Terms like 'recent' hint at 'date' and 'lines' but provide no concrete semantics or syntax.

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 marks chat messages as seen, using a specific verb and resource. It distinguishes from siblings like iam_chat_tail and iam_chat_post, but lacks detail on what 'seen' means.

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 on when to use this tool versus alternatives. The implied usage is to mark messages as seen, but no explicit conditions or exclusions are provided.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It clearly indicates a read-only operation that returns the active subscription if one exists, and the 'if any' phrasing conveys that no subscription results in an empty/null outcome. It does not detail error cases or side effects, but for a zero-parameter getter the core behavior is well 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?

The description is a single, tight sentence with no wasted words. The main verb and object appear immediately, and the conditional 'if any' is placed at the end without obscuring 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 zero-parameter, read-only lookup with an output schema present, the description provides all necessary context. The agent can invoke the tool safely and interpret the result without additional guidance about arguments or return 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 input schema has zero parameters, so the description need not explain parameter meanings. The baseline of 4 applies because there are no parameters to document, and the description appropriately focuses on the return value instead.

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 ('Return') and a precise resource ('this mailbox's active live chat subscription'), making the tool's purpose immediately clear. It also distinguishes itself from sibling chat actions like iam_chat_post or iam_chat_tail by focusing on subscription retrieval rather than message operations.

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 the tool is used to check whether a live chat subscription exists for the mailbox, and the 'if any' qualifier signals that absence is a valid outcome. However, it provides no explicit guidance on when to choose this over alternatives such as iam_chat_join or iam_chat_leave, nor does it mention prerequisites.

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 disclose key behaviors. It mentions 'enforcing private-channel membership' (authorization) but doesn't clarify if it's read-only, whether it streams or polls, limits, or side effects (e.g., marking messages as seen). The name 'tail' suggests streaming but description says 'read recent' adding ambiguity.

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?

Single sentence efficiently conveys the core action and a key constraint. However, it lacks structure (e.g., bullet points or sections) and could benefit from parameter hints or usage examples.

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 an output schema, the description is too terse. It fails to mention return value structure, pagination, or whether it supports streaming. Given moderate complexity (3 params) and no annotations, the description is insufficient for complete understanding.

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

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

Schema coverage is 0% and description provides no parameter details. Three parameters (channel, lines, date) are completely undocumented in both schema and description, leaving the agent to guess their formats, meanings, or constraints.

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?

Describes a specific verb ('read recent chat messages') and resource ('chat messages'), and adds a distinctive constraint ('enforcing private-channel membership'). This clearly distinguishes it from siblings like iam_chat_post (send) and iam_inbox (email).

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?

Only states what the tool does but provides no guidance on when to use it versus alternatives (e.g., iam_chat_seen for marking read, or other read tools). No explicit when-to-use or when-not-to-use 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?

No annotations provided, so description carries full burden. It only discloses one behavioral trait (no mark-as-read). Other traits like authentication, rate limits, or state changes are omitted. For a read-only tool, more could be said about side effects or scope.

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?

Single sentence, no wasted words, but lacks structured presentation of key info. Could be improved by front-loading the key behavioral trait and adding parameter context.

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 0% schema coverage, the description is insufficient. It covers purpose and a behavioral note but misses parameter semantics, usage guidelines, and broader behavioral transparency. Output schema exists but is not referenced.

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?

Description does not mention any parameters. Schema has 0% description coverage with two parameters (limit, unread_only) that remain unexplained. The description should clarify their meaning and defaults.

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 clearly states the tool lists newest inbox messages for the project without marking them read. It distinguishes from siblings like iam_read (which likely marks as read) and iam_list_mailboxes (lists mailboxes, not messages).

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 explicit when-to-use or when-not-to-use guidance. The phrase 'without marking them read' implies a contrast with iam_read, but no alternatives or context are provided. Sibling tools exist but are not referenced.

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, and the description does not disclose any behavioral traits beyond listing channels, such as rate limits, authentication requirements, or 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?

Single sentence, no unnecessary words, directly conveys the tool's 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?

Given zero parameters and no annotations, the description is brief but sufficient for a simple list operation. Output schema exists, so return values need not be explained.

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 has zero parameters, so schema coverage is 100% trivially; description adds no parameter info but none is needed. Baseline score of 4 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 clearly specifies the verb 'list' and the resource 'IAM public and private chat channel names', distinguishing it from sibling tools like iam_list_mailboxes and iam_inbox.

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 on when to use this tool versus alternatives or any exclusions; the description only states what it does without 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 must disclose behavioral traits. It only states the action and output, but does not indicate whether it is read-only, requires special permissions, or what scope the list covers (e.g., user's mailboxes vs. all).

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, concise sentence with no fluff. It front-loads the action and resource, efficiently conveying the tool's 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?

The tool is simple (no params, output schema exists). The description is minimal but sufficient for a straightforward listing. However, it lacks context about the source of mailboxes or any filtering capabilities, making it only marginally complete.

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

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

There are zero parameters, so the baseline is 4. The description adds no parameter info, which is acceptable since none exist.

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 clearly identifies the resource as 'IAM mailbox addresses and display names'. This clearly differentiates it from sibling tools like iam_inbox (list messages) and iam_whoami (user 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?

No guidance on when or why to use this tool over siblings or alternatives. It does not mention prerequisites, context (e.g., before sending), 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 provided, so description carries full burden. It does not disclose that reading a message by default marks it as read (mark_read param defaults to true). This side effect is important for an agent to 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?

Single sentence, no fluff, front-loaded with verb and resource. 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?

Given output schema exists, description doesn't need to explain return values. However, it omits the important behavioral note about marking read. Could be more complete with one additional sentence.

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?

Adds meaning to message_id by stating it accepts full id or unique prefix, which exceeds schema. However, mark_read parameter is not described at all despite having a default value and side effect.

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 clearly states verb 'read', resource 'inbox message', and identifier 'by full id or unique prefix'. It distinguishes from sibling tools like iam_inbox (list) and iam_archive (archive).

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

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

Implies usage when you have a message id or prefix, but lacks explicit 'when to use' vs alternatives like iam_inbox for listing, or iam_reply for replying. No 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 provided, the description carries the behavioral burden. It discloses a meaningful trait—preserving originator and routing—and clarifies that the reply is attached to an existing thread. Still, it does not mention side effects, required permissions, or failure modes, so coverage is partial.

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. It earns its place by stating the action and a key behavioral constraint, though 'substantive' is somewhat extraneous and could be removed without losing 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 an 8-parameter action with no annotations and no parameter explanations, this description is too thin. It leaves questions about reply routing behavior, relationship to iam_send, and how message_id/references work. The presence of an output schema reduces return-value ambiguity but not these usage 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?

Schema description coverage is 0% and the description mentions none of the 8 parameters. The agent receives no help beyond parameter names like message_id, references, or priority, and the description does not compensate for the missing schema detail.

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 clear action and object: 'send a substantive reply' in 'an existing thread'. The phrase 'preserving originator and routing' adds meaningful distinction from a generic message send, though 'substantive' is vague and not explained.

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 the tool should be used when replying within an existing thread, which gives some context. However, it does not explicitly state when not to use it or mention alternatives like iam_send for new messages, leaving the routing decision partially inferred.

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 of behavioral disclosure. It adds one useful behavioral nuance: urgent priority may steer an active Codex turn. However, it does not mention permissions, side effects beyond sending, or any constraints relevant to a mutating 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?

Two sentences with no filler. The core action is front-loaded, and the only additional sentence adds a meaningful behavioral detail about priority. 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?

With no annotations, 0% parameter coverage, and ambiguity between siblings like iam_reply and iam_chat_post, this short description is not enough for an agent to confidently invoke the tool in all intended contexts. The output schema covers return values, but important usage and parameter context 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 0%, and the description only adds meaning for `priority` by defining its allowed values and behavioral effect. The other six parameters (`to`, `subject`, `body`, `cc`, `references`, `attachments`) receive no additional semantic guidance beyond their property 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 states a specific action ('Send a new message') with a clear resource and purpose. It is concise and generally distinguishable from siblings like iam_reply, though it does not explicitly clarify that this is an email/message send rather than a chat post, so it falls short of full sibling differentiation.

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

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

No guidance is given about when to use this tool versus alternatives such as iam_reply or iam_chat_post. The description focuses only on the action and priority, not on selection criteria or exclusions.

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

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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It does state the required permission and that the operation is an add, which is helpful. Yet it does not mention side effects, idempotency, or what happens if the member already exists—though this may be less critical for a simple mutation.

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

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

The description is one efficient sentence, front-loads the verb and resource, and includes the permission condition without any filler. It is a model of conciseness.

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 no nested objects and has an output schema, so return details are not needed. However, with no annotations, the description could better define prerequisites, expected formats, and behavioral constraints to be fully self-sufficient for an agent deciding when and 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 0%, so the description must compensate. It does add meaning by specifying that 'member' is a mailbox and that 'team' refers to the current leader's team. This helps disambiguate the parameters, but it does not explain formats or how team and member are identified, so some ambiguity remains.

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 ('Add one mailbox') and the resource ('this leader's team'). It is specific and inherently distinguishes itself from the sibling iam_team_remove_member by indicating the additive nature of the 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?

The description gives a single usage condition ('when team.manage_members was explicitly granted'), which tells the agent when the tool is permissible. However, it does not explicitly compare to alternatives such as iam_team_remove_member or describe when not to use it, so the usage context is inferred rather than spelled out.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses the destructive action ('Remove') and two important constraints (non-leader mailbox, granted permission). However, it does not describe side effects, irreversibility, or what happens when the permission is absent.

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 entire description is one well-structured sentence with no filler. The action, target, restriction, and permission requirement are all front-loaded and immediately usable.

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 two-parameter tool with an output schema, the description provides the core action, the member restriction, and the permission prerequisite. Missing details like identifier formats and post-removal effects are minor gaps rather than critical omissions.

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 add parameter meaning. It does clarify that 'member' is a non-leader mailbox and 'team' is the leader's team. However, it does not specify identifier formats, such as whether team and member expect names, IDs, or email addresses, so it only partially compensates.

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: 'Remove a non-leader mailbox from this leader's team.' It also defines a clear condition ('when team.manage_members was granted'), which distinguishes it from sibling tools like iam_team_add_member without ambiguity.

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 an explicit usage condition: this tool should be used only when team.manage_members was granted and only for non-leader mailboxes. It does not explicitly name alternatives or exclusions, but the use case is clearly communicated.

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 action as cancelling a timer and scopes it to a mailbox, but it does not disclose error behavior, irreversibility, idempotency, or what happens if the timer_id is invalid or missing. This is thin for a destructive-looking 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 a single sentence with no wasted words, and it starts with the primary verb 'Cancel', giving immediate focus. It is appropriately sized for a one-parameter tool.

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

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

For a one-parameter cancel operation with an output schema present, the description captures the essential action and scope in a compact form. It omits edge-case details like error handling, but given the tool's simplicity and the presence of an output schema, this is mostly sufficient.

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 should compensate for the lone parameter, timer_id. The description only indirectly refers to a timer and never explains what timer_id is, where to obtain it, or what constraints apply. The field name is self-explanatory, but the description provides almost no additional parameter 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?

The description uses a clear verb ('cancel') and a specific resource ('timer'), and adds a meaningful scope qualifier ('created by or targeted to this mailbox'). It distinguishes from set/list tools, but it does not explicitly differentiate from the similarly named sibling 'iam_timer_clear', so there is slight ambiguity.

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 direct guidance about when to use this tool versus siblings like iam_timer_clear, iam_timer_snooze, or iam_timer_set. The only contextual hint is the word 'outstanding', which implies a pending timer, but that is simply inferred from the purpose. No alternative routing or exclusion is offered.

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

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

With no annotations, the description must convey behavior. It explicitly notes that cleared timers are not archived, which is useful. However, it doesn't mention irreversibility or permission requirements, which is a minor gap.

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

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

The description is two concise sentences with no fluff. The key behavioral note is front-loaded, making it effective for quick understanding.

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 parameter and an output schema, the description covers the core behavior. It lacks notes on error conditions or permissions, but the simplicity of the tool makes it reasonably 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 coverage is 0% and no parameter details beyond the name 'timer_id' are given. The description doesn't elaborate on the format or meaning of timer_id, but with only one parameter and a self-explanatory schema, baseline is adequate.

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 'clear' and the resource 'handled timer', and explicitly notes that cleared timers are not archived. This distinguishes it from related timer tools (cancel, snooze) which handle different states.

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 usage on 'handled' timers, distinguishing it from other timer operations like cancelling or snoozing. It doesn't explicitly rule out alternatives, but the context is sufficient.

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. The verb 'List' implies a read-only operation but the description does not explicitly state that nothing is modified, how 'outstanding' or 'temporary' are defined, or what the response contains. It minimally discloses the core behavior but leaves room for ambiguity.

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 words. It is appropriately compact for a simple listing operation; the absence of parameter explanation is a completeness issue, not a conciseness issue.

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 boolean parameter and an output schema, the description is minimally sufficient for an agent to guess the basic action. However, it lacks any context about due_only behavior, usage context, or why this tool exists alongside the sibling timer tools, so it is not 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 0%, so the description must compensate for the undocumented due_only parameter; it does not mention due_only at all. The parameter's name and default value provide some signal, but the description does not explain what 'due' means or how the filter changes results.

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 resource ('this mailbox's outstanding temporary reminders'), clearly stating what the tool does. It also distinguishes itself from the sibling timer mutators (set, clear, cancel, snooze) by being the only listing operation among them.

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 versus alternatives such as iam_inbox, iam_read, or the other timer tools. There are no exclusions, prerequisites, or suggestions about the appropriate context for listing reminders.

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?

There are no annotations, so the description must carry the full behavioral burden. It indicates 'Set' (a mutation) and 'one-shot', but it does not disclose side effects, whether an existing timer is replaced, permissions, or what happens after scheduling. This is a significant gap 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?

A single, front-loaded sentence states the action, target, and time-format requirement with no filler. For a two-parameter tool with an output schema, this is appropriately compact.

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 simple two-string-parameter shape and presence of an output schema, the core action and due_at format make the tool minimally viable. However, with no annotations, it should also address side effects of setting a timer and clarify the note parameter, so completeness is only partial.

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 is the only source of parameter meaning. It adds a genuinely useful constraint for due_at ('ISO-8601 timezone-aware time'), but note remains described only by its schema title. This is partial compensation, not complete parameter documentation.

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

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

The description opens with 'Set a one-shot reminder for this mailbox' – a specific verb and resource, and it adds a useful temporal constraint (ISO-8601 timezone-aware time). It does not explicitly distinguish this tool from sibling tools like iam_timer_set_team or iam_timer_snooze, so it stops short of a 5.

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

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

The 'one-shot reminder for this mailbox' wording implies when to use it, but there is no explicit when-not guidance or naming of alternatives among the timer siblings. It is enough to infer the basic use case, but not enough to confidently choose between iam_timer_set, iam_timer_set_team, and iam_timer_snooze.

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 burden. It does disclose one meaningful requirement: 'explicit timer.schedule permission is required.' It does not describe side effects, whether existing timers are replaced, or success/confirmation behavior, but the key permission constraint is present.

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 sentence with no filler. The core action is front-loaded, and the permission caveat is appended cleanly. Every word contributes to either purpose or behavioral context.

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 3 required parameters, no annotations, and 0% schema description coverage, yet the description does not clarify parameter semantics or routing among sibling timer tools. An agent would have to guess at the due_at format and target identifier. The presence of an output schema avoids the need to explain return values, but the remaining gaps are significant.

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 no descriptions for target, note, or due_at (0% coverage), so the description must compensate. It only implies that target is a teammate; it does not explain expected due_at format, note content, or how target should be identified. This is insufficient given the complete absence of schema-level parameter documentation.

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

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

The description states a specific verb and resource: 'Schedule a timer' for 'one authorized teammate.' This scope distinguishes it from sibling iam_timer_set_team, which implies a team-level timer, and from the other timer tools. Even without naming siblings, 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 phrase 'for one authorized teammate' implies this tool is for single-teammate timers, and the permission note gives a prerequisite. However, there is no explicit guidance on when to prefer this over iam_timer_set or iam_timer_set_team, nor any exclusions or fallback conditions.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It usefully reveals a permission requirement and the scheduling/mutation nature of the action, but it does not clarify side effects, reversibility, or what happens to the timers after creation. Some behavioral context is present, but key details are missing.

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 compact two-sentence definition. It front-loads the core purpose and immediately adds the most important usage constraint. Every word earns its place with 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?

Despite having an output schema, the description leaves important invocation details unresolved: the meaning of 'independent timers', how 'team' is identified, the expected date format for 'due_at', and how this tool differs from iam_timer_set_for. It is not complete enough for an agent to invoke with 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?

The input schema has three required string parameters with no descriptions, and the description does not compensate. The word 'team' is partially clarified by 'authorized team', but 'note' and 'due_at' receive no guidance about format, meaning, length, or timezone.

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—'Schedule independent timers'—with a specific target ('authorized team') and a notable access restriction ('Only an explicitly granted active leader may use this'). It is clear enough to distinguish from personal timer tools, though it does not explicitly name any 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 an explicit eligibility constraint: only an explicitly granted active leader may use it. However, it does not explain when to choose this over nearby siblings like iam_timer_set or iam_timer_set_for, nor does it provide scenarios or exclusions beyond the authorization note.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states the intended action but does not disclose side effects—what happens to the original due time, whether the timer must be in a certain state, what errors occur, or whether the operation is idempotent. The only extra behavioral constraint is the ISO-8601 timezone-aware format.

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 entire description is one sentence with no filler. It front-loads the verb and resource, includes the condition ('outstanding') and the required input format (ISO timezone-aware). 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?

For a two-parameter mutation with an output schema present, the description avoids the need to explain return values. But the overall context is thin: no annotation coverage, no caveats, no failure expectations. The description is usable for an agent, but leaves gaps in fully understanding when and how to invoke it 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 description coverage is 0%, and the schema gives no parameter descriptions. The description helps by indicating that due_at is an ISO-8601 timezone-aware timestamp and that a single existing/outstanding timer is being modified, which maps timer_id to the target timer. However, it does not explain how to obtain timer_id or whether due_at must be in the future.

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 specific action on the specific resource: 'Move one outstanding timer to a new ISO-8601 timezone-aware due time.' It clearly conveys rescheduling an existing timer, and the contrast with sibling tools like timer_set (which creates timers) is implied by the word 'outstanding'.

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 for existing/outstanding timers but does not explicitly say when to choose this over alternatives such as iam_timer_set or iam_timer_cancel. There is no when-not guidance, so the agent has to infer context from sibling names and the phrase 'outstanding'.

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 states the behavior but does not disclose any side effects, permission requirements, or other traits. For a simple read-only tool, the description is adequate but not thorough.

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, clear sentence with no unnecessary words. It is perfectly concise for the tool's simplicity.

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 has no parameters and a known output schema (not shown but exists), the description is largely complete. It could be improved by specifying the format of the returned identity (e.g., email address), but this is minor.

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 no parameters, and schema description coverage is 100% trivially. The description adds no parameter details, but none are needed. 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 clearly states the action ('Return'), the resource ('mailbox identity'), and the context ('bound to this MCP server'). It is distinct from sibling tools like 'iam_list_mailboxes' or 'iam_inbox', which serve different purposes.

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 does not explicitly state when to use this tool or when not to use it. However, the name and description imply it is the go-to tool for retrieving the current identity, with no obvious alternatives among siblings.

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