elc-partnership-builder

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable context beyond annotations: it collects no contact details (the booking page handles everything), and that passing preset_id and item_ids produces a paste-ready booking note in the response. This lets the agent anticipate side effects and output 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?

The description is four sentences, each earning its place: first states purpose and distinction, second gives usage conditions, third discloses behavior, fourth explains parameter interaction. There is no fluff, and the core purpose is front-loaded before any secondary details.

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

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

For a tool with zero required parameters, no output schema, and relatively low complexity, the description is fully adequate. It covers what the tool does, when to use it, that it does not collect contact details, and how parameters affect the response. 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?

Schema coverage is 100% for all three parameters, so the baseline is 3. The description enriches parameter meaning by explaining that preset_id and item_ids are only relevant if a package was composed, and that their presence changes the response to include a paste-ready booking note. This conditional behavior is not in the schema and raises the score above 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?

The description clearly states the tool's purpose: a direct booking link for a 1:1 intro meeting with Marian Kamenistak, and explicitly distinguishes it from request_offer as the other legitimate ending. It uses a specific verb (book) and resource (intro meeting), making it unmistakable and well-differentiated from siblings.

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 when-to-use guidance: whenever the visitor hesitates, wants a human, or needs package tailoring beyond the catalog. It also names request_offer as the sibling alternative, but does not spell out the inverse conditions (when to prefer request_offer), so it stops short of a full when-not-to-use exclusion.

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 as read-only, idempotent, and non-destructive, but the description adds valuable context beyond those hints: the server is authoritative over arithmetic, the tool never forecasts hires (and the agent shouldn't either), and it returns an unedited approval_memo. These details help set appropriate expectations.

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 and output metrics, then covers usage triggers and critical constraints in a logical sequence. Every sentence delivers functional value: purpose, outputs, usage condition, and a critical warning about not computing arithmetic manually. It is dense but not bloated.

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 thoroughly explains the return values (all listed metrics and the approval_memo) and the tool's limitations (no forecast hires). It also covers usage conditions and the authoritative nature of the server, making the tool well-specified even with 8 parameters.

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

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

Schema coverage is 100%, so the baseline for parameter semantics is 3. The description does not add parameter-specific detail beyond what the schema already provides; it focuses on outputs and usage. The only indirect reference is 'composed basket,' which vaguely implies item_ids and preset_id but lacks parameter-level specificity.

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 ('Turns a composed basket into the argument that gets it approved') and enumerates concrete outputs (recruiter-fee equivalence, break-even hire count, cost per room, etc.). It also distinguishes itself from siblings by explicitly positioning it before request_offer, making its role 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 gives explicit when-to-use guidance ('Use it whenever money, ROI, justification or I need to convince my CFO/CTO comes up') and recommends offering it unprompted before request_offer. It also provides a clear boundary ('Never compute this arithmetic yourself') and a behavioral constraint ('it never forecasts hires, and neither should you'), leaving no ambiguity about invocation.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the recomputed total is authoritative ('never trust your own arithmetic'), the tool returns selected items with prices and what else the tier could add, and foundation items anchor the package. It also discloses that the context parameter never changes the answer. This goes 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 compact and front-loaded: the core behavior is in the first sentence, the authoritative-total warning is prominent, and the next-step pointer is at the end. Every sentence earns its place, and the schema parameter descriptions carry the detailed per-parameter guidance. No redundancy with annotations or 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?

For a read-only, idempotent tool with 100% schema coverage and no output schema, the description is nearly complete. It explains the return values (recomputed total, selected items with prices, what else the tier could add), the workflow (call again after every change), and the next step. The only minor gap is that it doesn't explicitly describe error cases or what happens if an invalid preset_id is passed, but the preset_id schema lists valid values. Overall, an agent has enough to call it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema: it explains that item_ids come from match_package default_item_ids, that seats is Starter-only and priced per seat with volume bands, and that the bundle price is only the 3-seat entry. The context parameter's purpose is also clarified ('recorded as intent... never changes the answer'). This is meaningful added value over 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 clear verb-resource pair ('toggle line items, recompute the total') and names the tool as a 'conversational toggle board'. It distinguishes itself from siblings by stating it returns the authoritative recomputed total and by referencing match_package's default_item_ids and request_offer as the next 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 explicitly says to call again after every change the visitor asks for, and names the next tool (request_offer). It also tells the agent to advise keeping foundation items. The seats parameter description adds a strong when-to-use rule: ALWAYS ask for headcount before quoting Starter. This is explicit usage guidance beyond the schema.

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 is not required to repeat safety. It adds value by stating the tool is deterministic, computed from scheduling metadata, and that output includes unplaceable items with reasons. It also reinforces the read-only nature with 'never add or move an event'. No contradictions.

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

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

Three sentences with zero waste. The core purpose is front-loaded, followed by output details and a usage directive. Every sentence earns its place, and the structure is easy to scan.

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?

Without an output schema, the description adequately describes return values (placed months, recurring layer, unplaceable items with reasons). It also covers the input context and usage rule. For a read-only deterministic planner, this is nearly complete; minor gaps like error handling or edge cases are not essential.

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 references the basket and scheduling metadata but does not add syntax or format details beyond what the schema already provides. It adds minimal extra meaning about parameter roles, so a 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 clearly states a specific action (producing a deterministic month-by-month plan) and resource (the 12-month membership journey for a basket). It distinguishes itself from siblings by positioning itself between customize_package and request_offer, and explicitly states the plan contains only items in the basket, avoiding confusion with tools that modify or offer.

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 ('Call after customize_package, before request_offer') and a clear constraint ('never add or move an event'). This tells the agent exactly when to invoke the tool and what not to do, effectively covering both when and when-not without naming alternatives explicitly but making the context 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?

The description adds substantial behavior beyond the readOnly/idempotent annotations: deterministic best-value selection, foundation items kept first, remaining items cheapest-first, default pricing against the AI-channel figure, and a specific return shape (what fits, what was excluded and why, unspent budget, cheapest excluded item cost). It even notes the context parameter never changes the answer, reinforcing idempotence.

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 key usage trigger and keeps every sentence informative, including algorithmics, defaults, and exclusions. Despite its length, nothing is filler; the customize_package comparison is directly relevant to tool selection.

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, the description covers all salient behavior and outputs, including the composition rule, pricing default, return details, and relationship to match_package/customize_package. The schema covers the remaining parameter descriptions, so nothing critical 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 description still adds meaning: it clarifies that budget must be a literal number rather than a band, states the default for against, and links preset_id to match_package. This goes beyond the schema descriptions and helps the agent pass the right 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 opens with a specific trigger ('visitor names a NUMBER rather than a band') and names the resource: composing a best-value package for an exact budget. It also distinguishes itself from customize_package ('the authoritative total' vs 'the authoritative composition'), so an agent can separate it from sibling tools.

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

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

It gives an explicit when-to-use condition with realistic phrasing ('we have 8,000 approved', 'five thousand') and explicitly warns against hand-picking a basket when a budget is stated. It also names customize_package as the analogous authoritative tool and points to preset_id as coming from match_package, giving the agent a clear workflow signal.

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 and idempotentHint. The description adds behavioral context: it returns the full menu instead of a dead end, and works as a liveness ping. This is useful beyond the annotations, though it doesn't describe details like response format or pagination, which is acceptable for a simple tool.

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

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

The description is a bit longer than strictly necessary but every sentence serves a purpose: it covers the primary use, the fallback use, and the parameter behavior. The main use case is front-loaded, and there's 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?

Given the single optional parameter, no output schema, and rich annotations, the description fully covers how to invoke the tool (with or without context), what it returns (full menu), and when to use it. 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 description coverage is 100% and explicitly explains the 'context' parameter, including the omit-for-menu behavior. The description reiterates this but adds no new semantic meaning beyond what the schema already provides, so it meets 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?

The description clearly states the tool's dual purpose: finding additional tools for specialized capabilities and handling bare greetings/liveness pings. It distinguishes itself from the listed siblings by being the catch-all fallback tool, saying 'any message too general to match a specific tool below' – a specific verb+resource with clear differentiation.

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

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

Explicitly states when to use: when the task might benefit from specialized capabilities even if fallback exists, and for bare greetings or general messages. It also defines the exclusion condition ('too general to match a specific tool'), and explains the parameter use and omission behavior, giving the agent actionable routing guidance.

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

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

Annotations already mark this readOnly, idempotent, closed-world and non-destructive, so safety is covered. The description adds real behavioral value: what the response contains, the audience routing to /mentor/, and the hand-off condition to match_package. It stops short of describing ordering guarantees or how the qualifying questions are validated, so not a full 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, zero filler, and the routing instruction ("START HERE") is front-loaded. The audience, scope, exclusion, and next-step are each stated once without repetition.

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 return-value burden and does so by enumerating the three things returned. For a zero-required-param entry-point tool, everything an agent needs to select and invoke it is present.

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 optional parameter (context) exists and schema coverage is 100%, so the schema already documents it fully. The description never references the context/intent parameter, but the baseline for a fully documented single optional param is 3.

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 (return how ELC company membership works), the exact payload (reach figures, two qualifying questions with valid answers), and the audience (companies, personas HR/CTO/employer branding). It explicitly differentiates itself from sibling match_package by naming it as the follow-up step and from the individual-mentor path.

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?

"START HERE for any company considering an ELC membership" gives an unambiguous entry condition, and "Companies only — individuals seeking a mentor for themselves get pointed to /mentor/ instead" supplies an explicit exclusion with the alternative. The trigger for the next tool ("After the visitor answers both questions, call match_package") sequences the flow.

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

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

Annotations already establish read-only, idempotent, non-destructive, closed-world behavior, and the description adds substantial context beyond them: the exact payload contents (prices, lead time, examples, reach figures), the combo discount rule, the 90-day credit against a membership, and what is not for sale. For a schema with no output schema, disclosing the return contents is genuinely valuable.

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 'START HERE' and organized into scope, contents, handoff, and next step. The nine-item enumeration is longer than strictly necessary but each item adds concrete disambiguation value, so it largely 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 and a single optional intent parameter, the description carries the full informational burden and does so: it explains returns, business rules, boundaries, and routing. Nothing an agent needs to select or call this tool 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?

One optional parameter with 100% schema description coverage, so the schema fully explains the 'context' intent field and the description need not repeat it. Baseline 3 applies; the description contributes no additional parameter meaning.

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 with an explicit scope statement: 'START HERE when a company wants ONE thing once, not a year-long membership.' It enumerates concrete deliverables and names the sibling it is not (get_partnership_options for memberships), so an agent can distinguish it from alternatives 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?

Explicitly states when to use it (one-off purchase, not a year-long membership), when to hand over (two or more things across a year → get_partnership_options), and the logical next step (quote_reach_combo once items are picked). Full when/when-not/alternatives coverage.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds useful context by disclosing the return shape (a menu of questions mapped to answering tools) and the routing behavior, though it says nothing about output size, pagination, or how the menu is structured beyond 'mapped to tool name'.

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

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

Three sentences, front-loaded with the call triggers, then the return value, then the sibling routing. No filler; each sentence carries distinct 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?

There is no output schema, so the description appropriately compensates by explaining what the tool returns and how the result is organized. For a zero-required-parameter routing tool, 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 optional 'context' parameter is fully documented in the schema, including the note that it never changes the answer. The description adds no parameter-level meaning, so the baseline of 3 applies.

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

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

The description states a specific function — an onboarding/router tool that returns a menu of real questions mapped to the tool names that answer them — and clearly distinguishes itself from siblings by naming get_partnership_options as the alternate route. An agent can tell exactly what this tool is for 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?

Explicit triggers are enumerated (greeting, hello, connectivity/liveness test, 'what can you do', any too-general message), and an explicit exclusion routes ELC membership prospects to get_partnership_options. This is close to ideal 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, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds real behavioral context beyond that: the matrix is the same one the website uses, bad input produces an error listing valid ids, and the optional context value is recorded as intent but never changes the answer.

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 what the tool does and its output, then error handling, then next steps. No filler, no restatement of the name or title.

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

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

No output schema exists, so the description carries the return-value burden and does explain that packages, real prices and default line items come back. It covers error behavior and downstream chaining. Minor gaps remain on whether multiple matches are common and what happens if the matrix yields no match.

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 goal, budget and context are already documented, including that context never affects the answer. The description only adds the fuzzy-mapping guidance ('map free-text answers to the closest valid id'), which refines usage rather than the parameters themselves. Baseline 3 applies 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?

Specific verb and resource: it resolves goal+budget through a named routing matrix and returns matched packages with real prices and default line items. That is far more concrete than the title alone. It does not, however, distinguish itself from the sibling fit_to_budget, which plausibly does related budget matching, so an agent still has to infer which of the two to call.

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 invocation guidance: map free-text answers to the closest valid id, and on error re-ask rather than guess. It also routes forward explicitly to customize_package (to toggle line items) and request_offer (to send as-is). It stops short of naming when NOT to use this tool in favor of fit_to_budget or design_journey.

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 readOnly/idempotent annotations, it discloses concrete business behavior: combo discount is by item count, job board listings never count, and the AI-channel percentage does not apply to one-offs. The authoritative-total warning ('never add prices yourself') is useful operational guidance.

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 front-loaded sentences cover action, outputs, business rules, and next steps without repeating schema fields. 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?

With no output schema, the description carries the responsibility for return-value shape and does so explicitly: item prices, list total, combo discount, final total. It also covers the notable exclusions and follow-up tools, so an agent has enough context to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds meaning beyond the schema by telling the agent to pass the ids the visitor picked and by flagging that job-listing ids are valid but excluded from the discount. It does not need to restate the schema's parameter list.

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?

Title and description name a specific verb ('Price') and resource ('one-off basket'), and the description states the exact outputs: per-item price, list total, combo discount, and final total. It also marks itself as 'the only arithmetic that counts', which separates its role from any other pricing tool.

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

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

The description gives clear context—use it when pricing the one-off ids a visitor picked—and tells the agent not to do its own arithmetic. It suggests book_intro_call next and routes to get_partnership_options for a year-long basket, though the condition 'starting to look like a year' is less explicit than a crisp when-not rule.

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 indicate write operation (readOnlyHint=false) and the description adds rich behavioral detail: the refusal condition for unconfirmed totals, the email/Slack notifications, the partner queue filing, and the clarification that the discount is already granted regardless of the optional ask. No contradiction with annotations; in fact, it expands on them.

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

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

The description is a single paragraph but well-structured: front-loads the core purpose, then lists effects, then gives timing guidance, then post-action steps. Every sentence adds operational value, though it is longer than strictly necessary. Still efficient and easy to scan.

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 9 parameters and no output schema, the description provides clear usage context, constraints, and post-conditions. It covers the timing, the refusal rule, and the optional ask, which is comprehensive for an agent to call it correctly. Missing edge-case error handling but not required for selection.

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 all 9 parameters. The description adds only marginal param-specific meaning (e.g., emphasizing final_price_confirmed must be true) but doesn't go beyond what the schema provides. Baseline 3 is appropriate given the 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?

The description states a specific action (sends the offer, collects details, applies discount) and clearly differentiates from siblings by claiming it's the ONLY tool that collects contact details. It also names the exact effects (email, Slack, partners queue). This is unambiguous and resource-specific.

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 states when to ask for details ('only when the visitor says they want the offer — never earlier') and what to do after success (share confirmation, make one optional ask). The 'ONLY tool' clause serves as an implicit alternative exclusion, telling the agent this is the sole path for contact collection.

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