Queue

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds scope context by clarifying this is a container, not an approval of promises. It does not address the idempotency behavior (duplicate names) or permission requirements, so it adds only modest value beyond the annotations.

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

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

Two tight sentences, front-loaded with the core action and immediately followed by the scoping exclusion. No filler or repetition; every clause earns its place.

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

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

An output schema exists, so return values need not be explained. But with 0% schema coverage on the parameters, the description leaves a real gap for a create tool whose inputs are entirely undocumented. It is complete on purpose/scope but not on parameters.

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 schema contributes no meaning for the two parameters (name, description). The description must therefore compensate, but it never mentions either parameter, their constraints, or format expectations, leaving the agent with no semantic guidance.

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+resource ('Create a response catalog') and further scopes it as 'a new home for approved support response times.' It also distinguishes itself from adjacent write tools by naming what it does NOT do (approve a reply window, channel, or staffing promise), which maps to siblings like save_reply_window and save_staffing_promise.

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

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

Gives an implied trigger ('when the user asks for a new home for approved support response times') and implicitly routes the reader away from reply-window/channel/staffing-promise approval. However, it never names the alternative tool (e.g., save_reply_window, list_response_catalogs) or states the condition that selects this tool over its siblings explicitly.

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

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

Annotations already declare readOnly, idempotent, non-destructive, so the safety profile is covered. The description adds decision semantics ('REFUSED means do not offer it', OFFER_* refuse things the plan lacks), which is useful, but since an output schema exists the return shape is already handled and no auth/rate-limit context is added.

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

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

Four tight sentences, front-loaded with the core decision, with no padding. The only cost is that 'REFUSED' is referenced before its meaning or source is established, making the opening slightly opaque.

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 5 parameters, three enums, conditional input requirements, and 0% schema coverage, the description is too thin. It covers the action-level semantics but omits the parameter-to-action mapping and any prerequisite context an agent needs to invoke it correctly.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate and largely does not. It never mentions catalogId, planId, or the conditional requirements (channel for OFFER_CHANNEL, staffingKind for OFFER_STAFFING), leaving the agent to infer which inputs are needed for which action.

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 ('Decide') and resource (plan coverage of reply window, channel, staffing promise), which maps onto the three action enum values. It is distinguishable from the list_* siblings, though the framing is terse and relies on jargon (REFUSED) that is not defined.

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 routes the agent to a sibling: 'Permission to state wording still requires evaluate_support_promise for the exact text,' and gives an action rule ('REFUSED means do not offer it'). It does not say when to prefer this over list_plan_channels or how the three actions map to required inputs, so it stops 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 this a read-only, idempotent, closed-world evaluation, so the safety profile needs no restating. The description earns its keep by adding the verdict semantics that annotations cannot express: REFUSED forbids uttering the claim, no substitutes may be invented, and APPROVED restricts wording to sayOnly. That is meaningful operational context beyond the structured fields.

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, front-loaded with the decision being made, then the two verdict semantics. Nothing is padding, though the 'Do not promise a faster reply, a dedicated agent...' clause overlaps with the REFUSED rule and could be tightened.

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?

An output schema exists, so return values need no prose, and the outcome vocabulary is well covered. However, for a four-required-parameter tool with zero schema description coverage and two confusable UUID identifiers, the description leaves an agent unsure how to construct a valid call. The refusal semantics are complete; the invocation contract is not.

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 carries the full burden for four required parameters and it does not meet it. 'Reply window, channel, or staffing promise' loosely maps to the kind enum and proposal, but catalogId and planId (both UUIDs, with planId merely $ref-ing catalogId) are left entirely unexplained — an agent has no way to tell them apart or know what the proposal string should contain.

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: 'Decide whether a proposed reply window, channel, or staffing promise is in the approved set for this customer plan.' That is far more precise than the name alone and separates this evaluation tool from the listing/saving siblings. It stops short of naming the adjacent evaluator (evaluate_plan_coverage), so an agent must infer the boundary.

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: call this to test a proposed promise against the approved set. The description explains what the outcomes mean afterward but never states when to choose this over evaluate_plan_coverage, nor any preconditions (e.g., that a plan and catalog must exist first). Adequate but inferential.

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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world). The description adds non-obvious behavioral guidance: results are evidence not permission, a missing plan must not be used to invent faster replies or channels, and evaluate_support_promise must gate any claim. That is genuine added context beyond the structured hints.

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

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

