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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds real value beyond that by disclosing the shape of the payload (join code/url, member/message/owner counts, history and messaging flags) and permission-scoped output ('what this account may edit').

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

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

One dense sentence with the verb and resource front-loaded and the field list trailing. Every clause earns its place, though the field enumeration is long and could be trimmed.

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

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

For a read-only, single-parameter getter with no output schema, the description's return-field enumeration compensates well for the missing output schema. Only the lack of explicit routing against remind_list_entities keeps it from being fully complete.

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

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

There is a single parameter with 100% schema description coverage, so the schema already documents the uuid array and its provenance. The description adds no format or sourcing detail beyond 'by uuid', which is the expected baseline when schema coverage is complete.

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

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

States a specific verb and resource ('Get full detail for one or more classes by uuid') and enumerates the returned fields, so an agent knows exactly what it gets. It does not explicitly name the sibling remind_list_entities as the source of uuids (only the schema does), 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?

The phrase 'by uuid' implies this is a follow-up lookup rather than a discovery call, and the schema notes uuids come 'from remind_list_entities', but the description itself gives no explicit when-to-use or when-not-to-use guidance versus remind_list_entities or remind_list_chats.

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 establish this as a safe, idempotent read. The description adds useful behavior beyond that: result ordering is 'newest-last' and returned items are typed as MessageItem, SystemMessageItem, or GapItem, including the paging-gap semantics. It does not detail pagination limits or attachment shape, but the added context is substantial.

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

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

The description is front-loaded with the core action and then adds the item-type taxonomy in a compact second sentence. It is appropriately sized and wastes little space, though the parenthetical item definitions make it slightly denser than necessary.

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

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

With no output schema, the description partially compensates by describing return item types and ordering. It remains incomplete on deeper pagination behavior and attachment fields, but for a read tool with complete annotations and a fully documented input schema, it gives an agent enough to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents both parameters, including the uuids source and the limit's meaning. The description adds no parameter-level detail beyond restating 'one or more chat streams,' so the baseline 3 is appropriate.

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

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

The description gives a specific verb and resource: 'Read messages in one or more chat streams,' and adds scope via 'newest-last.' It clearly distinguishes the tool from write siblings like remind_send_message, though it does not name alternatives explicitly.

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

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

Usage is implied by 'Read messages in one or more chat streams,' but there is no explicit when-to-use guidance, when-not-to-use guidance, or named alternative. The schema points to remind_list_chats for uuids, but the description itself does not route the agent.

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 establish that this is a read-only, idempotent operation, so the bar is lower. The description still adds meaningful behavior beyond annotations by explaining the `canManage*` flags and the subscriber-account limitation on changes, which is real permission context an agent needs.

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

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

Two tightly written sentences that front-load the resource and its contents, then add the permission caveat. Every clause is informative and nothing is repeated from structured fields.

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

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

With no output schema but zero parameters, the description carries the full burden of explaining the return shape, and it does so by naming the preference categories and device types returned. The permission semantics round out what an agent needs to interpret the response correctly.

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

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

The tool takes zero parameters, so the baseline is 4. There are no parameter names or formats to clarify, and the description correctly does not waste space on non-existent inputs.

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

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

States a specific verb (Get) and resource (notification settings), and enumerates the exact sub-settings returned (reply/announcement-copy/incoming-call preferences, delivery devices). It does not explicitly contrast itself with the sibling `remind_set_notification_devices`, so it stops short of the sibling-differentiation bar for 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 description never states when to call this tool versus alternatives such as `remind_set_notification_devices`, nor does it give any prerequisite or timing guidance. Usage is only implied by the verb 'Get', which is not enough for a 3.

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 readOnlyHint annotation, the description discloses three non-obvious behaviors: introspection is enabled, mutations are rejected, and unknown fields surface as a 500-backed GRAPHQL_VALIDATION_FAILED rather than a normal field error. The error-shape warning is exactly the kind of operational detail annotations cannot convey.

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, front-loaded with the core capability, then the introspection affordance, then the write-boundary and error caveat. Every sentence carries a distinct operational fact and none is padding.

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 raw-query escape hatch whose return shape is defined by the caller's own query, the definition covers the constraints an agent needs: read-only scope, introspection availability, the write alternative, and the unusual error semantics. No output schema is required since responses are arbitrary by design.

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

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

