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

No annotations are provided, so the description carries the full burden. It does disclose that the tool 'writes live Brewfather data,' which is a key behavioral trait. It also states the confirmation requirement. However, it doesn't mention potential side effects (e.g., overwriting, undo-ability), failure modes, or permission needs. This partial transparency warrants a 3.

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 sentences, front-loaded with the action and a warning. Every clause adds value—the write intention and the confirmation gate are both critical. There is no fluff, making it highly concise and well-structured.

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 only one parameter and no output schema, the description still fails to explain the parameter's purpose or where it comes from. It also lacks information about response format or error handling. Given the tool's simplicity, this is inadequate. A 2 is appropriate.

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

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

Schema coverage is 0%, so the description must explain the parameter, but it doesn't mention 'confirmationToken' at all. The description says 'after the user explicitly confirms' but gives no hint of what the token is or how to obtain it. The agent is left without guidance on the single required parameter. This is a significant gap.

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 ('Create the recipe') and the context ('from a prior preview'). It distinguishes itself from sibling preview tools by explicitly noting it writes live Brewfather data, and the name itself suggests application of a preview. However, it doesn't explicitly compare to sibling apply/update tools, so a 4 is appropriate.

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 an explicit condition: 'Only call after the user explicitly confirms that exact preview.' This tells the agent when to use it, and implies it should not be called without that confirmation. It doesn't reference alternative tools (like preview or update), but the condition is clear enough. A 4 is justified.

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?

No annotations are provided, so the description carries full burden. It discloses the write side effect ('writes live data'), a failure mode (rejection if recipe changed), and a safety gate (explicit user confirmation). It does not mention success return format, but with no output schema and a single param, this is reasonably transparent for a mutation.

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

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

Three concise sentences with no fluff. The first sentence states the purpose, the second provides behavioral context and a failure condition, the third gives an explicit usage prerequisite. Every sentence earns its place and the key information is front-loaded.

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

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

For a simple mutation with one parameter and no output schema, the description covers the essential action, prerequisites, and a failure mode. However, it omits where the confirmationToken comes from (likely the preview response) and what constitutes a successful apply. This leaves an agent slightly uncertain about the full call flow, though the sibling tools could fill in the 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?

There is 0% schema description coverage and the description never explains what 'confirmationToken' is or where it originates. It implies it comes from a prior preview but does not explicitly state that. The only schema metadata is minLength, which is insufficient for an agent to know how to obtain or use the token 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 states the action: 'Apply a previously previewed recipe update' with a specific verb and resource. It distinguishes from siblings like preview_recipe_update by implying this is the final write step, and from apply_recipe_create by specifying 'update'. The phrasing 'writes live Brewfather data' reinforces the mutation nature.

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 the prerequisite: 'Only call after explicit user confirmation' and a critical condition: 'server rejects if recipe changed after preview'. This implies the agent should have previewed first and should not call prematurely. It does not explicitly contrast with apply_recipe_create, but the name and sibling context make the distinction clear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states that the action is read-only and that it never returns credentials, which are critical safety and privacy traits. It does not mention return format or potential side effects, but these are minor given the tool's simplicity.

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 only two short sentences, with the core purpose front-loaded and the behavioral caveat immediately following. Every word earns its place; there is no redundancy or filler.

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

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

For a zero-parameter tool with no output schema, the description is mostly complete, but it fails to specify what the tool returns. The phrase 'check whether ... work' implies a boolean or status result, but this is not explicit. An agent would benefit from knowing the return shape to interpret the result correctly.

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

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

The tool has zero parameters and the schema description coverage is 100% (vacuously). Per the rules, the baseline is 4 when there are no parameters. The description adds no parameter semantics because there are none to explain, but it does not neglect anything.

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 ('check') and resource ('local Brewfather credentials') along with the intended purpose ('whether they work'). It is immediately distinct from all sibling tools, which are recipe-oriented (list, search, get, preview, apply).

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 when to use the tool (to verify credentials) but does not explicitly mention alternatives or exclusions. Since no sibling tool overlaps in function, the usage context is clear enough but lacks explicit guidance on when not to use it or prerequisites.

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

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

