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

The description discloses important behaviors: 'Never waits' indicates an asynchronous operation, and it explains group token behavior (appends to all instances unless narrowed with 'instances'). It also clarifies that subtasks are answered independently and how to retrieve them.

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 paragraph with about four sentences, conveying necessary context without excessive verbosity. It is well-structured, though longer than the ideal two-sentence example.

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

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

The description covers key usage context: how to reference the original task, how to narrow instances, and how to retrieve subtask responses. It omits error conditions and return values, but these are not required for basic usage and the description is sufficiently complete for an agent to call the tool correctly.

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

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

The schema provides 100% coverage with detailed descriptions for all parameters. The tool description adds general context about append_token and instances but does not offer additional semantic clarity beyond the schema's own descriptions for individual parameters.

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

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

The description clearly states the tool's purpose: adding a follow-up question or checklist item to a task created by send_task. It explicitly identifies the resource (tasks/groups) and the scope (single task or specific instances).

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

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

The description provides context by referencing send_task and explaining how to read subtask responses via get_task or get_group_status. It does not explicitly name alternative tools, but the relationship to send_task and retrieval is clear enough to infer appropriate usage.

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

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

With no annotations, the description carries the burden of side-effect disclosure, and it does so thoroughly: pending recipients see the item as canceled, prior answers remain, group cancellation cascades to still-pending instances and reports a finished count, and the action is irreversible. These are substantive behavioral details beyond the schema.

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

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

Three short sentences carry the action, resource types, key side effects, and an irreversibility warning without repetition. The most load-bearing information is front-loaded.

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

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

For a tool with no annotations and no output schema, the description covers the main semantics: what gets canceled, what happens to recipients, group behavior, and non-reversibility. It stops short of specifying exact return/error behavior, but the core call decision is well supported.

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

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

Schema coverage is 100%, so the baseline is 3, and the description adds extra meaning by explaining the significance of id types, especially that canceling a group_id cancels all still-pending instances and reports already-finished ones. The note, reason, and superseded_by parameters are left to the already-complete schema.

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

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

The description opens with a specific action, "Withdraw something sent earlier," and names the exact resource forms accepted: tsk_, sub_, and grptsk_ ids. This clearly identifies the tool as a cancellation operation and distinguishes it from siblings like send_task and append_subtask.

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 when-to-use context: withdraw something already sent, and it clarifies that pending recipients can no longer answer while existing answers are preserved. It also warns that the operation is not undoable, which is a useful usage caution, though it does not name explicit alternative tools.

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

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

With no annotations, the description carries the full burden and does so well. It discloses the inline return for images, the short-lived download URL plus metadata for other files, and the required 'files:read' scope. This goes beyond a basic action statement.

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

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

Three sentences, each earning its place: what it fetches, how results are returned, and what permission is needed. The most important information is front-loaded.

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

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

For a two-parameter tool with no output schema and no annotations, the description covers the essential invocation details, return behavior, and auth requirement. The only minor gap is the vague 'plus metadata' and no mention of failure modes, but these are not critical for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description's phrase 'the id of what holds it and the id of the file' loosely maps to scope_id and file_id but adds no new detail beyond the already detailed schema descriptions with concrete id prefixes.

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

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

The description opens with a specific verb ('Fetches') and a clear resource ('photo, voice recording or file'), and identifies the exact id pair needed. It also distinguishes the tool from the sibling list by focusing on media/file download rather than task or submission management.

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

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

The context of use is implied: call it when you hold a scope_id and file_id and need the actual photo/recording/file. However, there is no explicit guidance about when not to use it or which alternative to choose, despite a list of sibling tools.

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

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

With no annotations, the description carries the full burden and does so well. It discloses the default 7-day window, the specific categories included (open/declined/expired tasks, answers, replies, declines, cancellations, ad-hoc submissions), and the org-vs-member scoping behavior. This goes well beyond a generic 'returns activity' statement.

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

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

Three sentences, with the most important guidance front-loaded ('Use this first'). Every sentence adds value: example intents, returned bundle, default window, and scoping rule. No filler or redundancy.

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

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

There is no output schema, so the description appropriately explains the return contents: tasks, answers, replies, declines, cancellations, and ad-hoc submissions with who and when. Combined with default behavior and member omission semantics, an agent has enough to invoke the tool correctly without further inference.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's 'Defaults to the last 7 days' and 'Omit member for the whole organization' restate what the schema already documents rather than adding meaning beyond it.

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

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

The description clearly states a broad, catch-all purpose ('Use this first') and enumerates the exact intents it covers, from 'any problems with <member>?' to 'anything I should know?'. It also spells out the bundled resource types returned, which distinguishes it from targeted siblings like query_tasks or get_task.

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

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

