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

The description goes well beyond the annotations, which only indicate readOnlyHint=false and destructiveHint=false. It explicitly warns that this write is UNVERIFIED and instructs the agent to inspect the confirmation preview before approving. It also details the confirmation mechanism, including the confirmToken usage, which is critical behavioral information.

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 yet efficient. It front-loads the primary purpose, then covers confirmation flow, unverified status, and parameter nuance in a well-organized manner. Every sentence carries essential information with no wasted words.

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

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

Given the tool's complexity (confirmation, two-step fallback) and lack of an output schema, the description explains the response flow (preview and confirmToken) and the caution about unverified behavior. It covers what an agent needs to call it correctly, though it does not specify the preview content or success response details, which is acceptable given the unverified nature.

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 schema already documents both parameters. The description adds significant value by explaining the confirmToken's role in the two-step fallback, emphasizing that it must not be invented or reused, and clarifying when it is ignored. This goes beyond the schema's basic 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 clearly states the tool's action: 'Apply a coupon code to the account.' This is a specific verb and resource, and it is distinct from sibling tools like mhlb_apply_gift_card and mhlb_remove_coupon. The purpose is immediately obvious.

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

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

The description provides clear context about the confirmation flow and the two-step fallback, but it does not explicitly state when to use this tool versus alternatives or when not to use it. It implies usage for applying a coupon, but lacks explicit routing to or away from 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?

Beyond annotations, the description discloses critical behavioral context: the confirmation requirement, the two-step token flow, and the important caveat that this write is UNVERIFIED and should be inspected via the preview before approving. This goes well beyond what readOnlyHint/destructiveHint alone 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?

The description is compact and front-loaded: the core action is stated first, followed by the confirmation mechanics and then the unverified-write warning. Every sentence carries necessary information without fluff.

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

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

Despite lacking an output schema, the description explains the essential runtime behavior: confirmation prompt behavior, the preview and confirmToken returned on first call, the repeat-call requirement, and the safety warning. This is sufficient for an agent to invoke the tool correctly and 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 100%, so the schema already documents both 'code' and 'confirmToken' thoroughly. The description reinforces confirmToken's role in the two-step flow, but does not add substantial new parameter meaning 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 description uses a specific verb and resource: 'Redeem a gift card code onto the account balance.' This clearly distinguishes it from siblings like mhlb_list_gift_cards and mhlb_apply_coupon without requiring the agent to infer from the name alone.

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

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

The description clearly states what the tool does and the confirmation flow that must be followed, including the two-step fallback and the MCP_CONFIRM_MODE reference. It does not explicitly name alternatives or when-not-to-use conditions, but the distinct purpose and sibling names make the intended usage clear enough.

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

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

Annotations already mark this as destructive/non-read-only, and the description adds crucial context: it makes a real payment, requires prior checkout initialization, may require a two-step confirmation, and is explicitly marked as UNVERIFIED with a warning to inspect the preview before approving. This is exceptionally transparent about the operation's risk.

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: the core action, prerequisite, card constraint, confirmation behavior, and verification warning are all essential. The description is dense but not bloated, and the safety-critical caveat about the unverified write is included without unnecessary 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 high-stakes payment tool with no output schema and no annotation detail beyond mutability and destructiveness, the description covers prerequisites, confirmation semantics, limitations, and risk warnings. It gives an agent enough to invoke the tool safely and to route the user through the confirmation step properly.

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 each parameter already has detailed meaning in the schema. The description adds some operational context around expectedTotal and the confirmToken flow, but it largely restates what the schema already documents rather than providing substantial new parameter-level insight.

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

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

The description opens with a specific verb and resource: 'PAY for the lunches in the cart' and immediately clarifies the real-world consequence: 'charges a real payment method.' It distinguishes itself from mhlb_init_checkout by requiring that tool as a prerequisite and positioning this one as the actual charging step.

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 workflow instructions: run mhlb_init_checkout first, read the returned total, pass it as expectedTotal, and only use a card already saved on the account. It also clearly states when the tool cannot be used (new card requiring a Stripe token unavailable server-side) and describes the confirmation flow for both supported and unsupported environments.

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 only cover the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true). The description goes well beyond that: it discloses the elicitation vs. two-step confirmation protocol, the preview/confirmToken flow, the MCP_CONFIRM_MODE dependency, and — critically — that the write is UNVERIFIED and derived from a compiled client, advising inspection of the preview. That is exactly the kind of behavioral context annotations cannot provide.

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-loaded with the action and the required prior call, then the payment boundary, then confirmation mechanics, then the verification caveat. Every sentence carries distinct information, though the confirmation/token sentence is dense enough that it could be split for faster scanning.

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, yet the description explains the response shapes that matter — the confirmation prompt, or a preview plus confirmToken — and the precondition call needed to construct the nested `order` object. For a nested-object, open-world write tool, nothing essential is left unspecified.

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 earns above baseline by tying the `order` parameter to its source ('the model returned by mhlb_get_order_form, with quantities and options set') and by adding strict invocation rules for confirmToken — never on first call, never invented, never reused, ignored under elicitation — which reinforce the schema text rather than merely repeating 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+resource ('Place a lunch order into the cart') and immediately scopes it against siblings: it adds to the cart rather than paying, and names mhlb_checkout for payment. An agent can distinguish this from mhlb_get_order_form, mhlb_checkout, and mhlb_update_order without opening 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?