With no annotations, the description carries the burden. It discloses read-only behavior and completeness of the returned recipe. It does not mention error handling or auth, but for a simple get this is acceptable.

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

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

Two sentences with no fluff. The main action is front-loaded, and usage guidance follows efficiently.

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?

Complete for a single-parameter retrieval tool with no output schema. It explains what it does, how to obtain the ID, and that it is read-only. 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 0%, so the description must compensate. 'by its _id' clarifies the parameter is the recipe identifier, and the guidance to call list/search first explains its origin, adding meaning beyond the schema.

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

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

The description clearly states 'Get one complete Brewfather recipe by its _id', specifying the verb, resource, and identifier. It also notes 'Read-only', distinguishing it from create/update 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?

Explicitly advises 'Call list or search first if only a recipe name is known', telling the agent when to use alternative tools. This provides clear routing and prerequisites.

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

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

With no annotations, the description must carry the behavioral burden. It explicitly states 'Read-only', which is a critical safety disclosure. It also mentions that results are compact unless complete=true, and hints at pagination behavior. However, it does not disclose rate limits, authentication needs, error behavior, or what fields are present in compact vs. complete modes. These gaps are notable for a tool with no annotations and no output schema.

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 sentences with no fluff. The core purpose is front-loaded, and the pagination hint is placed after. Every sentence adds value, and there is no redundant information. It is appropriately concise, though it sacrifices depth for brevity.

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 tool has 6 parameters, no output schema, no annotations, and very little description. The description does not cover parameter semantics, return format, error handling, or filtering capabilities. The agent would have to make educated guesses about how to construct a valid request. For a listing tool with multiple optional parameters, this is severely incomplete.

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%, meaning the description does not elaborate on any of the six parameters. The mention of 'startAfter' and 'complete' is incidental but does not explain their meaning or usage. Parameters like 'limit', 'include', 'orderBy', and 'orderByDirection' are entirely undocumented in both the description and the schema (which has no descriptions). The agent is left to guess parameter formats and semantics, making this a severe deficiency.

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 ('List') and resource ('Brewfather recipes'), which unambiguously defines the tool's primary function. It does not explicitly differentiate from the sibling 'brewfather_search_recipes', but the act of listing without filters is distinct enough that an agent can likely infer the difference. The read-only note further clarifies intent.

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 guidance on when to choose this tool over its siblings like 'brewfather_search_recipes' or 'brewfather_get_recipe'. It only mentions pagination usage ('Use startAfter with the last _id'), which is a usage instruction for a parameter, not a tool-selection guideline. The agent receives no context about when listing is appropriate vs. searching or fetching a single recipe.

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?

With no annotations, the description carries the burden of behavioral disclosure. It states that the tool does not write ('without writing it') and that it reports normalizations and rejections. However, it does not explicitly state it is read-only or describe the exact output format of the preview, leaving a minor gap for an agent to infer the response shape.

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 and front-loaded: it starts with the core action and the required sequencing, then adds relevant constraints. Every sentence adds value, and there is no redundancy or filler.

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

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