The description gives explicit when-to-use guidance with concrete example questions and explicitly says to omit member for the whole organization. It does not name specific sibling alternatives or state when not to use it, but 'Use this first' clearly communicates priority among the broader toolset.

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 are absent, so the description must carry the full burden. It discloses the output shape (one summary per recipient plus count per status) but does not explicitly state that the operation is read-only or free of side effects. Given the 'get' prefix, agents may infer safety, but the description does not confirm it, and it also omits any mention of required permissions or return errors.

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

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

The description is a single, densely packed sentence that leads with the core purpose, then explains the input source and output format. No wasted words; every clause adds information. It is 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?

With no output schema, the description is responsible for explaining return values, which it does by specifying 'one summary per recipient plus a count per status.' It covers the essential input group id and the optional status filter. Minor gaps include lack of detail on the exact summary structure or any pagination, but for a tool with only 2 parameters, this is 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 100%, so the baseline is 3. The description adds value by explaining that group_id is a grptsk_ group id originating from query_tasks, which the schema does not state. It also implies the status array filters results by state, reinforcing the schema's description. This additional context enhances the agent's understanding beyond the schema.

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

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

The description clearly states the tool answers 'who has answered and who has not' for a task sent to multiple people, and specifies the input type (grptsk_ group id) and output (per-recipient summary plus count per status). This verb+resource is specific and distinguishes it from siblings like get_task or get_task_answer, which focus on single tasks or answers rather than group status.

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

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

The description gives clear context by linking the group id to query_tasks, implying when to use the tool (when you have a grptsk_ id from a multi-recipient task). It does not explicitly state when not to use alternatives, but the purpose is self-explanatory enough to route the agent. No misleading or absent guidance.

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

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

The description discloses return states (pick, pending, delivered) but does not mention side effects or error behavior. As a read operation, it is implicitly safe, but transparency could be improved by explicitly stating it has no 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 concise and well-structured, with the purpose stated first and sufficient detail for the single parameter.

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

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

The description covers the necessary context for a simple tool: how to obtain the parameter and what the return states mean. It could be slightly clearer about the 'delivered' state, but overall it is complete for the tool's complexity.

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

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

The description and schema fully explain the notification_id parameter, including its origin (returned by send_notification). This is unambiguous and 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?

The description clearly states the tool's function: checking whether a notification sent via send_notification has been answered and retrieving the answer. It identifies the resource and action 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 implies when to use it (after send_notification, passing the returned notification_id) and explains result states. It does not explicitly contrast with alternative tools, but the context is sufficient for appropriate usage.

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

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

No annotations are provided, so the description carries the full burden. It discloses the full behavioral scope: the complete task content, subtasks, answers, replies, declines, uploads with inputId, and reply files with id. It also reveals the group-behavior nuance (grptsk_ groupId) and the fact that files are intended for download_attachment. It does not discuss errors, permissions, or side effects, but the read-only nature is clear from 'Read' and 'get'.

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

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

Three sentences with no filler. The opening sentence states the purpose, the second enumerates the returned content compactly, and the third gives follow-up guidance. The most decision-relevant information is front-loaded.

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

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

For a tool with only one required parameter and no output schema, the description covers prerequisites, return content, file-id semantics, and a group-copy follow-up. It does not specify the exact response structure, but the enumerated content types give an agent enough to invoke the tool and interpret the result.

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

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

Schema coverage is 100% and the schema already documents task_id as 'The tsk_ id.' The description adds meaningful provenance guidance: the task_id comes from query_tasks or get_activity, and the grptsk_ groupId context clarifies multi-recipient tasks. This goes beyond the bare schema, so a slightly-above-baseline score is warranted.

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

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

The description clearly identifies the resource: one task plus every appended subtask. It states a specific verb ('Answers') and scope ('what exactly was asked and answered'), and enumerates the content categories (questions, answers, replies, declines, uploads, reply files), which distinguishes it from listing tools like query_tasks and narrower tools like get_task_answer.

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

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

The description gives explicit context: use after query_tasks or get_activity has identified the task. It also routes the agent to get_group_status when the task has a grptsk_ groupId, naming a concrete follow-up alternative. It does not explicitly say when not to use this tool in favor of get_task_answer, so it stops short of perfect exclusion guidance.

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

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

With no annotations, the description carries the behavioral disclosure burden. It explains return states (answer vs. pending), the parent-task naming behavior for subtasks, and the inputId for media attachments. It does not explicitly state that this is a read-only operation, but the verb "Check whether" strongly implies it.

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

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