Explicit prerequisites ('Call mhlb_get_order_form first and send that model back with quantities set'), explicit boundaries ('it does not pay; use mhlb_checkout for that'), and explicit when-to-confirm behavior including the token fallback. This is a full routing decision, not an implication.

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 annotations (readOnlyHint=false, destructiveHint=false, openWorldHint=true) by disclosing that the write is UNVERIFIED against a live account, that a confirmation gate exists, how the confirmToken fallback works, and that the preview should be inspected before approving.

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-loaded with the action and prerequisite, then confirmation behavior, then the UNVERIFIED caveat. Slightly dense with parenthetical detail, but every sentence carries information an agent needs before invoking.

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, and the description compensates by describing the phase-1 "confirmation-required" response and confirmToken round-trip, so the agent knows what to expect back. Nothing material is missing for a nested-object write 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 coverage is 100%, so the baseline is 3, but the description adds real semantic value: it explains that `student` is the `data` object returned by mhlb_new_student_form with edits applied, and that confirmToken is only for the no-elicitation fallback and must never be invented or reused.

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 ("Add a student to the account") and immediately disambiguates from the update/delete siblings by positioning it as a create flow fed by a form model. An agent can tell what this does without opening the 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 names the prerequisite sibling (call mhlb_new_student_form first and send that model back), and spells out the confirmation branch: elicitation where supported, otherwise a preview + confirmToken two-step with a pointer to MCP_CONFIRM_MODE.

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

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

The description discloses that refund behavior is outside the tool's control, that confirmation is required, and that the request shape is UNVERIFIED against a live account and was derived from the web app's compiled API client. This meaningfully supplements the annotations' destructiveHint and should change how an agent executes and approves the call.

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 longer than average, but every sentence earns its place: purpose, refund caveat, confirmation mechanics, fallback behavior, and the unverified-write warning. The core action is front-loaded, and the safety warnings appear before an agent would act.

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 write with no output schema, the description explains the full confirmation flow, what a fallback first call returns (preview plus confirmToken), and what to inspect before proceeding. Parameter details are fully covered by the schema, and the annotations cover destructive intent, so no critical operational information 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%, and the parameter-level descriptions are already rich: confirmToken explains the exact two-step protocol, eventDate specifies the format, and isSubscribed gives per-tool defaults. The tool description adds no parameter-specific meaning beyond that, so the baseline 3 for high schema coverage 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 opens with 'Cancel a lunch order', a specific verb and resource that unambiguously defines the operation. It also clarifies scope by noting that refund behavior is external and by distinguishing this cancellation tool from the subscription-focused sibling mhlb_unsubscribe_order.

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 process guidance for confirmation: use the client-supported prompt when available, or the two-step preview/confirmToken fallback otherwise, with explicit rules about never inventing or reusing the token. It does not explicitly enumerate when to prefer this over mhlb_unsubscribe_order, but the schema's isSubscribed description hints at that split, so the usage context is clear if not exhaustive.

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 signal destructiveHint=true, but the description goes much further: it discloses irreversibility, cascading deletion of order history, the confirmation prompt vs. confirmToken fallback, and the fact that the write is UNVERIFIED against a live account. This is exemplary transparency for a high-risk mutation.

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

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

The description is dense but every sentence earns its place: the action, the irreversible consequence, the confirmation expectation, the fallback flow, and the unverified-write warning are all present with no filler. The most important scoping facts appear early, making the risk profile immediately visible.

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 tool with two parameters and no output schema, the description covers everything needed: what gets deleted, how confirmation works, what the fallback response shape is, and that the agent must inspect the preview before approving. Nothing critical is missing for safe 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 description coverage is 100%, so the schema already fully documents studentId and confirmToken, including safety rules like 'never invented, never reused.' The tool description reinforces the confirmToken flow but adds little beyond the schema's own parameter descriptions. Baseline 3 is appropriate because the schema carries the semantic load.

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

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

The description clearly states a specific verb and resource: 'Remove a student from the account.' It also goes beyond a simple label by explaining the consequence ('order history goes with them') and distinguishing this destructive action from less final operations. Siblings like update_student or delete_order are easy to tell apart.

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 intended use obvious: deleting a student, with strong emphasis on the irreversible nature and the need for user confirmation. It does not explicitly contrast with alternatives such as update_student, but it provides clear operational context and a precise two-step confirmation workflow, so an agent can decide when to invoke it.

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

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

Beyond the readOnlyHint/openWorldHint annotations, the description adds a security-relevant disclosure: returned text is third-party authored, untrusted, and must be treated as data rather than instructions. That is exactly the kind of behavioral context annotations cannot convey, and it also documents the shape of the response (per-student day statuses).

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 purpose and response content, then the trust caveat. Every sentence earns its place; the only minor cost is that the status enumeration is dense within a single sentence.

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 compensates by describing what the calendar returns (day statuses per student) and flagging the untrusted-content property. Nothing an agent needs to call this read-only range query 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?

Schema description coverage is 100% with two well-documented date parameters, so the schema carries the semantics. The description only adds "over a date range", which adds no format or boundary detail beyond what startDate/endDate already specify.

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 (lunch calendar) scoped to a date range, then enumerates the exact content returned: open, ordered, paid, in-cart, subscribed, closed, per student. This level of detail cleanly separates it from siblings like mhlb_get_day or mhlb_get_menu without needing to open either 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?

The line "This is what the Lunch Calendar page shows" anchors the tool to a concrete UI context, which implies when an agent should reach for it. However, it names no alternative and states no when-not conditions, so routing between this and mhlb_get_day or mhlb_get_menu is 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 and openWorldHint, so the safety profile is covered; the description adds a genuinely non-derivable warning that returned text is third-party authored and must be treated as data, not instructions. It stops short of describing pagination or result size, which keeps it out of 5 territory.

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, no filler. The functional scope leads and the security caveat follows, so 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 read-only, no-required-params, no-output-schema tool whose annotations cover safety, this is nearly complete: the agent knows the resource, the filters, where filter values come from, and how to treat the response. Only minor gaps remain around result shape and pagination.

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 are already documented, including the cross-reference to mhlb_get_cart_tabs. The description only restates the filtering axes at a high level and adds no format or value constraints 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?