Schema description coverage is 100% and both parameters (query, variables) are documented in the schema, so baseline 3 applies. The description adds GraphQL syntax examples for the query string, but nothing about how variables bind to the document, so it is largely redundant with 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?

States a specific verb and resource ('Run an arbitrary READ-ONLY GraphQL query against Remind's API') and immediately differentiates from the typed sibling tools by noting it reaches fields 'the typed tools do not expose'. An agent can distinguish this escape hatch from remind_get_classes, remind_list_chats, etc. without reading any schema.

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

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

Explicitly scopes when to use it (introspection-based field discovery) and when not to (mutations are rejected), directing writes to the write tools and noting those preview and confirm. The alternative path is named, not left to inference.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description still adds real behavioral value by disclosing the mechanism (an actual authenticated query against the live session) and the reported outcome (auth still valid or not), which is not in the annotations or schema.

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

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

Two short sentences, front-loaded with the action and followed by the reported result. No filler, no repetition of the title.

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

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

For a zero-parameter, annotated, no-output-schema healthcheck, the description covers what it does and what it reports. A minor gap is that it does not say what the agent should do on failure (e.g., re-auth flow), but nothing essential to invoking it correctly is missing.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to clarify or compensate for, and it does not add any misleading param behavior.

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

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

States a specific verb and resource ('Verify the Remind session', 'healthcheck via smallest authenticated query') and explains the outcome it reports. It is readily distinguishable from sibling tools like remind_graphql or remind_list_chats, which perform real work rather than a connectivity/auth probe.

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 makes the usage context clear ('verify the session end-to-end', 'whether the captured browser session still authenticates'), which implies running it before/after other Remind calls when auth is in doubt. It does not, however, name explicit alternatives or state when not to use it, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds genuinely useful behavior the annotations do not: the payload includes unread counts, member counts, last-updated timestamps and per-stream permissions such as canSend, which is valuable given no output schema exists.

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

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

Two sentences with zero filler; the resource and its returned fields come first, followed by the filtering options. Every clause carries 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?

With no output schema, the description usefully enumerates what comes back, and the read-only/idempotent annotations mean no mutation caveats are needed. It falls slightly short on ordering, pagination, and the default behavior when no filter is supplied.

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

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

Schema description coverage is 100%, so all three parameters (query, uuids, class_id) are already documented in the schema. The description only echoes those filters in prose and adds no syntax, matching behavior, or precedence rules, so the baseline 3 applies.

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

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

States a specific verb and resource ('List conversation streams') and even enumerates the salient return fields (unread counts, member counts, last-updated, per-stream permissions). It is clearly distinct from remind_get_messages or remind_send_message, though it never names a sibling to route against.

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

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

The second sentence ('Filter to specific uuids, a class, or a search string') implies when to narrow results, but it merely restates the three schema parameters rather than saying when to prefer this tool over remind_get_messages or remind_list_entities. No exclusions or prerequisites are given.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds useful context beyond that: results include unread counts, mirror the app's rendering, expose uuids for downstream tools, and support cursor paging.

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 with zero waste; the core purpose and entry-point role are front-loaded before the filtering and paging notes.

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

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

No output schema exists, but the description covers the essentials an agent needs: what is returned (classes, chats, unread counts), that uuids feed other tools, and how to page. A little more on return ordering or result size would make it fully self-contained.

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 100% schema description coverage, the schema already documents both parameters. The description reiterates the query filter and cursor paging in prose without adding format, syntax, or edge-case detail beyond the schema, so the baseline of 3 applies.

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

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

The description names a specific verb and resource ("List everything in the Remind sidebar — classes and chats") and clarifies scope ("as the app itself renders it, with unread counts"). It implicitly distinguishes itself from siblings like remind_get_classes and remind_list_chats by being the combined entry point.

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?

"This is the entry point: it yields the uuids the other tools take" gives clear when-to-use context and explains its role relative to the other tools. It stops short of explicit exclusions (e.g., when to prefer remind_get_classes or remind_list_chats directly).

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 and idempotentHint, so the safety profile is covered. The description adds genuine value beyond that by disclosing the returned fields (uuid, name, email, locale, admin/child flags, sign-in count), which is important since there is no output schema. It stops short of mentioning auth requirements or rate limits.

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

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

A single tight sentence that front-loads the action and resource, then lists return fields without waste. Every clause earns its place and nothing is repeated from the schema or annotations.

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

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

With no output schema, the description carries the burden of telling the agent what comes back, and it does so with a concrete field list. It is nearly complete for a zero-parameter read, though it omits any mention of error behavior or whether the response is a single object.

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

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

The tool takes zero parameters, which is the baseline 4 case; there is nothing for the description to clarify and it correctly avoids inventing parameter guidance. It stays focused on the resource rather than padding with irrelevant input 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 gives a specific verb ('Get') and resource ('the signed-in Remind account') and even enumerates the fields returned, which is far more informative than the ambiguous tool name 'remind_me' suggests. It does not explicitly contrast itself with siblings like remind_get_classes or remind_graphql, so it falls short of a 5.

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

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

There is no statement of when to use this tool versus the many sibling read tools, no prerequisites, and no exclusions. The phrase 'signed-in' hints that it returns the current user's own profile, but the agent must infer that this is the tool for identity/account context rather than anything explicit.

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

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

Goes well beyond the destructiveHint=true annotation by disclosing that the action CANNOT be unsent, that nothing is sent until confirmed, that a preview shows the exact payload, and how the two-step confirmToken fallback works. This is exactly the kind of irreversibility and auth/permission context an agent needs.

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?

Front-loads the action and the irreversibility warning, then layers the confirmation mechanics and the permission prerequisite. Every sentence carries functional information 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?

For a destructive send tool with no output schema, the description covers the confirmation protocol, the non-reversibility, the token fallback, and the pre-flight permission check. Nothing an agent needs to invoke this safely is missing.

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

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

Schema description coverage is 100%, so the schema already documents body, urgent, recipient_type, recipient_uuid and the confirmToken contract in detail. The description adds the permission pre-check context for the recipient but no additional parameter syntax or semantics beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Send a message to a chat stream or class') plus the delivery target distinction. It effectively separates itself from read-oriented siblings such as remind_get_messages by making clear this is an outbound send to real people.

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 prerequisites and sequencing: check `permissions.canSend` on the target first (via remind_list_chats), then confirm before sending. It also names the fallback path (confirmToken) and the MCP_CONFIRM_MODE condition that selects between confirmation mechanisms.

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 only readOnlyHint=false and destructiveHint=false; the description adds substantial behavior beyond that — the preview of the exact mutation input, the no-op-until-confirmed guarantee, and the two-phase confirmToken protocol with explicit prohibitions (never on first call, never invented, never reused).

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?

Front-loads the core action and the id source, then layers the confirmation semantics. Dense but every clause carries a constraint; the parenthetical mode reference is the only slight compression cost, keeping it just short of a 5.

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

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

For a zero-required-param toggle with no output schema, the description covers the full call lifecycle: id sourcing, preview behavior, both confirmation routes, and token handling. An agent has everything needed to invoke it correctly on the first attempt.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds framing the schema cannot: that confirmToken belongs only to the elicitation-less fallback, must be supplied with identical arguments on the second call, and is ignored when elicitation exists. That meaningfully shapes how the parameter is used rather than merely restating it.

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

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

States a specific verb pair (enable/disable) and resource (notification delivery devices), keyed by id, and names the sibling tool (remind_get_notification_settings) where those ids come from. An agent can distinguish it from peers like remind_get_notification_settings or remind_send_message at a glance.

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

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

Explicitly tells the agent where to obtain the device ids, that nothing is sent until confirmed, and gives the two alternative confirmation paths (native prompt vs. preview + confirmToken retry). The conditional 'otherwise' clause names the fallback and the governing mode.

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