The description is compact and every sentence earns its place: purpose, parameter constraint, return behavior, media-attachment note, and alternative routing. The most important scoping information is front-loaded.

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

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

Given there is no output schema and no annotations, the description compensates well. It covers invocation constraints, expected return values, the pending state, subtask-specific behavior, media attachment handling, and the relevant sibling alternative. An agent has enough to select and call this tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantics beyond the schema by explaining the relationship between task_id/subtask_id and their originating tools (send_task/append_subtask), and by imposing the crucial exactly-one constraint that the schema itself does not encode.

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

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

The description begins with a specific verb ("Check whether") and names the exact resource (the answer to a task sent via send_task or a subtask appended via append_subtask). It distinguishes itself from get_task by clarifying scope: answer to a single task/subtask vs. whole task including subtasks.

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

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

It explicitly states "Pass exactly one of task_id or subtask_id," which is critical guidance given both parameters are optional in the schema. It also names the alternative tool get_task and gives the exact condition for using it instead: when the whole task including every subtask is needed.

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

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

With no annotations, the description carries the full burden. It discloses read-only intent through "Read" and "Answers what happened," plus ordering (oldest first), default time window (last 7 days), and data coverage. It does not describe the response envelope or pagination, but the schema already documents limit and cursor, so the gap is minor.

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?

Every sentence earns its place: primary purpose, sibling exclusion, default behavior, filter options, and alternative routing. The most decision-relevant information is front-loaded before the filter details.

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 query tool with no annotations and no output schema, the description covers what events are returned, who and when is included, ordering, default range, filter dimensions, and which sibling tools to use instead. Pagination details are already in the schema, so nothing essential for invoking the tool is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by enumerating actual event type wire names, clarifying that filtering works by member or event type, and implying the meaning of the default since/until window. These details go slightly beyond the bare schema descriptions.

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 "Answers 'what happened'" and clearly identifies the tool as the organization's activity history. It names specific event types and makes the distinction from query_tasks explicit, so an agent can tell exactly what this tool is for.

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

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

It explicitly states this is where problems surface, that query_tasks does not contain them, and provides routing to alternatives: use get_activity for a ready-made per-member bundle and query_submissions for ad-hoc reports alone. This gives clear when-to-use and when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses ordering ('Oldest first'), the default time window ('defaults to the last 7 days'), supported content types, and the attachment-id convention for download_attachment. It could additionally state read-only behavior more explicitly, but the title and content make it sufficiently clear.

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

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

Three sentences, front-loaded with the core intent, then scope, ordering/default, and attachment integration. Every sentence contributes distinct information with no filler or repetition of schema content.

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

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

The tool is a low-complexity read-only list operation. The description covers what the response contains, ordering, default date filtering, and downstream attachment retrieval. Pagination details are already covered in the schema descriptions, and no output schema exists, so the description sufficiently fills that gap.

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

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

The schema already describes all five parameters at 100% coverage, so the baseline is 3. The description adds useful semantic context beyond the schema by stating the default date range ('defaults to the last 7 days') and explaining how returned photo/file ids relate to download_attachment via scope_id. This is meaningful but modest extra value.

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

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

The description uses a specific verb ('query/read'), names the resource (ad-hoc submissions reported by people on their own), and clearly distinguishes this from task answers: 'not answers to a task' and 'the task index never shows these.' An agent can immediately tell this apart from query_tasks and get_task_answer.

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

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

It explicitly says when to use the tool: 'Check this whenever a question is about problems or reports.' It also gives a when-not: 'not answers to a task,' and explains why alternatives won't work: 'the task index never shows these.' This is strong routing guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses meaningful traits: status-only output, no answer content, one page of summaries, newest-first ordering, and exact returned fields. It does not mention pagination or auth, but those are partly covered by the schema and not essential for a read-style query.

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

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

The description is three dense sentences with no filler. It front-loads the core answer, then gives the exclusion, then the compact field/filter list. The length is justified by the need to describe a return shape in the absence of an output 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?

With no output schema, the description fully enumerates the returned fields and ordering. It names all filter dimensions, explicitly lists sibling alternatives, and leaves pagination to the already-detailed schema properties. An agent has enough to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds high-level filter grouping ('status, time window, topic, member, or group') but no syntax or format details beyond what the schema already provides.

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

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

The first sentence states the exact question the tool answers: 'which tasks are open, expired, declined or done, and who has them'. It also explicitly contrasts itself with siblings by saying it never shows answers/reports, which clearly distinguishes it from get_task, query_events, and get_activity.

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 tells the agent when not to use this tool: if answer or report content is needed, use get_task, query_events, or get_activity. It also summarizes the available filters, giving clear context for selecting this tool over alternatives.

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

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