Names a specific verb and resource and then defines the resource's scope precisely: 'the shopping cart — lunches added but not yet paid for.' That scope statement distinguishes it from mhlb_get_order and mhlb_list_transactions without the agent needing to open either 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?

It says what the filters do ('filter by order status and ordering period, or narrow to one student') and points at mhlb_get_cart_tabs as the source of valid values, which is useful routing. But it never states when to prefer this tool over siblings like mhlb_get_order or mhlb_get_transaction, so usage is only implied.

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 openWorldHint, so safety direction is partly covered. The description adds genuinely non-obvious behavioral context: that the correct default tab is returned and that the returned text is third-party authored and must be treated as data, not instructions. This trust-boundary warning is a strong addition, though return format/pagination is not discussed.

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 purpose, then usage, then the security caveat. No filler; every sentence earns its place and the most actionable guidance leads.

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 describing returns and does so (periods, tabs, default selection) plus a trust caveat. It is near-complete for a read-only lookup tool, though it omits any hint of how counts or scoped results are shaped when the optional filters are used.

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 all three filters (period, tabName, studentId) are documented in the schema itself. The description adds no syntax or scoping detail beyond what the schema already provides, 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?

States a specific verb (Get) and resource (valid filter values for mhlb_get_cart), then enumerates exactly what those values are: ordering periods/semesters, status tabs, and the default selection. It explicitly distinguishes itself from the sibling mhlb_get_cart, which consumes these values.

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 sequencing guidance ('Call this before filtering the cart') and names the related tool it feeds. The agent knows both why and when to invoke it relative to mhlb_get_cart.

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 cover readOnlyHint and openWorldHint, so the safety baseline is set. The description adds a genuinely valuable behavior note not derivable from annotations: that the returned text is third-party/untrusted and must be treated as data rather than instructions (injection warning). It does not describe the shape of the returned coupon, but that gap is modest.

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. The purpose is front-loaded and the security caveat follows without padding; 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?

For a 0-param, read-only tool with annotations already covering the safety profile and no output schema to explain return values, the description is nearly complete. Only the absence of any hint about the coupon's fields or the no-coupon return state keeps it from a 5.

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?

Zero parameters, so the baseline of 4 applies. There is nothing param-related for the description to clarify or compensate for.

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?

Specific verb+resource: 'Get the coupon currently applied to the account'. The word 'currently' scopes it to the applied state, which implicitly separates it from apply_coupon/remove_coupon siblings, though none are named 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?

'if any' implies this may return nothing, giving minimal usage context. There is no explicit guidance on when to call this versus apply_coupon, remove_coupon, or the other get_* inspection 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?

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds genuine context beyond that: it discloses that the returned text is authored by third parties and must be treated as data, never as instructions. This trust boundary is important and not derivable from the schema, though return format and pagination behavior remain unstated.

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, tightly written, with the core purpose front-loaded and the security caveat second. No filler or redundancy; 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?

For a two-param read-only tool with no output schema, the description usefully states what comes back and flags the untrusted-content risk. What is missing is how a day's multiple orders, if any, are aggregated and whether results are bounded — minor gaps for an otherwise complete definition.

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% (date format documented, studentId sourced from mhlb_list_students), so the schema carries parameter meaning. The description's enumeration of items/sizes/quantities/prices describes return content, not parameter semantics, so it adds no parameter-level information. 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?

The description names a specific verb and resource (what a student ordered on one specific date) and enumerates the returned content (items, sizes, quantities, add-ons, prices). It does not, however, distinguish itself from close siblings such as mhlb_get_order or mhlb_get_calendar, so an agent must infer whether 'a day' means an aggregated daily view versus a single order.

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 only implied: the phrase 'on one specific date' plus the two required params suggests this is a daily snapshot lookup for one student. There is no explicit when-to-use statement, no exclusion ('use mhlb_get_order for a single order'), and no prerequisites, so routing among the order-related siblings is 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 and openWorldHint, so safety is partly covered, but the description adds genuinely new behavior: the returned text is third-party authored and must be treated as data, never as instructions. That prompt-injection warning is real operational context an agent needs. It stops short of noting auth requirements, rate limits, or what happens when no menu exists for the date.

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

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

Two sentences, front-loaded with the core purpose, then the ordering context, then the trust warning. No filler, no repetition of the title or schema, and the most actionable guidance (untrusted content) is easy to find.

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 describing the return payload, and it does so by listing vendor, items, sizes, add-ons, prices, and the ordering deadline. Combined with fully documented parameters and annotation-covered safety, an agent has everything needed 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%, and the schema already documents date format/pattern and that studentId comes from mhlb_list_students, so the baseline of 3 applies. The description adds nothing parameter-specific, and the 'one student on one date' framing simply restates the two required params rather than clarifying edge cases like closed ordering windows.

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 precise verb and resource with scope: 'orderable menu for one student on one date', and enumerates what the payload contains (vendor, items, sizes, add-ons, prices, deadline). This clearly separates it from siblings like mhlb_get_order (an existing order), mhlb_get_cart, and mhlb_get_calendar (schedule-level, not per-student orderable menu).

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 read half of placing an order' gives a clear contextual trigger: call this before mhlb_create_order to see what is orderable. However, it never names an alternative sibling or an explicit when-not condition (e.g., how it relates to mhlb_get_day or mhlb_get_calendar for browsing), leaving the sibling routing partly 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 openWorldHint=true, so safety of the read is covered. The description adds genuinely new behavioral context by flagging that returned text is third-party authored and must be treated as data, never instructions — a real prompt-injection warning that no structured field conveys.

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

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

