Barbaro

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is known. The description adds useful behavioral context by stating 'No persistence' and emphasizing that this is a calculation over unique published ingredient IDs, with no indication of any contradiction 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 three short sentences with the main action front-loadedaren't followed by concise clarifications. There is no redundant restatement of the title or schema, and every sentence adds 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 single-parameter, annotation-covered calculation tool, the description is nearly complete: it names the input domain, the output shape, and side-effect behavior. However, no output schema exists and the description does not define what 'meters' are or list exact return fields, leaving a small gap for response interpretation.

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 input schema only documents an array of UUID strings with uniqueness and maxItems constraints; it does not describe the domain meaning. The description compensates by explaining that the IDs are ingredient IDs, must be published, and are used to produce six balance contribution totals and meters.

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 ('Calculate') and resource ('six balance contribution totals and meters') and scopes it to 'unique published ingredient IDs'. It also explicitly excludes what it is not ('Not nutrition or ingredient weights'), making the tool's purpose easy to distinguish from sibling tools like get_ingredient or search_ingredients.

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 conveys when to use the tool: when you need balance contribution totals and meters for unique published ingredient IDs. It includes exclusions ('Not nutrition or ingredient weights. No persistence.'), though it does not explicitly name an alternative sibling tool or state when another tool should be preferred.

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

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

The annotations already declare readOnlyHint, idempotentHint, destructiveHint false, and closed-world behavior. The description adds useful return-content information (quantities, warnings, source information, a Dough continuation link) and states 'No persistence,' which goes beyond the structured fields. 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?

Three tight sentences, front-loaded with the core action, followed by return information and a persistence note. Every sentence earns its place 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?

Given a 25-parameter tool with no output schema, the description gives a brief return summary but omits key behavioral constraints such as fixed temperature assumptions, buffer requirements, and flour-mode ball-target behavior. Those details appear only in the schema description, making the tool description minimally adequate but not rich.

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 only broadly gestures at 'gram sizing, percentages and published or custom flours.' With 25 parameters and only 40% schema description coverage, it fails to compensate for undocumented parameters like dmp, pff, buffer, oil, salt, and many others. The schema carries the burden, but the description adds almost no 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?

The description uses a specific verb ('Calculate') and resource ('dough formula'), and names the input basis (explicit gram sizing, percentages, published or custom flours). This clearly identifies the domain apart from siblings like calculate_balance, get_flour, or plan_bake.

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?

No when-to-use or when-not-to-use guidance is provided, and no alternatives or prerequisites are mentioned. The agent must infer usage solely from the capability statement, with no routing help among the many 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that the result is public catalog data with source links and credits, which is useful but limited; it does not address missing identifiers, access restrictions, or error 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 short sentences with no filler. The core operation and identifier format are front-loaded, and the return-content note earns its place by indicating what the agent can expect.

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 tool with strong annotations and a fully documented schema, the description is complete enough for correct invocation. The absence of an output schema is adequately compensated by the note about public catalog data with source links and credits.

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 input schema already describes the id parameter in detail, including UUID vs slug constraints and resolution behavior. The description merely repeats 'by UUID or slug' without adding meaning beyond what the schema provides, so the baseline score 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 uses a specific verb ('Read') and a clear resource ('published flour'), and it identifies the identifier forms (UUID or slug) plus the return payload. It does not explicitly name or differentiate from sibling tools like search_flours, though the lookup-by-identifier framing implies the distinction.

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 context is implied: use this tool to fetch a specific published flour when you already have its UUID or slug. However, there is no explicit guidance about when not to use it or when to prefer a sibling like search_flours, leaving the routing decision mostly 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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds valuable context about the response contents (source links and credits) and the 'public catalog' scope, which goes beyond the annotations. No contradiction is present.

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 concise sentences with no filler. The action is front-loaded, and the return-value note is brief but informative. 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 gives a high-level idea of the response ('source links and credits') which is sufficient for an agent to know what to expect. It does not cover error cases or availability, but for a simple read tool with strong annotations, this is adequate.

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

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

Schema description coverage is 100%: the schema already documents that 'id' must be a canonical UUID (case-insensitive) and explains why slugs are not valid. The description simply repeats 'by UUID' without adding further parameter meaning, so a baseline score 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?

