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

Annotations already declare readOnly/non-destructive/no open-world, and the description adds substantive context beyond them: results are tier-based guidance, not inventory; a human coordinator confirms coverage after submission; output must not be framed as a reservation. That is exactly the operational nuance an agent needs to relay results honestly.

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?

Purpose and the critical negative constraint are front-loaded, then examples and hints are segregated into tagged blocks. Slightly dense — the 'not a real-time inventory' point is restated in three ways (inventory, coordinator confirmation, not a reservation) — but each restatement covers a distinct failure mode.

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

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

An output schema exists so return-shape need not be described, and the remaining gaps an agent would care about (human follow-up step, cost-tool routing, rush-window edge case, display constraints) are all covered. Nothing needed to call or interpret this tool is missing.

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

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

Schema description coverage is 100%, so all four params are self-documenting and the baseline would be 3. The description adds marginal value by showing realistic combinations of the optional role and count alongside required date/city, and by framing city as a 'configured market' (i.e., supported-market constrained) rather than free-form geography.

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

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

The first sentence names a specific verb and resource ('Return tier-based lead-time guidance') plus its scope (event date + configured market). It immediately rules out what it is not ('not a real-time inventory or order-coverage check'), which separates it from order/quote siblings like request_quote and get_quote_status.

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

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

Gives explicit trigger questions ('What's the typical lead time for brand ambassadors in [city]?'), an explicit exclusion with a redirect ('DO NOT use for cost questions (use get_role_pricing)'), and a presentation constraint ('never present the result as a reservation'). The hints block also tells the agent to still submit rush windows, covering the edge case where an agent might otherwise decline.

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, openWorldHint=false, and destructiveHint=false. The description adds meaningful behavioral context: configured entries are planning data, catalog presence does not promise availability or coverage, a coordinator must confirm orders, unfiltered results are capped, and the public coverage claim is 300+ markets. This goes well beyond the structured 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 front-loaded with the core purpose and caveat, followed by use cases, examples, and hints. It is longer than the minimum, but every section earns its place given the semantic pitfalls an agent must avoid. The structure is organized and scannable.

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 lookup tool with 100% parameter documentation and an output schema, the description supplies all needed context: when to use it, how to answer common user questions, what caveats to preserve, how filters behave, and what sibling tools cover adjacent needs. Nothing material is missing for correct invocation.

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

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

Schema coverage is 100%, but the description still adds value by clarifying accepted formats ('CA' or 'California' for state, 'US' or 'CA' for country), nickname/borough resolution, the meaning of limit caps with full counts retained, and the fact that city matching returns a suggestion rather than a coverage promise. These nuances are not fully captured in the schema.

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

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

The description opens with a specific verb and resource: 'List configured market entries by tier, or match one city.' It clearly distinguishes this tool from siblings like check_availability and get_role_pricing, and explicitly names the non-goal: catalog presence is not availability or order coverage.

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 concrete query patterns ('What markets are configured in [state]?', 'Is [city] in the catalog?'), provides example calls for several filter combinations, and explicitly names sibling tools for related tasks (get_role_pricing, check_availability, plan_staffing). It even instructs how to handle 'Do you cover [city]?' with the proper caveat.

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, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds genuinely useful context beyond that: a legal-advice disclaimer and a hint that daily-overtime states (CA, AK, NV, CO) change shift budgeting. It does not discuss error behavior for unrecognized states, keeping it 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?

The purpose and the sibling exclusion are front-loaded, and the disclaimer plus hint are short and on point. The three quoted example questions overlap with each other and with the purpose sentence, adding some length without much new information.

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

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

For a one-parameter read tool with full schema coverage, complete annotations, and an output schema handling return values, the description covers purpose, alternatives, caveats, and a domain hint. Nothing an agent needs in order 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 coverage is 100% and the single parameter already documents that either a two-letter code or a full name is accepted. The examples (state='CA', state='Tennessee') restate that same flexibility rather than adding new syntax, 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+resource ('Get the event staffing compliance summary for a US state') and enumerates what is returned: minimum wage, overtime rules, state-specific quirks. It also explicitly routes away from the nearest sibling (get_role_pricing) for rate questions, so an agent can distinguish it without opening 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?

Gives concrete trigger questions ('What are the W-2 vs 1099 rules...', minimum wage, compliance gotchas) and an explicit exclusion: 'DO NOT use for rates (use get_role_pricing)'. Both when-to-use and when-not-to-use are spelled out.

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

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

Annotations already declare readOnly/non-destructive, and the description adds information annotations cannot express: a 30-day retention window, non-PII status, anti-enumeration constraints, and the three distinct causes of a not-found result. That is exactly the behavioral context an agent needs to interpret failures rather than retry blindly.

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?

Purpose and usage conditions are front-loaded and there is no filler prose. The trailing hints section re-states the 30-day expiry already mentioned in the first sentence, and the XML-style tags add mild visual bulk, but each block is scannable and 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 an output schema present, return values need not be described, and the description covers everything else: provenance of the ID, retention limit, failure interpretation, and the required user-review step before request_quote. 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 coverage is 100% and the pattern already encodes the 12-character lookalike-free format, so the schema carries most of the weight. The description still adds sourcing semantics ('use only the ... plan_id the user, plan_staffing, or save_staffing_plan supplied') and a concrete example call, going beyond a bare restatement.

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 ('Restore') plus a clearly scoped resource ('complete non-PII staffing plan') and names both producers (plan_staffing, save_staffing_plan), which cleanly separates it from the mutating siblings with similar names. An agent can tell immediately that this is the read-back counterpart to save_staffing_plan.

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 triggers are given ('buyer starts a new conversation, changes agent platforms, or wants to continue a saved plan before requesting a quote') along with a hard prohibition ('DO NOT guess or enumerate plan IDs') and a recovery path on failure ('re-run plan_staffing'). It also sequences the tool relative to request_quote, which is genuine when/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?

Annotations already declare readOnlyHint/openWorldHint=false, so safety is covered; the description adds substantial behavior beyond that: omitted topic returns everything, unknown topics return the available-topic list rather than erroring, alias inputs are tolerated, per-order terms are tagged confirm_with_coordinator, and the result is characterized as 'an operational summary, not a contract'. That is exactly the context an agent needs to interpret output safely.

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 purpose, then coverage list, then tagged examples and hints; the tag structure keeps a dense description scannable. Slightly long, and the 'narrow lexical aliases remain accepted' clause is a marginal edge-case detail, but every sentence carries actionable information.

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

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

For a zero-required-parameter, single-enum read tool with an output schema already present, the description covers everything an agent needs: when to call it, how to pick a topic, what happens with no topic or a bad topic, and how to treat provisional values. Nothing material is left to inference.

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

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

Schema coverage is 100% and the enum is fully described there, so the baseline is 3; the description earns extra credit by explaining the omit-for-all semantics, the alias tolerance not visible in the enum, and the fallback behavior for unknown values. The three example invocations concretely map natural questions to topic values.

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 TempGuru's published booking and procurement policies') and immediately enumerates the concrete subject matter it covers (minimums, cancellation, COIs, deposits, rush fees, background checks). No sibling tool deals with policy retrieval, so the scope is unambiguous against check_availability, get_plan, request_quote, etc.

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

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