Four short sentences, front-loaded with the primary action before the constraints. Each sentence carries a distinct point (what it returns, what it is not, what a miss means, what to call next), 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?

The output schema exists, so return values need no explanation, and the anti-hallucination guidance is strong. The gap is on the input side: with 0% schema coverage, the description says nothing about catalogId, question format, or the limit parameter, leaving invocation details underspecified.

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% across three parameters, so the description must compensate and largely does not. 'Question' is only loosely implied by 'match a support question,' and catalogId and the limit/pagination behavior are entirely undocumented in both schema and description.

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

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

States a specific verb ('Retrieve') and resource ('customer plans that match a support question') and enumerates the related artifacts returned (reply windows, channels, staffing promises). It is clear on its own, but never distinguishes itself from the sibling search_customer_plans, which sounds like it does something similar.

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

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

Gives a concrete follow-up rule: 'Call evaluate_support_promise before stating any of them,' and frames the output as evidence rather than permission. It does not, however, say when to prefer this tool over search_customer_plans or the list_* siblings.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is low. The description still adds a genuinely non-obvious rule: the returned list is exhaustive and absence implies exclusion, which changes how an agent should reason about the result.

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, front-loaded sentences with no filler. The last two sentences restate the same closed-world idea (exclusion semantics plus the action derived from it), so there is slight redundancy, but nothing is padded.

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?

An output schema exists, so return-value explanation is rightly absent. However, for a 3-parameter tool with 0% schema coverage, the description should at least clarify includeRetired and whether the list is paginated; those gaps leave it only minimally adequate.

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

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

Schema description coverage is 0% and the description adds nothing about the three parameters. 'On one customer plan' loosely implies planId, but catalogId and especially includeRetired (default false) are entirely unexplained in both schema and description, leaving the agent guessing about retired channels.

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 (read) and resource (channels included on one customer plan), which is enough to distinguish it from the write sibling save_plan_channel and the listing siblings list_reply_windows / list_response_catalogs. It does not explicitly name an alternative tool, 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 only guidance is a downstream behavioral directive ('a channel that is not listed is not included. Do not offer it'), which tells the agent how to treat results, not when to choose this tool over evaluate_plan_coverage, list_response_catalogs, or search_customer_plans. No prerequisites, no when-not conditions, no alternative named.

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 annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds a real interpretive constraint ('listing them does not approve a faster reply'), which is useful context beyond the annotations, but it says nothing about pagination, result volume, missing/retired windows, or authorization 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?

Three short sentences, front-loaded with the core action, and each sentence carries distinct information. Minor inefficiency in the slightly indirect phrasing of the second and third sentences, but nothing is wasted.

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?

An output schema exists, so return-value documentation is not required, and the safety profile is carried by annotations. The remaining gap is parameter semantics: with 0% schema coverage and an undocumented includeRetired filter, an agent cannot fully predict how filtering works. Adequate but incomplete for a 3-parameter tool.

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

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

Schema description coverage is 0% across three parameters, so the description must compensate and largely does not. It only implies the plan scoping that catalogId + planId represent, and gives no hint at all about includeRetired (default false) or why both a catalog and a plan identifier are required.

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

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

The description gives a specific verb and resource ('Read reply windows') plus scope ('for one customer plan'), which cleanly separates it from the write sibling save_reply_window. It stops short of explicitly distinguishing itself from other list_* siblings such as list_plan_channels or list_response_catalogs, so it is clear but not fully differentiating.

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

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

It provides concrete when-to-use guidance by naming an alternative path: call evaluate_support_promise with the exact wording before promising a faster reply. However, it offers no guidance on when listing is the right initial step versus other read tools, and no preconditions for the catalogId/planId pair.

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, idempotentHint=true, destructiveHint=false and closed-world, so safety is covered structurally. The description adds the workflow rule that ids must come from this call rather than being guessed, which is genuinely useful context, but it says nothing about pagination limits or result size.

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 very short sentences with the core action front-loaded and the constraint ('do not guess') placed last as a caution. Nothing is wasted, though it is arguably terse to the point of omitting needed detail.

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?