Two sentences, front-loaded with the core purpose and return-shape contract, followed by the security caveat. No filler or restatement of the tool name.

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 characterizes the return (a `data` model consumable by mhlb_update_order) and covers the untrusted-content risk. The one gap is that all three identifiers are optional, yet the description never says which combination is required to resolve an order.

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 each of the three optional identifiers (eventId, orderId, studentId) is documented in the schema itself. The description adds no syntax, precedence, or selection guidance for these identifiers, 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 (get an existing order) and pins down the return shape as the editable model that mhlb_update_order expects. That link separates it cleanly from sibling mhlb_get_order_form and mhlb_print_orders, which serve different presentation purposes.

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

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

The round-trip contract ('data is the model mhlb_update_order expects back') makes the intended workflow — fetch, edit, update — explicit and actionable. It stops short of naming when NOT to use it (e.g. vs. mhlb_get_order_form for display), so it is clear context without explicit exclusions.

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

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

Annotations cover the safety profile (readOnlyHint=true, openWorldHint=true), but the description adds a genuinely useful behavioral fact not in structured data: the returned content is third-party authored and untrusted, with an explicit prompt-injection warning. It also discloses that the model is pre-populated with available items. It stops short of covering size, paging, or upstream failure behavior.

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, both load-bearing: the first defines what is returned and its downstream consumer, the second carries the security constraint. No filler or repetition of the tool name.

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, and the description compensates by describing the return as text containing a blank, item-populated order model matching mhlb_create_order's expected `data`. It does not spell out the exact text/JSON shape or error cases, but an agent has enough to call and consume 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% and both parameters already document their source tools (mhlb_get_menu/mhlb_get_calendar for eventId, mhlb_list_students for studentId). The description adds no parameter-level detail, 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 ('Get the blank order model for a student on a specific lunch event') and clarifies scope as a pre-populated, submission-ready template. It also distinguishes itself from form siblings (mhlb_get_student_form, mhlb_new_student_form) by naming its consumer, mhlb_create_order.

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 by saying this is 'the exact structure that mhlb_create_order expects back (as `data`)', which tells the agent to call it before creating an order. It does not state exclusions or compare against mhlb_get_order / mhlb_get_menu as alternatives, so no explicit when-not 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?

Beyond the readOnlyHint/openWorldHint annotations, it discloses two non-obvious behaviors: the payload is a round-trip model for mhlb_update_student, and the returned text is third-party-authored and must be treated as untrusted data rather than instructions. That prompt-injection warning is real added value annotations do not carry, though error/empty-response behavior is unstated.

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, no filler: the first front-loads what the tool returns, the second delivers the round-trip contract and the trust warning. 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?

With no output schema, the description carries the burden of describing the return payload, and it does — naming the fields, the dropdown options, and the data-versus-instructions distinction. Combined with the annotation-declared safety profile, an agent has what it needs to call and interpret this 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?

Only one parameter and schema description coverage is 100%, with the schema already explaining that studentId comes from mhlb_list_students. The description adds no further parameter meaning, which is the expected baseline at high coverage.

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

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

States a specific verb and resource ("Get the editable profile for one student") and enumerates what the profile covers — school, grade, teacher, delivery location, allergies, plus dropdown options. It is clearly distinguishable from siblings like mhlb_get_order_form and mhlb_new_student_form.

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 names the paired tool and the exact workflow condition: its `data` is the model mhlb_update_student expects back, which tells the agent this is the read step before an update. It stops short of stating when *not* to use it or what to do instead for non-editable views.

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 (readOnlyHint=true, openWorldHint=true), but the description adds genuinely non-structured behavior: the returned text is third-party authored and untrusted, and should be treated as data rather than instructions. That prompt-injection warning is high-value context an agent cannot derive from the annotations or empty schema. It stops short of 5 only because return format/pagination are not addressed.

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 with no filler: the first front-loads what is fetched and what it contains, the second carries the security caveat. 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?