Explicitly routes usage: 'Use for real booking questions that otherwise require an email', which tells the agent when this tool substitutes for human contact. It also gives selection guidance for the topic parameter (advertised topic = one policy, omit = all) and warns never to infer a missing number. It stops short of naming an alternative tool for adjacent questions, so a 4 rather than a 5.

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

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

The description adds important behavior beyond the annotations: this is a v1 status stub that only reports received/queued, does not yet expose quote_sent or won, retains status records for 90 days, and not-found results do not prove the CRM lead is absent. This is rich, honest behavior disclosure.

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

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

The description is front-loaded with the purpose, followed by concrete usage rules, limitations, an example, and retention hints. Every sentence carries meaningful information, and the structured examples/hints tags make the details easy for an agent to parse.

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

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

For a simple read-only status-checking tool, this is complete: purpose, usage constraints, sibling distinction, current limitations, retention behavior, and a not-found caveat are all covered. The output schema handles return-value details, so no additional information is needed here.

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

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

The schema already documents the reference parameter with a pattern, maxLength, and example, so it carries most of the semantic load. The description adds valuable extra context by clarifying that only form-submission references are valid and that the authless request_quote handoff does not generate one.

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 ('Check whether a TempGuru quote request reference was received by the CRM or durably queued'), and clearly differentiates itself from siblings by noting that the authless MCP request_quote handoff does not create a reference. It is precise and disambiguates the tool from request_quote.

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 usage conditions are given: 'Use only after the buyer personally submitted a TempGuru website form and received a TG reference, or for a historical reference.' It also states an exclusion — the authless MCP request_quote handoff does not create a reference — making it clear when not to use this tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds meaningful behavioral details beyond that: it returns a national typical plus range, handles brand ambassadors by market tier, and describes the optional tier parameter as adding 'tier_usd' data for each role.

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 more detailed than average, but every sentence contributes: scope, data source, return value, example use cases, exclusions, citation, and parameter hints are all covered. It is front-loaded with the core result and the guidance to use alternative tools.

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 two optional parameters, an output schema, and clear annotation coverage, this description is complete. It covers the dataset, measurement scope, tier handling, citation format, and appropriate alternatives. An agent can confidently decide when to invoke this tool and understand the shape of the result before even opening the output schema.

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

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