With no annotations, the description carries the full burden and delivers extensively: stemming behavior depends on org config, multiple words must all appear, phrases require quoting, location-only results are sorted nearest-first, combined query+radius filters hits by in-radius points, and encrypted records are not searchable. This is far beyond minimal disclosure.

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

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

The description is dense but every sentence earns its place, moving from scope to matching behavior to location modes to hit payloads and limitations. Front-loaded with the most important search intent and progressively detailing edge cases, it avoids filler while fully covering a complex 9-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 complex tool with no output schema and no annotations, the description is unusually complete: it explains result IDs and how to follow up with get_task/get_group_status/get_notification_answer/query_submissions, describes snippets and location-hit payloads, covers ranking order in both circle and polygon modes, and flags non-searchable encrypted records. An agent has enough to invoke it correctly.

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

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

Schema coverage is 100%, but the description adds substantial operational meaning: how query matching works, when center/radius_meters alone or combined with query changes result semantics, polygon use and ordering, snippet composition, and practical advice like preferring generous radii for geocoded coordinates. This goes well beyond the schema's bare field definitions.

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 a clear verb and resource: full-text and location search over all records this credential reads, listing task titles/content, answers, replies, notifications, and submissions. It also distinguishes itself from siblings by positioning itself as the broad 'search everything' entry point rather than a narrower query_tasks/query_submissions-style tool.

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

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

The description gives explicit use cases: 'anything about X?', 'what was said about X?', and 'who mentioned X?', plus clear guidance for location search. It references the getter siblings for reading full hits and advises resolving coordinates first, but it does not explicitly say when not to use this tool versus targeted alternatives like query_tasks.

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

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

With no annotations provided, the description carries the full burden and excels. It details default return behavior (immediate vs. waiting), per-recipient copies vs. shared, how results identify each recipient (one notification_id per person), and timeout behavior (marks who has not answered). It also notes availability restrictions for member and broadcast in personal mode.

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 information-dense yet well-organized, moving from purpose to behavioral nuances to parameter guidance. Every sentence contributes unique value—no repetition or filler—and the flow is logical, making it easy for an agent to parse and apply.

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

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

Given the tool's complexity (10 parameters, nested input object), the description is complete. It covers all relevant aspects: purpose, when to use alternatives, return behavior, input types, shared semantics, and usage restrictions. It even describes what the result will contain, compensating for the lack of an output schema.

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

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

The description adds meaning beyond the schema by explaining the input oneOf variants (text, choice, actions) and their behavior (e.g., 'tapping one answers with its key'). It clarifies shared semantics ('one person's input answer resolves it for all') and wait_seconds behavior, all supplementing the schema's property descriptions.

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 push notification to phones') and clearly distinguishes it from send_task by explaining that notifications are for alerts/heads-ups, not questions that must be answered. This makes the tool's purpose unambiguous and differentiates it from sibling tools.

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

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

The description explicitly tells the agent when to use this tool versus send_task ('For a question that needs an answer, a photo, file, location, slider or several inputs, use send_task'). It also explains how to get answers later (get_notification_answer) and how to wait synchronously (wait_seconds), covering both usage patterns and alternatives.

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 exist, so description carries the burden. It discloses that a timeout is not cancellation, tasks stay live, unanswered recipients are marked pending, `shared: true` resolves on first answer, and every result carries an append_token — genuinely useful behavioral facts beyond 'creates a task'.

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

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

Four dense sentences, front-loaded with the core action and then adding mode/wait/append semantics in a logical order. No filler or repetition of schema field names.

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

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

For a 14-parameter write tool with no output schema and no annotations, it covers the send/wait/timeout lifecycle well and mentions per-recipient results and append_token. It still leaves recipient-targeting mechanics (topic/member/broadcast) and the exact result payload mostly to the schema, which is a minor gap at this complexity.

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

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

Schema already covers 100% of parameters, so baseline is 3; the description adds real cross-parameter meaning (content vs inputs, reply thread behavior, shared semantics, wait_seconds timeout semantics). It does not walk through every parameter, but it clearly compensates for the most decision-critical ones.

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

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

States a concrete action ('Create a task on people's phones and wait for the answers') and scopes the resource type via the title/description (a question, form or checklist item), which is distinct from notification-style siblings. The `content` vs `inputs` split and per-recipient vs shared mode make the tool's purpose unmistakable.

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

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

Provides clear decision context: default per-recipient copies vs `shared: true` for matters one answer settles, and points to get_group_status/get_task_answer for late answers. It does not explicitly contrast with send_notification or state when not to use the tool, so not a full 5.

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