The description uses a specific verb ('Read') and resource ('published ingredient by UUID') and notes the return content ('public catalog data with source links and credits'). This clearly distinguishes it from sibling tools like search_ingredients (which search by criteria) and get_flour/get_pizza (different resource types).

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 when a UUID is available, but does not explicitly state when to prefer this over search_ingredients or get_flour. There is no mention of alternatives or exclusions, leaving the agent to infer the appropriate context from the parameter requirements.

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 with readOnlyHint, idempotentHint, and destructiveHint, so the bar for additional behavioral disclosure is lower. The description adds that the data is public and includes source links and credits, but it does not describe error behavior, not-found handling, or any further response structure.

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

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

Two short sentences with no wasted words. The identifier mechanism is front-loaded, and the return summary follows immediately, making the definition 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 one-parameter read-only tool, the definition covers how to identify the target and what kind of data will be returned. The lack of an output schema is partially compensated by the return-value hint, though a more explicit statement about not-found or error responses would make it fully 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?

The schema description coverage is 100% and the id parameter is already well documented with a pattern, length constraints, and semantics. The description's 'by UUID or slug' restates the schema rather than adding new meaning, so it stays at the baseline for fully-covered 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?

States a specific verb ('Read'), a specific resource ('published house pizza'), and the accepted identifier forms ('UUID or slug'). This clearly differentiates it from sibling search and list tools, which operate over collections rather than a single identified pizza.

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 intended usage is clear: call this when you already have a UUID or slug and want the public catalog record for one published pizza. It does not explicitly name alternatives like search_pizzas for discovery or read_menu for menu-level reads, but the context is unambiguous enough to guide selection.

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 idempotentHint=true, covering the safety profile. The description adds substantial behavioral detail: stages must be sequential and contiguous, ending at oven entry, time offsets must match the IANA zone, no fermentation prediction, unique stage IDs, duration bounds, and no persistence. These constraints go beyond annotations and help the agent understand expected input invariants, though the actual output behavior is not disclosed.

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

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

The description is concise, with no filler, and front-loads the core concept of caller-provided stages ending at oven entry. The subsequent constraint list is dense but purposeful. It is not overly long, and every phrase adds information, though the structure is a run-on list rather than a clear paragraph.

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 (5 parameters, nested stages, no output schema), the description is incomplete. It does not explain what the plan actually is or what the tool returns, nor does it clarify the meaning of 'method'. It focuses on input constraints but omits output semantics and usage context. For a non-trivial planning tool, this is a significant 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?

With schema description coverage at 0%, the description must compensate. It adds meaning to some parameters: stages are implied by 'sequential, contiguous stages', bakeStartAt is implied as the oven-entry time, availableFrom as the horizon, and timeZone via the IANA requirement. However, it does not explain 'method' at all, and the constraints are terse rather than explanatory. It partially compensates but leaves gaps.

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 title and description indicate this tool plans a bake by scheduling sequential stages that end when the first pizza enters the oven. It is distinguishable from sibling search/read/calculation tools, though the description reads more as a constraint list than an explicit statement of function. A clearer verb like 'generate a bake timeline' would strengthen clarity.

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 no explicit guidance on when to use this tool versus alternatives. It mentions constraints like 'No fermentation prediction' and 'Windows are marginal, not independently selectable' but does not state that the tool should be used for bake planning or that it should not be used for other purposes. No sibling tools are referenced as alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so safety is covered. The description adds useful context by noting the data is public and includes source links and credits, but does not disclose further behavioral details such as pagination or freshness.

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

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

Two short sentences, both informative and without filler. The core purpose is front-loaded, and the second sentence adds a valuable detail about return content.

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

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

For a zero-parameter, read-only tool, the description covers the essentials: what it reads and what it returns. No output schema exists, so the description's mention of public catalog data, source links, and credits partially fills that gap, though a more precise return shape would be richer.

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 there is nothing for the description to add beyond what the schema already conveys. The baseline of 4 for parameterless tools 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 names a specific verb ('Read') and resource ('published menu sections and their pizza IDs'), making the tool's function clear. It does not explicitly differentiate among siblings, but no sibling targets menu sections, so the risk of confusion is low.

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 no explicit guidance on when to use this tool versus alternatives. Context is only implied by the name and resource; no conditions, exclusions, or sibling routing are mentioned.

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, and destructiveHint, so safety is covered. The description adds value by disclosing that results come from public catalog data and include source links and credits, but it does not explain pagination behavior, result shape, or any other runtime traits.

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 concise, front-loaded sentences with no filler. The scope ('Search published flour facts') is stated first, followed by the useful return-behavior line about public data, source links, and credits.

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 low-complexity search tool with no required parameters, the schema covers inputs and annotations cover safety. The description covers the return value at a high level, which is important because there is no output schema. A small gap remains: the exact structure of the catalog results is not described.

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 (q, limit, offset) are already fully documented in the input schema. The description does not add new parameter-level meaning beyond what the schema provides, 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 clearly states a specific verb and resource: search published flour facts. It also distinguishes itself from siblings by noting it returns 'public catalog data with source links and credits,' which separates it from get_flour and the other search 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?