For a zero-parameter read tool with no output schema, the description covers both what the tool returns (recurring-ordering flag and terms) and the critical handling constraint for that content. Nothing needed to invoke or interpret the result 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 schema carries no semantics to compensate for; per the rubric a 0-parameter tool has a baseline of 4. The description adds nothing parameter-related because there is nothing to add.

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 ('Get the account's subscription configuration') and further specifies the payload ('whether recurring ordering is on, and its terms'), so an agent knows exactly what it retrieves. It does not explicitly differentiate itself from the write-side sibling mhlb_set_subscription_enabled, keeping it just 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?

Usage is implied — read subscription configuration when you need to inspect the account's recurring-ordering state — but there is no explicit when-to-use, when-not-to-use, or pointer to alternatives such as mhlb_set_subscription_enabled or mhlb_list_subscriptions. Adequate but leaves 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 readOnlyHint=true and openWorldHint=true, so safety and external-data exposure are partly covered. The description adds a valuable security warning that the returned text is third-party authored and must be treated as data, not instructions. It does not describe error behavior or null-line-item handling, keeping it out of the top score.

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

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

Two sentences, front-loaded with the tool's purpose, followed immediately by the untrusted-content warning. Every clause earns its place with 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?

For a single-parameter, read-only lookup with a fully documented schema and no output schema, the description covers purpose, the untrusted-content risk, and the parameter's origin. Nothing an agent needs to invoke 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?

Schema description coverage is 100%, and the single parameter is documented as the 'id' field from mhlb_list_transactions, with a positive-integer constraint. The description adds no further parameter detail beyond what the schema already supplies, so the baseline of 3 is appropriate.

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

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

States a specific verb+resource: 'Get the line-item detail of one transaction — which lunches it paid for.' The second clause clarifies the return content in concrete terms, distinguishing it from list-level siblings. It doesn't explicitly differentiate from mhlb_get_order or mhlb_print_transaction, but the resource is uniquely named.

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: you need a transaction ID, and the schema points to mhlb_list_transactions as the source. There is no explicit when-to-use/when-not, and no mention of how this differs from mhlb_print_transaction, but the resource name plus parameter documentation make the scenario reasonably inferable.

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 adds beyond annotations by explicitly stating it is read-only and 'never returns the credential itself', a safety-critical behavior. It also discloses that it makes one authenticated request and reports round-trip time, which are behavioral details not captured by the annotations. This is valuable transparency.

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

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

The description is logically structured into action, outputs, and usage, and the essential details are front-loaded. It is slightly verbose with the repetition of the hostname and the long enumeration of failure modes, but every sentence earns its place. It could be tightened but remains clear and readable.

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 parameters and no output schema, the description is complete: it explains what the tool does, what it reports, the safety guarantee, and when to use it. It covers the key return values (credential source, acceptance, round-trip time, and error hint) in plain language, so an agent has everything needed 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?

There are zero parameters, and the schema is an empty object, so there is nothing to document. The description correctly focuses on behavior rather than parameters, and the baseline for 0 params is 4. It adds no parameter-specific meaning because none exist.

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

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

The description states a specific action (resolves credentials and makes an authenticated request to a named host) and explicitly reports the diagnostic outputs. It also distinguishes itself from siblings by framing the tool as a failure-diagnosis tool ('Call this when a real tool fails and you want to know which hop broke'). This gives clear, unambiguous purpose.

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 a clear, explicit trigger: 'Call this when a real tool fails and you want to know which hop broke.' However, it does not name alternative tools or state when not to use it, so it lacks the full when-not/alternatives guidance. The context is clear enough for an agent to decide, but not exhaustive.

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 mark readOnlyHint=false, so it's a write; the description clarifies it does not charge but is still a write step. It discloses the confirmation prompt behavior and the two-step fallback with confirmToken, and adds a critical UNVERIFIED warning about the request shape. This goes well beyond the annotations and gives the agent actionable risk awareness.

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 well-organized: purpose first, then confirmation flow, then a safety warning. Every sentence carries information; no filler, though it is slightly longer than minimal due to the necessary confirmation and unverified warnings.

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 confirmation complexity and the UNVERIFIED warning, the description covers the behavior an agent needs: what it returns, that it's a pre-checkout step, how confirmation works, and the risk. No output schema, but return values are listed. It's complete for this tool, though it could mention what happens if the cart is empty or invalid.

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% with detailed descriptions for each parameter, including confirmToken's special semantics. The description itself doesn't add parameter-specific meaning beyond what the schema provides, so it stays at the baseline for high schema coverage.

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

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

States a specific verb and resource: 'Start checkout for the cart' and lists the returned data (order summary, totals, taxes, credits, payment methods). Explicitly distinguishes from sibling mhlb_checkout by calling itself 'the read step before mhlb_checkout', so an agent can tell them apart without inspecting schemas.

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?

Clearly indicates it is the first step before mhlb_checkout and does not charge. Describes the confirmation flow and references MCP_CONFIRM_MODE, giving explicit sequencing guidance. It doesn't mention when to use a non-checkout alternative like mhlb_get_cart, but the purpose is distinct enough that the agent can infer the right context.

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

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

Annotations already declare readOnlyHint and openWorldHint. The description adds valuable behavioral context: codes are masked by default and revealCodes exposes redeemable money, signaling a security-sensitive operation. No contradiction.

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

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

Two sentences with no filler. The main action and output are front-loaded, followed by the precise conditional for the optional 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?

For a read-only list tool with one optional boolean parameter and no output schema, the description covers the action, the masking behavior, and the reveal condition. Nothing an agent needs to call 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?

Schema covers revealCodes with 100% description coverage, explaining the default and security note. The description adds the conditional usage context ('only when the user needs a full code'), going slightly 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?

States a specific action (List), resource (gift cards), scope (on the account), and key output details (balances, status, masked codes). Clearly distinct from siblings like mhlb_apply_gift_card which operates on gift cards differently.

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 conditional usage for revealCodes ('only when the user needs a full code'), which is direct guidance. Does not name alternatives, but no sibling list-gift-cards tool exists, so the context is sufficient.

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

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

Annotations cover the safety profile (readOnlyHint=true, openWorldHint=true), and the description adds genuinely new context: the untrusted third-party authorship of the returned text and the instruction to treat it as data, plus the inactive/unaccepted-invite status semantics. It does not describe pagination or result-size behavior, so it stops short of a 5.

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 with a distinct job: what is listed, why the id matters, and how to treat the payload. The identity and return-shape information is front-loaded and there is 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?

With no parameters and no output schema, the description carries the full burden and discharges it by enumerating the returned fields and flagging the untrusted-content risk. An agent has everything it needs to call this correctly 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?

The tool takes zero parameters and the schema is empty, so there is nothing to document beyond the call itself. The baseline for a parameterless tool is 4, and the description appropriately spends its words on returned fields instead of inventing parameters.

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

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

The description opens with a specific verb and resource ("List the students on the account") and then enumerates the exact fields returned, so an agent knows precisely what it gets. This clearly separates it from sibling mutators such as mhlb_create_student, mhlb_update_student, and mhlb_delete_student.

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 downstream usage context ("The student id feeds every calendar and ordering tool"), which implies you list students first to obtain an id. However, it never states when to choose this over alternatives such as mhlb_get_student_form or mhlb_whoami, and there are no exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is partly covered. The description adds genuine value beyond them by explaining that subscriptions are auto-charged recurring orders and by warning that returned text is third-party and untrusted, which is a concrete security disclosure an agent needs before acting on output.

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

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

Two sentences, front-loaded with the core purpose before the trust warning. Both sentences earn their place, though the security line is somewhat boilerplate rather than tool-specific.

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 list tool with full schema coverage and no output schema, the description covers purpose, scope, and the untrusted-data caveat. Slight gap on return shape/pagination, but nothing essential to correct invocation 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% for the single 'period' parameter, so the schema already documents it. The description adds no extra detail about period semantics or format, so 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 upcoming lunch subscriptions') and goes further to define what a subscription is ('recurring orders that will be placed and charged automatically'), which cleanly separates it from settings-related siblings like get_subscription_settings. It does not explicitly name siblings, but the resource and scope make the tool's identity unambiguous.

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

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

The 'upcoming' scope hints at intent, but there is no explicit when-to-use guidance or prerequisites, and no routing to alternatives such as get_subscription_settings or set_subscription_enabled. An agent must infer the right context on its own.

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 openWorldHint=true, so safety is covered. The description adds a critical behavioral trait beyond annotations: the returned text is third-party-authored and untrusted, with a clear instruction to treat it as data, never as instructions. This is a valuable security disclosure. It doesn't add much else, but the untrusted-content warning alone is meaningful.

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: the first states purpose, the second delivers a crucial warning. Front-loaded and zero waste. Every sentence earns its place.

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

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

Given the simple read-only nature, no output schema, and annotations covering the safety profile, the description is nearly complete. The only minor gap is that it doesn't explain how periods scope results or whether pagination exists, but for a two-param list tool with no output schema, the untrusted-content warning and clear purpose make it sufficiently 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 schema already fully documents both parameters (period with a reference to mhlb_get_cart_tabs, studentId with a range hint). The description adds no parameter-specific semantics. Baseline 3 is appropriate when the schema does the heavy lifting.

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 (List) and resource (payment transactions) plus the fields returned (date, amount, what was paid for). It's clear what the tool does, but it doesn't explicitly differentiate from siblings like mhlb_get_transaction, which appears to fetch a single transaction.

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

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

The description implies usage (listing transactions on the account) but gives no explicit when-to-use guidance or alternatives. With siblings like mhlb_get_transaction and mhlb_print_transaction, an agent could benefit from knowing when to choose this list vs. a single fetch or print. No exclusions or routing to alternatives are provided.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety of the read is covered. The description adds genuinely non-derivable context: the returned text is third-party authored and untrusted, and must be treated as data rather than instructions — a meaningful prompt-injection disclosure. It stops short of describing size, caching, or session-bound behavior.

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, both earning their place: the first covers purpose, contents, and the hand-off to mhlb_create_student; the second covers the trust boundary. Front-loaded with the core action and with no redundant restatement of the title 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 explaining returns and does so: blank profile, dropdown options, and a `data` field for the create step. It also flags the untrusted-content risk, which is the main non-obvious hazard for a zero-parameter form fetcher, leaving nothing 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?

The tool takes zero parameters, so the baseline is 4 per the rubric. The description goes beyond the empty schema by describing the shape of what comes back (blank profile plus dropdown options, exposed as `data`), which is output rather than input detail but still adds useful signal.

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 (blank student profile plus school/grade/teacher dropdown options), and names the downstream consumer mhlb_create_student, which implicitly separates it from mhlb_get_student_form. However, it never explicitly contrasts itself with the similarly-named sibling mhlb_get_student_form, so an agent still has to infer which form-retrieval tool applies.

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 downstream usage (fill in and pass `data` to mhlb_create_student), which is useful workflow context. It does not state when to prefer it over mhlb_get_student_form or any precondition for calling it, so the when-vs-alternative guidance 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 indicate readOnlyHint=false and destructiveHint=false, but the description adds valuable behavioral detail: it writes the PDF to disk and returns a path, with an inline option for base64 bytes. This goes beyond the annotations and clarifies the side-effect profile without contradicting 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?

Two sentences, zero filler. The first sentence front-loads the core purpose (generate PDF for date range), and the second covers output behavior and the inline option. Every word earns its place.

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

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

Given the five parameters, three of which are required, and the absence of an output schema, the description adequately explains what the tool returns (path or inline bytes). It also covers the side effect of writing to disk. It does not mention error conditions beyond what the schema already notes (e.g., empty studentIds fails), but that is already documented. No critical missing context 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 description coverage is 100% — every parameter (startDate, endDate, studentIds, inline, filename) has a description. The tool description reiterates the inline behavior and file-writing but adds no new meaning beyond the schema. Baseline of 3 is appropriate because the schema carries the semantic load.

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

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

The description states a specific verb ('Generate') and a specific resource ('printable lunch calendar PDF'), and the date range scope. It clearly distinguishes from the sibling mhlb_get_calendar (data retrieval) and other print tools like mhlb_print_orders and mhlb_print_transaction, even though it doesn't name them 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?

There is no explicit guidance on when to use this tool versus alternatives. The description explains what it does but not when an agent should prefer it over mhlb_get_calendar or the other print tools. It does not mention conditions like needing a PDF versus data, or exclusions.

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

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

Annotations only provide readOnlyHint=false, destructiveHint=false, and openWorldHint=true. The description adds valuable behavioral details beyond those: the endpoint fails if studentIds is empty and also fails if no order matches the date/status. This helps an agent anticipate errors without contradicting the annotations.

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

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

Three sentences, no filler. The primary purpose is front-loaded, followed by critical constraints and a pointer to the data source. Every sentence contributes value.

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

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

For a 5-parameter tool with no output schema and modest annotations, the description covers purpose, input source, key failure modes, and scope. It does not explain the inline/filename output behavior, but the schema fully covers those, so nothing essential is missing.

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

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

Schema coverage is 100%, with every parameter already documented (date format, inline base64, filename default, studentIds minItems, orderStatus const values). The description reinforces studentIds being required and failure-prone, but does not add new semantic information beyond the schema, so 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 opens with a specific verb and resource ('Generate the printable order-details PDF') and immediately scopes it to 'a single lunch date,' which distinguishes it from sibling print tools like mhlb_print_calendar and mhlb_print_transaction. The resource and scope are unambiguous.

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

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

The description clearly instructs where to obtain the required inputs ('Get both from mhlb_get_calendar') and flags the single-date constraint. It does not explicitly name alternatives or say when not to use the tool, but the usage context is clear enough for an agent to route correctly.

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

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

Annotations already declare destructiveHint=false and openWorldHint=true, so the safety profile is partly covered, and the description adds real value by explaining the server-side fetch-and-render flow and that the receipt reflects live account data. It does not explain the filesystem write implied by readOnlyHint=false, which is the one behavioral trait left unaddressed.

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 waste; the core action is front-loaded and the follow-up sentence adds the workflow context the agent needs. 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?

Covers the input workflow and the rendering behavior well, and the schema documents the inline/filename output options. It stops short of describing what the caller gets back when inline=false (a written file path, presumably) and there is no output schema to fill 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?

Schema description coverage is 100%, so the baseline is 3. The description links transactionId back to mhlb_list_transactions, but that is already stated in the schema's own parameter description, and inline/filename/isCreditType get no extra explanation here.

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 ('Generate'), a concrete resource ('printable receipt PDF'), and scope ('for one transaction'). It is clearly distinguishable from siblings like get_transaction, print_orders, and print_calendar without opening 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?

The description routes the agent to mhlb_list_transactions as the source of the transaction id, giving clear usage context. It stops short of saying when to prefer this over the sibling get_transaction or print_orders, so no explicit exclusions are stated.

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 annotations (readOnlyHint false, destructiveHint false), the description discloses a critical behavioral fact: the write is UNVERIFIED, its request shape was derived from compiled API client code, and it has not been exercised against a live account. It also warns the agent to inspect the preview before approving, which is significant transparent context.

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 purpose, followed by the essential confirmation mechanics and a necessary risk warning. Every sentence carries required information, and there is no filler or repetition of the schema.

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

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

Given there is no output schema, the description sufficiently outlines the expected two-step behavior and the confirmToken handoff. It references MCP_CONFIRM_MODE and warns to inspect the preview. It does not spell out edge cases like 'no coupon applied,' but the confirmation flow and unverified-write warning cover the most important operational context.

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

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

Schema coverage is 100% and the confirmToken parameter is already richly documented in the input schema. The description adds value by explaining the two-phase return behavior—first call returns preview and confirmToken, repeat call with token proceeds—which gives the parameter operational meaning beyond the schema text.

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 clear, specific statement: 'Remove the coupon currently applied to the account.' This identifies the action (remove), the resource (coupon), and the scope (currently applied to the account), making it unambiguous and inherently distinct from related siblings like apply_coupon or get_coupon.

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, actionable usage guidance for the confirmation flow: prompt when the client supports it, otherwise first call returns preview/confirmToken, and only a repeat call with that token proceeds. It does not explicitly compare against sibling tools, but the unique action and 'currently applied' scope make the intended use clear.

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 non-read-only, idempotent, non-destructive, and the description adds real behavioral context beyond them: specifically what state is discarded and how the next call behaves (re-authentication). It stops short of stating whether re-auth can prompt interactively or fail, which would be the last useful detail.

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, both front-loaded and functional: the first states the effect, the second the trigger. 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 zero-parameter, no-output-schema utility whose safety profile is fully covered by annotations, the description supplies everything needed: what it does, the observable effect, and when to invoke it.

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

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

Zero parameters, so per the rubric the baseline is 4. The description correctly implies no inputs are needed; there is nothing further to document.

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 precise verb+resource ('Discard the cached ... access token') and the consequence ('the next tool call signs in again'). No sibling tool overlaps with session/cache management, so the agent can identify it immediately.

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 explicit trigger conditions: after changing credentials, or when calls fail with stale-session errors. There is no competing sibling for this action, so no alternative needs naming.

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 the confirmation behavior, including the two-step fallback with confirmToken, and warns that the write is UNVERIFIED with a request shape derived from compiled API client. This goes well beyond the annotations (readOnlyHint=false, destructiveHint=true) by explaining the exact behavior and risk. No contradictions with annotations.

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

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

The description is dense but every sentence carries critical information: purpose, confirmation flow, fallback mechanism, and the unverified warning. It is front-loaded with the core action and the warning is placed last. No fluff or redundancy.

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

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

For a write tool with a confirmation flow and an unverified implementation, the description covers all necessary operational details: the two-step process, the meaning of confirmToken, and the caution to inspect the preview. It also references MCP_CONFIRM_MODE for further context. No output schema exists, so return values aren't required, and the description doesn't claim them.

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. The description adds meaning by explaining that 'enabled=true' means future lunches are ordered and charged automatically, and it elaborates on confirmToken usage, including never inventing or reusing tokens. This provides context beyond the bare schema 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 clearly states the tool's action: 'Turn recurring lunch subscriptions on or off for the account,' specifying both the verb and the resource. It distinguishes itself from sibling tools like mhlb_get_subscription_settings (read) and mhlb_list_subscriptions (list) by focusing on the write operation. The purpose is immediately clear and unambiguous.

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

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

The description provides explicit context on when to use the tool: to change subscription status, and it details the confirmation flow. However, it does not explicitly name alternatives or state when not to use this tool, though it's implied by the action. The note about inspecting the confirmation preview before approving is a useful safety guideline.

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 mark the tool as destructive, and the description goes further by stating the write is UNVERIFIED and instructing the agent to inspect the confirmation preview before approving. It also discloses the confirmation fallback mechanism, adding behavioral context 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 focused sentences plus a concise warning note. Every sentence serves a purpose: the first states the action and confirmation behavior, the second highlights risk and preview inspection. No filler or redundancy.

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

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

The description covers the confirmation flow, the unverified status, and the need to inspect the preview. It lacks a description of the final success response, but given the detailed schema and annotations, the tool is adequately specified for an agent 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 coverage is 100%, so all parameters are already documented. The description adds little beyond the schema—it mentions confirmToken in the flow but doesn't provide new semantics. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states a specific verb ('Stop'), a resource ('a recurring subscription for a specific lunch order'), and clearly distinguishes it from siblings like mhlb_delete_order and mhlb_set_subscription_enabled. The confirmation flow is also mentioned, leaving no ambiguity about what the tool does.

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 explains when to use the tool (to stop a subscription) and details the two-step confirmation process, including when to pass confirmToken. It doesn't explicitly contrast with alternatives, but the purpose is clear enough that an agent can decide appropriately.

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=false and openWorldHint=true, but the description adds substantial non-obvious context: the endpoint replaces the entire order (not a partial patch), a user confirmation is required, and the write is UNVERIFIED against a live account. The only minor gap is it doesn't state what the preview/response actually contains, but the confirmation flow and unverified warning are exactly the kind of disclosure that matters here.

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 verb and core action are front-loaded, and the remaining clauses (confirmation flow, unverified note) each carry necessary operational detail. It is dense and somewhat long for a single paragraph, but no sentence is filler given the multi-step confirmation behavior it must 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?

For a write tool with a non-trivial confirmation handshake, no output schema, and a nested order object, the description covers the essential behaviors: prerequisite call, whole-model replacement, elicitation vs. token fallback, and the unverified caveat. Nothing an agent needs to invoke it 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 coverage is 100% and both parameters carry detailed inline descriptions, so the baseline is 3. The description adds real meaning by explaining that the `order` value must be the model returned by mhlb_get_order (with edits) and that `confirmToken` comes only from a phase-1 preview and is never reused — reinforcing rather than merely restating 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 ("Change an existing lunch order") that cleanly separates it from the sibling create_order, delete_order, and get_order tools. An agent can identify it as the mutation path for an existing order without opening the 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 names the prerequisite ("Call mhlb_get_order first and send that model back with your edits"), explains the replacement semantics, and lays out the two confirmation paths including the exact fallback sequence. When-to-use and how-to-sequence are fully specified rather than inferred.

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

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

The description states 'the endpoint replaces the whole record, so omitted fields are lost,' which is an overwrite of existing data — exactly the destructive-update behavior the spec assigns to destructiveHint=true. The annotations declare destructiveHint=false (additive updates only), so the description contradicts structured data, despite otherwise rich disclosure of the confirmation flow and unverified status.

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 purpose, then prerequisite, then confirmation mechanics, then the verification caveat — a sensible priority order with no filler sentences. It is dense and fairly long, but each clause carries operational information (confirmToken lifecycle, preview inspection), so the length is largely earned.

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 no-output-schema, nested-object mutation tool, the description covers everything an agent needs: input provenance, whole-record replacement risk, both confirmation modes, token reuse rules, and the UNVERIFIED caveat. Nothing material is left for the agent to infer.

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 are documented inline (the student model and the confirmToken semantics and constraints). The description adds framing about where the student object originates but no syntax or format detail 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 ('Update a student profile') and immediately reveals the mechanism that separates it from siblings: it consumes the model returned by mhlb_get_student_form rather than raw fields. An agent can distinguish this from mhlb_create_student / mhlb_new_student_form without opening 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?

Gives an explicit prerequisite workflow ('Call mhlb_get_student_form first and send that model back') and fully describes the confirmation path in both elicitation and token-fallback modes, naming MCP_CONFIRM_MODE. It lacks an explicit statement of when to prefer this over creating a new student, but the use context is otherwise unambiguous.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description supplements this by listing the specific returned information: name, email, role, counts, balances, and subscription flags. It also frames the call as a session validation, adding context beyond the annotations without contradicting 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 two short sentences with no filler. The data enumeration is dense but useful, and the 'Start here' guidance adds practical value without bloat.

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 zero parameters and no output schema, the description covers what the tool does, what it returns, and why to call it first. Nothing essential is missing for an agent to select and invoke 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?

The tool has zero parameters, so the description has no parameter burden and the baseline 4 applies. The description's reference to 'the signed-in account' clarifies that the tool relies on the active session rather than any input.

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 says 'Get the signed-in My Hot Lunchbox account' with a specific verb and resource, then enumerates the data returned. This makes it clearly distinct from sibling transaction, student, order, and subscription 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 says 'Start here to confirm the session works,' giving a clear trigger condition. It does not name alternatives, but no sibling provides the same whoami/session-check functionality, so the guidance is sufficient.

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