An output schema exists, so return values need not be explained, and the safety profile is carried by annotations. Still, for a paginated list tool the description omits how to page and what the id is ultimately for, leaving a modest 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 single offset parameter has 0% schema description coverage and no enum; the description never mentions pagination, offset semantics, or what happens beyond the returned page. With no compensating text, an agent cannot infer how to page through 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?

States a specific verb and resource ('List this team's response catalogs') and scopes it to the team, which distinguishes it from the save_/create_ siblings on the same resource family. It does not explicitly contrast with other list_* siblings, but the resource 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?

'Use the returned id. Do not guess a catalog.' implies this is the discovery step that must precede operations requiring a catalog id, which is useful workflow guidance. However, it never states when to prefer this over alternatives or any precondition, so usage remains implied rather than 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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and a closed world, so the safety profile is covered. The description adds one domain constraint (unlisted dedicated agents must not be promised), which is real context, but says nothing about the includeRetired filter's effect or result ordering.

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 core purpose, with no filler. The trailing domain rule is somewhat tangential to the listing operation but is at least substantive.

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?

An output schema exists, so return values need not be described, and annotations cover safety. However, with three undocumented parameters (including a defaulted filter) and no indication of pagination or the meaning of retired promises, the definition is thin for the tool's surface.

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

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

Schema description coverage is 0%, so the description carries the full burden and fails: planId and catalogId are never explained, and includeRetired (default false) is undocumented, leaving the agent to guess what 'retired' promises are and whether they appear by default.

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 staffing promises') and scopes it to 'one customer plan', which distinguishes it from save_staffing_promise (write) and the plan-level evaluators. It does not explicitly contrast itself with siblings, but the read+resource pairing 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?

There is no guidance on when to call this versus evaluate_support_promise, save_staffing_promise, or evaluate_plan_coverage. The second sentence is a business rule about dedicated agents, not a usage condition or exclusion that helps select the tool.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, but the description adds concrete detail beyond them: identical retries keep the same revision, and a changed plan requires expectedRevision from a previous read (optimistic concurrency). This is genuinely useful behavioral context the annotations don't 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?

Four short sentences, front-loaded with the core purpose before the definition, idempotency note, and concurrency requirement. Little waste, though the 'set of reply windows, channels, and staffing promises' sentence is definitional padding that 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?

An output schema exists, so return values need no explanation, and the description covers the approval precondition, idempotency, and concurrency requirement. The main gap is per-parameter documentation, but that is scored separately under parameter semantics.

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%, so the description carries the full burden. It explains expectedRevision well ('from a previous read,' required for changed plans), which is the trickiest parameter, but says nothing about name, summary, catalogId, or status. Only one of five parameters gains meaning beyond the schema, so it 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?

States a specific verb+resource ('Store or revise a customer plan') and further defines the resource as the aggregate of 'reply windows, channels, and staffing promises,' which implicitly distinguishes it from the component-level save_plan_channel / save_reply_window / save_staffing_promise siblings. It does not name those siblings explicitly, so the differentiation is inferred rather than stated.

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

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

Gives real preconditions: the plan must be 'explicitly approved,' and a changed plan requires expectedRevision from a prior read. It also notes identical retries are safe. It lacks explicit when-not guidance or naming of alternative tools (e.g. search vs save), so it stops 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 this a non-readOnly, idempotent, destructive write. The description adds useful context beyond that: the statement field is the only channel wording that may later be approved, and unsaved channels are excluded downstream. It stops short of explaining the destructive/idempotent behavior (e.g. overwriting an existing channel entry).

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, front-loaded with purpose, then channel values, then the statement rule and inclusion rule. No filler, though the enum restatement is slightly redundant with 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?

An output schema exists, so return values need not be described. However, with 7 parameters at 0% schema coverage and no mention of the concurrency-control field expectedRevision, the definition is not complete enough for an agent to call this mutation confidently.

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% across 7 parameters, so the description carries the full burden but only touches two of them. It restates the channel enum (already in the schema) and clarifies the statement field's downstream authority, but leaves name, catalogId, planId, status, and especially expectedRevision completely unexplained.

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 gives a specific verb and resource: storing a support channel the user has approved for one customer plan. It clearly reads as the write counterpart to list_plan_channels, though no sibling is named explicitly, so it falls just short of the 5 bar for 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 description supplies a precondition (the channel must be explicitly approved by the user) and a consequence for skipping it (a channel not saved here is not included), which implies when to call it. It does not name an alternative tool or state when NOT to use it, so guidance stays implied rather than 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?

Annotations already declare readOnly=false, destructive=true and idempotent=true, so the safety profile is covered. The description adds genuine domain behavior beyond that: a validation rule ('a statement that promises a shorter wait than withinMinutes is rejected') and the approval semantics of the statement field. It still omits overwrite/upsert behavior and how expectedRevision conflicts are handled, which matters for a destructive write.

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

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

Four short sentences, front-loaded with the core action and its scope, with no filler. The final sentence ('Do not save a faster reply the user did not approve') largely restates the earlier rejection rule, a minor 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?

An output schema exists, so return values need no explanation, and annotations carry the safety profile. But for a 7-parameter destructive write with 0% schema coverage, the description leaves concurrency (expectedRevision), status transitions, and the name field entirely undocumented, which is not quite enough for an agent to call it confidently.

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 carry parameter meaning, and it only covers withinMinutes ('the approved wait'), statement ('the only reply-time wording that may later be approved'), and implicitly the plan reference. The name, status, and expectedRevision parameters are left completely unexplained in both schema and description.

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

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

The description gives a specific verb and resource ('Store the reply window ... for one customer plan'), and the resource noun ('reply window') naturally separates it from the save_customer_plan / save_staffing_promise / save_plan_channel siblings. It does not explicitly name any alternative, 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?

It states a precondition (only what the user explicitly approved) and a prohibition ('Do not save a faster reply the user did not approve'), which implies when this tool is appropriate. However, it never names an alternative sibling or says when to use save_reply_window versus list_reply_windows or save_customer_plan, leaving routing 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 this is a non-read-only, destructive, idempotent write, and "Store" is consistent with that. The description adds the approval precondition and a wording constraint, but it never says what an existing promise for the same plan is replaced with, nor how expectedRevision/conflict behavior works despite destructiveHint=true.

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 purpose and the approval constraint are front-loaded, which is good. However, two of the six sentences are pure tautology ("SHARED_QUEUE is a shared queue. DEDICATED_AGENT is a dedicated agent.") and add no information the enum values don't already convey.

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?

An output schema exists, so return values need no explanation. But for a 7-parameter destructive write, the description omits replace/overwrite semantics and expectedRevision concurrency, which an agent needs to call 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% across 7 parameters, so the description carries the full burden. It only glosses staffingKind ("SHARED_QUEUE is a shared queue" restates the enum rather than explaining it) and hints at statement's role; catalogId, planId, name, status, and expectedRevision are entirely undocumented, leaving the concurrency parameter opaque.

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+resource ("Store a staffing promise") scoped to "one customer plan," which is clear. It does not compare itself to siblings like list_staffing_promises or save_customer_plan, but the purpose itself 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?

It states a real precondition (the promise must be "explicitly approved") and an explicit exclusion ("Do not save a dedicated agent the user did not approve"). It stops short of naming an alternative tool for the cases it excludes, so it is clear context without full routing.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), so the bar is lower; the description still adds genuine behavior: how to interpret an empty result and an explicit warning not to invent reply windows, channels, or staffing promises.

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

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

Four short sentences, front-loaded with the core purpose and no filler. Slightly choppy, but every sentence 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?

An output schema exists so return values need no explanation, but the definition leaves the required catalogId undocumented and does not route the agent among the many plan/channel/promise siblings.

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%, so the description must compensate and only partly does: 'by name or summary' loosely maps to query and 'Page with offset' maps to offset, but the required catalogId and includeRetired are never mentioned.

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 ('look up') and resource ('customer plans') plus the matching surface ('by name or summary'). It is distinguishable from the list_*/save_* siblings, though it never names an alternative 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?

Gives one useful usage rule (an empty result means no approved plan) and a guardrail against fabricating related entities, but never says when to reach for this tool versus list_response_catalogs or get_queue_context.

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