No guidance is given on when to use this tool versus alternatives like get_flour, search_ingredients, or search_pizzas. The word 'Search' implies usage, but there is no explicit when/when-not or reference to a sibling that fetches a single flour.

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 read-only, non-destructive, and idempotent, so the description doesn't need to repeat safety. It adds that the tool 'Returns public catalog data with source links and credits', which gives a bit of return-context but nothing further on behavior. 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 short sentences: the action and the return type are stated immediately, no filler or redundant 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?

No output schema exists, so the description compensates by indicating the return holds public catalog data with links and credits. It doesn't cover pagination or result structure, but parameters are well-documented in schema and the tool is a straightforward read-only search.

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 each parameter already described. The description adds no extra meaning to parameters, 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?

Description uses a specific verb 'Search' with a clear resource 'published ingredient facts' and adds return content. It implicitly distinguishes from sibling search_flours and search_pizzas by covering all ingredients rather than a particular category.

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?

No guidance on when to use this tool versus alternatives. It doesn't state that it is the general ingredient search or mention exclusions like 'use search_flours for flour-specific queries'. The context is implied but not explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds that it returns public catalog data with source links and credits, providing behavioral context about the response content. 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?

The description is two short sentences, front-loaded with the action and outcome. No filler or redundant information; 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?

The description covers the essential purpose and return content. Without an output schema, it mentions the key output elements (public data, source links, credits). It omits details like pagination behavior, but given the rich parameter schema and annotations, the description is adequate 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 description coverage is 100%, so all three parameters (q, limit, offset) are fully documented in the schema. The description adds no parameter-specific meaning beyond what the schema provides, 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?

The description clearly states the action ('Search published house pizzas') with a specific resource, and distinguishes it from siblings like search_flours and search_ingredients. It also specifies what it returns (public catalog data with source links and credits), adding precision.

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 for searching pizzas but does not explicitly mention when to prefer this tool over siblings like get_pizza or read_menu. It lacks explicit exclusions or alternative routing, so guidance is only implicit.

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, and destructiveHint=false, so safety is covered; 'No persistence' largely duplicates that. The description does add non-obvious behavior: pizza references 'annotate topping needs only; they do not multiply dough', custom ingredients are 'never merged across batches', and the custom id format — genuinely useful rules an agent could not infer.

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 text is a dense run of clipped fragments ('Ready starter is separate from fresh ingredients. Topping quantities are unknown. No persistence.') that reads like schema notes rather than an agent-facing preamble. It is neither front-loaded with a purpose statement nor organized into scannable guidance.

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 a deeply nested schema, 0% description coverage, and no output schema, the description should explain what comes back and how batches/flours/pizzas combine. It gestures at a few rules but omits the return shape (a list of ingredients with quantities?) and the topping-need model, leaving critical gaps.

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

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

Schema description coverage is 0%, so the description must carry weight, and it does explain that pizzas are topping annotations rather than dough multipliers and gives the custom ingredient id syntax custom:<batchId>:<rowId>. However, it never explains the 'batches' structure or the relationship between batches, flours, and the resulting list, leaving much of the parameter semantics opaque.

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

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

The description never states what the tool produces — no verb like 'compute', 'aggregate', or 'return' a shopping list appears. Instead it opens with a restatement of the batches constraint ('One to eight uniquely identified, already-sized Dough requests'), which is parameter semantics rather than purpose. Only the name and title hint that a shopping list is generated, and nothing distinguishes it from siblings like calculate_dough or plan_bake.

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 statement of when to call this versus calculate_dough, plan_bake, or read_menu, and no prerequisites or ordering guidance. A reader learns constraints ('Topping quantities are unknown', 'No persistence') but not when this tool is the right choice.

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