Schema coverage is 100%, so parameter basics are already documented. The description adds extra value by explaining what the tier parameter actually does ('adds each role's measured span within that tier (tier_usd)') and by showing concrete example calls with different parameter combinations, which helps an agent understand how to pass arguments correctly.

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

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

The description clearly identifies the resource (TempGuru Event Staffing Rate Index) and the specific output: all-inclusive W-2 hourly bill rates by role from 407 markets, with a typical rate plus the national range. It also explicitly distinguishes itself from related tools like get_role_pricing and plan_staffing by stating what the tool is NOT for.

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

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

Usage guidance is explicit and actionable. It provides example queries, states when to use the tool ('What do event staff cost in 2026?', 'Industry benchmark'), and gives clear exclusions: do not use for one city's price (use get_role_pricing) or to build a budget (use plan_staffing).

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 provide readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context by explaining that rates are all-inclusive, non-binding, and not a quote, which shapes how the agent should present results.

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: it defines output semantics, gives user-style queries, routes to alternatives, adds exclusion guidance, and provides examples and hints. It is front-loaded with the core purpose.

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

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

For a simple two-parameter read-only tool with a full output schema, the description is complete: it states the exact inputs, the meaning of the returned range, the non-binding caveat, and alternative tools for related tasks.

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 descriptions already cover 100% of the parameters with names and slug examples. The description adds value beyond the schema with call examples and a useful pricing hint: 'Brand Ambassadors floor at $40/hour in every market.' This helps agents choose valid parameter values.

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

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

The description states a specific verb and resource: 'Get the all-inclusive hourly rate range for a specific role in a specific city.' It clearly distinguishes itself from siblings like check_availability and plan_staffing through question examples and explicit exclusions.

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

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

The description gives explicit when-to-use guidance with natural language examples, and explicit when-not-to-use guidance: 'DO NOT use for availability or dates (use check_availability)' and 'For a multi-role budget, use plan_staffing.' This leaves little ambiguity about tool routing.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to restate safety. It adds useful behavioral context beyond annotations: the tool returns slugs that are the exact values other tools accept, and that entries include descriptions and skill tiers. This helps the agent predict integration behavior, meriting a score above baseline.

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 slightly longer than typical for zero parameters but each element earns its place: the first sentence states the core purpose, the question examples clarify usage, the DO NOT sentence provides routing, and the hints add cross-tool integration value. It is structured with clear separation, just slightly verbose.

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

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

For a zero-parameter, read-only tool with a high-quality output schema, the description covers everything an agent needs: what the tool does, when to use it, when to avoid it, how it integrates with other tools, and expected content. No meaningful gap remains.

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 and 100% schema coverage, so no parameter documentation is needed. The description further reinforces this with an example call get_roles() showing it accepts no arguments, which is helpful for the agent. A 4 aligns with the 0-parameter baseline.

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 event staffing roles TempGuru provides') and immediately separates itself from get_role_pricing by explicitly naming it as the alternative for cost questions. The example user questions anchor the resource in concrete intents, leaving no ambiguity about what get_roles returns.

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 when-to-use signals via representative question examples ('What kinds of event workers can I hire?', 'Do you have brand ambassadors?') and explicitly states when not to use it ('DO NOT use for what a role costs, use get_role_pricing with a city'). Names the sibling tool directly, leaving no inference required.

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 a non-read-only, non-destructive, non-idempotent, closed-world tool; the description explains why (it may persist a non-contact 30-day snapshot and return a plan_id) and what it explicitly will not do: accept contact details, reserve staff, or create a quote request. It also sets the interpretation boundary for outputs (totals are planning estimates, not quotes) and states that live inventory/coverage is confirmed by a human coordinator — context the annotations cannot convey.

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

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

Front-loaded with the imperative call-to-action and ordered sensibly: what it returns, what it excludes, follow-up save rule, then status branching. It runs long and spends two separate sentences on negative disclosures (no coverage/inventory, no contacts/reservations/quotes) that could be consolidated, but nearly every sentence carries actionable information for a workflow-entry tool.

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

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

An output schema exists, so return-value detail is not required, and the description instead covers the parts an agent cannot infer: sequencing across siblings, the 30-day snapshot/plan_id persistence model, the status branches (plan, needs_roles, roles_not_found, city_not_found), and the instruction to confirm rather than auto-apply suggested roles. Nothing needed to invoke or follow up 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 coverage is 100%, so the schema already documents every field including defaults, bounds, and the enum. The description reinforces only the one non-obvious behavior (omitting roles yields a catalog plus suggested mix) and otherwise describes inputs collectively as "city, date, roles, and headcount." Baseline 3 is appropriate when the schema carries the parameter burden.

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 (plan event staffing) and enumerates exactly what the response contains: catalog match, W-2 rate math, estimated totals, lead-time guidance, and compliance flags. It explicitly separates itself from the granular siblings (get_rate_benchmark, get_role_pricing, get_compliance_by_state) and from request_quote/save_staffing_plan, so an agent can route correctly without opening a 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?

"CALL THIS FIRST" gives an explicit entry-point rule, and "Use granular tools only for a single rate, date, or state fact" names the exact condition that selects the alternatives. It also covers the follow-up decision tree — call save_staffing_plan once only if no plan_id is returned, never re-save an existing plan — and tells the agent to omit roles for the catalog path.

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

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

The annotations already carry readOnlyHint, idempotentHint, and destructiveHint, but the description adds meaningful non-obvious behavior: it never transmits contact information, never creates a lead itself, requires the buyer to open and submit the form, and does not reserve or guarantee pricing/availability. There is no contradiction with the annotation object.

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 front-loaded with the trigger condition and key requirement. It is arguably a little long and contains a couple of repeated privacy-related caveats, but each sentence carries a meaningful operational or safety instruction for an agent.

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 schema covers all parameters, an output schema exists, and annotations cover the read-only behavior, the description supplies what is left: preconditions, fallback behavior, expiration handling, and the PII boundary. The tool is fully covered from the perspective of an agent deciding whether and how 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?

Schema description coverage is 100%, so the baseline applies. The description does reinforce that plan_id must be a saved non-PII plan reference from plan_staffing or save_staffing_plan, but it adds no new meaning for skill_id, skill_version, or source_platform beyond what the schema already documents.

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: after a buyer asks to proceed, return a TempGuru-owned pre-filled review form for a saved plan_id. It explicitly states the tool does not create a quote reference or CRM lead, which clearly distinguishes its purpose from quote-status or lead-creation tools.

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

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

It gives an explicit trigger condition, required input source, and the buyer's required follow-up action. It also gives concrete when-not guidance by saying to give continuation.form_url directly when no plan_id exists, to never collect contact details, and to re-run an expired plan.

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

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

Annotations already declare this is a non-read-only, non-idempotent, non-destructive write, and the description adds substantial context beyond them: the server recomputes rates, totals, lead time, and compliance and rejects caller-supplied pricing. It also explicitly scopes what the tool does NOT do (reserve staff, submit contact details, request a quote) and describes the full status-branch behavior for saved, plan_incomplete, rate_limited, and storage_unavailable.

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

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

The purpose and gating condition are front-loaded before the behavioral warnings, and every sentence carries signal—including the hints block, which is load-bearing for error handling. It is somewhat dense and long, and the 'Provide the same confirmed…' sentence could be tightened, but there is no true 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?

An output schema exists, so return-value documentation is not required, yet the description still explains the status outcomes an agent must branch on. Combined with the explicit non-goals and the input-recomputation rule, an agent has everything needed to invoke this correctly and handle its results.

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

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

The description enumerates the inputs to supply ('city, date, event type, attendees, roles, headcount, hours, and days'), which maps to all five top-level parameters plus nested fields. It adds the semantic constraint that these must be the same confirmed values and that no pricing or totals may be supplied—a rule not expressible in the schema. With 100% schema coverage already documenting formats and defaults, this is solid added value rather than full burden-carrying.

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

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

The description states a specific verb and resource: 'Explicitly save a complete non-contact staffing plan for 30 days,' with the stated purpose ('shared, resumed, or linked to a later quote request'). It distinguishes itself from plan_staffing and request_quote by name, so an agent can tell which to call without opening a 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 gives an explicit positive trigger ('only when plan_staffing returned plan_complete:true without a plan_id and the user needs persistence') and an explicit negative trigger ('never call this tool when plan_staffing already returned a plan_id'). The hints block further routes by status code and names the fallback (continuation.form_url) when saving fails.

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