For a tool with a single rich parameter and no output schema, the description covers what an agent needs to call it properly. The main omission is the exact shape of the response (what the preview returns), but given it's a validation step, the description communicates enough for correct invocation. A brief description of the return value would make it 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 recipe parameter schema description is exceptionally detailed, covering common fields, metric units, color normalization (EBC vs lovibond), allowed misc units and aliases, and a warning about string tags. It adds substantial meaning beyond the bare schema, making it easy for an agent to construct valid inputs.

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: 'Prepare and validate a new Brewfather recipe without writing it.' It uses a specific verb (prepare/validate) and resource (new recipe), and explicitly distinguishes from the sibling apply tool by saying 'Always call this before brewfather_apply_recipe_create.'

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 usage guidance: call this before the apply tool, and it warns about rejected inputs (string tags, unsupported miscellaneous units). It provides a clear ordering rule and constraints, leaving no ambiguity about when to use it versus 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It accurately discloses merge semantics (deep-merge for objects, replace for arrays), the normalization report (unit/color), and rejection conditions (string tags, unsupported misc units). It does not mention any side effects, authentication, or rate limits, but for a preview tool these are less critical. The behavior described is consistent with the tool's name and purpose.

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 sentences, front-loaded with the primary purpose, followed by essential behavioral details. Every sentence earns its place—no fluff, no repetition. The information is dense but organized logically: purpose, output, merge behavior, and error handling.

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 preview tool with two parameters, the description covers the key aspects: purpose, merge semantics, error conditions, and the need to fetch the recipe for arrays. It does not specify the exact structure of the preview report or what the 'confirmation' step entails, but that might be handled by the apply tool. Overall, it is adequate for an agent to correctly invoke the tool, with minor gaps around the exact response format.

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 covers only the 'changes' parameter (with a description about partial objects and complete arrays), while 'recipeId' has no description. The tool description compensates by elaborating on array replacement ('send a complete ingredient array') and rejection criteria, which adds beyond the schema. However, it still lacks a precise description of what 'changes' can contain beyond the schema's generic object definition. Overall, it adds meaningful context.

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 verb (validate and preview), the resource (recipe update), and the key distinction of not writing. It explicitly sets it apart from apply_recipe_update, and the mention of 'preview' makes the dry-run nature obvious even without reading the 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 implies when to use this tool (when you want to validate changes before applying) and provides operational guidance for nested objects and arrays. It does not explicitly name alternatives like 'apply_recipe_update' or 'preview_recipe_create', but the context of 'without writing it' and the sibling list makes the intended usage clear. A slight deduction for not explicitly mentioning alternatives when they exist.

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?

With no annotations, the description carries the full burden. It does state 'Read-only' and that pagination is local and 'can use several API calls,' which is a useful heads-up about possible latency/cost. However, it doesn't disclose what happens on pagination (does it auto-fetch all pages? does it cap?), any rate limits, or error behavior. It's above minimal but lacks rich detail.

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

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

Two sentences with zero fluff. The first sentence front-loads the action and searchable facets, the second adds critical behavioral notes (read-only, pagination). Every word earns its place; it is appropriately terse.

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 is provided, and the description doesn't describe the return shape (what a result contains, ordering, total hits). It mentions pagination but doesn't specify how many results per page or how 'maxPages' affects the response. An agent inferring from the schema knows only that three numeric constraints exist. For a search tool, this lacks important operational details like result format and pagination semantics, so it is incomplete for safe invocation.

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

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

Schema has zero descriptions (0% coverage), so the description must explain the parameters. It lists the search fields (name, author, type, style, equipment) but does not clarify how they map to the single 'query' parameter—is it a free-text search across those fields or a structured filter object? 'limit' and 'maxPages' are self-evident from names and numeric bounds, but the description adds no guidance on how they interact or what values are sensible. The description only partially compensates for the schema gap.

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 ('search') and resource ('Brewfather recipes') and enumerates searchable attributes (name, author, type, style, equipment). This clearly differentiates it from siblings like list_recipes (which likely returns all recipes) and get_recipe (which fetches by ID). It stops short of naming those siblings explicitly, so it's not a top score, but the purpose is unambiguous.

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

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

There is no explicit guidance on when to use this tool versus the sibling list_recipes or get_recipe. The description implies filtering is the use case ('by name, author...'), but it never says 'use this when you need to filter' or contrasts it with listing all recipes. Without that, an agent could pick the wrong tool for a straightforward list request. No when-not or alternatives are mentioned.

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