btw

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

The annotations already provide readOnlyHint=true and openWorldHint=false, covering the main behavioral safety concern. The description adds the count categories and a sibling pointer, but it does not disclose additional behavioral traits such as data freshness, rate limits, or how 'live/queued/filled' are defined. No contradiction exists.

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 the core function front-loaded and a routing pointer after. No wasted or redundant words; every phrase contributes to understanding or usage.

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 stats tool, the description adequately communicates the output categories and routes to a sibling for more detailed status. Some ambiguity remains about what 'book' refers to and the exact meaning of 'live product', but an agent can invoke the tool directly without missing required information.

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 schema coverage is 100%, so the baseline is 4. The description does not need to explain parameters, and it doesn't.

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 the tool provides counts for three categories (live, queued, filled), which is specific about the resource and output. It also distinguishes itself from the status sibling by pointing to status for the live product. It misses a clear verb like 'returns' or 'fetches', so it doesn't earn a 5.

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

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

It gives an explicit routing hint: 'Use status for the live product.' This indicates a when-not-to-use condition for one alternative. However, it never explicitly states when to use book_stats (e.g., 'when you need aggregate counts'), and the phrase 'live product' is ambiguous, so usage guidance remains mostly implied.

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

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

readOnlyHint=true already signals a safe read, and the description adds no behavioral detail such as return shape, error behavior, or whether this is a lightweight summary. It does not contradict the annotations.

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

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

The description is very short, but 'Prefer status' is cryptic and does not earn its place. The two fragments leave key information implied rather than stated.

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 lookup with no output schema, the description should at least state what the returned chain data is and clarify the status preference. It does neither, so an agent would likely need to probe the tool or guess.

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 id is described as 'chain slug', so the description's 'by slug' is redundant. No additional meaning or format detail is provided 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 phrase 'One product by slug' conveys that the tool fetches a single item by its slug, but the resource is inconsistently called 'product' while the tool/title say 'chain', and no explicit verb appears. 'Prefer status' adds ambiguity rather than clarifying what this tool returns.

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

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

'Prefer status' hints that the status sibling may be preferred, but it gives no condition, context, or exclusion for when to call get_chain instead. No other alternatives or prerequisites 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?

The description richly discloses behavior beyond annotations: it explains that nothing is charged now, the deposit is charged only if the product fills, and test mode is used with test cards only. It also describes pricing tiers (early vs group price). This adds substantial context that annotations do not cover, making the tool's side effects clear and actionable.

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 somewhat long but every sentence contributes meaningful information. It is front-loaded with the core action ('Hold your human a spot'), then covers requirements, return, pricing, and payment behavior in a logical order. No redundant sentences are present, though it could be trimmed slightly without losing value, so it earns a 4 rather than a 5.

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 that holds a spot and handles payment, the description covers all essential aspects: what it does, the required email, the return values (price and link), the pricing logic, the charging conditions, and the test mode. Since there is no output schema, the description adequately explains what the agent can expect from the response. An agent would know exactly how to call it and interpret results.

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

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

The input schema already provides descriptions for all six parameters (100% coverage), so the baseline is 3. The description mentions 'Needs their email' but this is already in the schema. It does not add extra meaning or syntax details for parameters like 'ref' or 'chain' beyond what the schema provides. Thus, it does not improve upon the schema's documentation.

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

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

The description opens with a specific verb and resource: 'Hold your human a spot on the live product.' It clearly states the action (hold a spot) and the object (a spot on the live product), and goes on to describe the outcome (returns price and link). It distinguishes itself from siblings by describing the specific pricing tiers and charging behavior, which is unique to this tool among the listed siblings like 'park' or 'waitlist'.

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 context about when the tool is used (to hold a spot on a live product) and the implications (test mode, charging behavior), but it does not explicitly mention alternatives or when not to use it. It lacks explicit exclusions like 'use this instead of waitlist if...' or 'do not use if...' which would earn a higher score. The usage is implied rather than directly guided.

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

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

The description discloses substantial behavioral detail beyond annotations: no charge happens immediately, a link is returned, pricing tiers differ based on spot order, conditional deposit charging occurs only if the product fills, and Stripe test mode is used with test cards only. This lets the agent understand the real-world effects of invocation.

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 somewhat long but every sentence carries relevant operational information: pricing, return value, charge behavior, and test-mode limitation. It is front-loaded with the alias relationship and tool purpose. Minor awkward phrasing like 'your human a spot' prevents a perfect conciseness score.

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

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

For a tool with no output schema, the description explains the return contents (price, link, tier), the pricing rule, and the charge lifecycle, which gives an agent enough to invoke it and interpret results. It could be more complete by explicitly stating the deprecation policy and directing callers to the 'hold' tool, but the 'old name' mention partially covers this.

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 100% of parameters with descriptions, so the baseline is 3. The description adds only that email is required, which is already in the schema as a required field. It does not meaningfully augment parameter-level 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 identifies the tool as 'the old name for hold' and states its action: holding a spot for a human on the live product. This explicitly links it to the sibling tool 'hold' and distinguishes it from unrelated siblings like join_chain or waitlist.

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 that this is a deprecated alias for hold and mentions the email prerequisite, but it does not explicitly say when to choose this tool over hold or provide exclusions for other alternatives. Usage guidance is implied rather than direct.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. However, the description adds almost no behavioral detail: it doesn't say whether calling this tool is a no-op, returns an error, or still performs a legacy mutation, nor what the response looks like.

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 deprecation fact is first and the replacement instruction second. Every word earns its place.

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

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

For a deprecated tool, the replacement pointer is largely sufficient, and the annotations cover the read-only safety profile. But the missing parameter semantics and lack of an output schema leave an agent uninformed if it ever has to call join_chain directly.

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% and the description does not mention id, team_name, or monthly_commit_usd at all. For a tool with three undocumented parameters, the description offers no semantic help.

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 identifies this tool as 'The old v1 join' and the title says 'Join a chain (old name)', so an agent can tell it is a legacy join operation. It also names the replacement 'hold', which distinguishes it from the sibling set. It stops short of explaining what joining actually does, but that is acceptable for a deprecated pointer.

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 instruction 'Use hold instead' is an explicit, unambiguous routing directive: for any join-a-chain use case, the agent should call hold rather than this tool. This is stronger than most sibling-differentiation 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?

The annotations already indicate destructiveHint=true and readOnlyHint=false, so the agent knows this is a mutating operation. The description adds valuable context beyond that: 'Nothing is charged for a released spot' and that the commitment id comes from 'hold or status.' These details clarify side effects and required input provenance, which annotations do not cover. It does not describe other consequences like reversibility, but the annotation coverage lowers the burden.

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 filler. The alias note is front-loaded, the action is stated clearly, and the parameter requirements and side-effect note are given efficiently. Every sentence adds needed information without redundancy.

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

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

For a three-parameter, no-output-schema tool with destructive annotations, the description covers the key facts: what it does, the required parameters and their sources, the destructive nature (via annotations), and the no-charge side effect. It does not explicitly mention that this is deprecated or that 'release' is the preferred name, but the title and first sentence imply it. This is nearly complete for an alias tool.

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

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

Schema description coverage is only 33% (only 'chain' has a description). The description compensates by explaining all three parameters: 'product slug' maps to chain, 'email that holds it' maps to email, and 'commitment id from hold or status' maps to commitment_id. This adds meaning beyond the schema, though it does not specify formats or optional details. Given the low coverage, this is a solid compensation.

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

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

The description clearly states the tool's action: 'Release a held spot.' It also explicitly identifies the sibling 'release' by saying 'The old name for release,' which distinguishes this tool as an alias. An agent can immediately understand the resource and action, and how it relates to the similar sibling.

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 preconditions: 'Needs the product slug, the email that holds it, and the commitment id from hold or status.' This implies when to use it (when you have a held spot to release). However, it does not explicitly say when to prefer this tool over 'release' or state that it is deprecated, nor does it mention alternatives like 'hold' or 'park'. The guidance is implied rather than explicit, so it is adequate but not strong.

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 no contradiction exists. The description adds some behavioral content by enumerating the chain entries ('the live one, what's up next by wants, and what filled or closed'), but it does not describe ordering, response shape, or what happens when there are no chains.

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?

At two sentences it is short, but the first sentence is a confusing, informal fragment ('Every product btw has run or queued') that front-loads a domain explanation instead of the tool's action. No space is wasted, but the structure sacrifices clarity.

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 list, the description conveys the general contents and points to the status tool, but it never states explicitly that list_chains returns a list of these chains or how they are represented. The cryptic phrasing leaves an agent to infer the basic behavior.

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

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

The tool has zero parameters, so the baseline is 4; there is no parameter meaning for the description to add, and the schema fully covers the empty input.

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

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

The description never states a direct verb+resource for list_chains; it opens with the cryptic 'Every product btw has run or queued...' and only implies that this tool returns the run/queued chain. The title supplies the action, but the description itself is vague about what the tool actually produces.

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 routing cue: 'Use status for the live one,' which tells the agent that status is the alternative when only the current live state is needed. It does not, however, explain other alternatives such as get_chain, so it is not a full routing guide.

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 the tool as read-only, and the description adds useful behavioral context: the confirmation-link prerequisite, the meaning of each status, and that the list is tied to the user's email. There is no contradiction with readOnlyHint=true.

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 content is useful but delivered as a single run-on sentence with parentheticals and awkward phrasing such as 'What your human's btw agent is watching.' Key facts are not front-loaded or separated, making it harder to parse.

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

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

For a single-parameter read-only tool with no output schema, the description covers the input, the output shape (list of items with statuses), status definitions, and an important precondition. It could be clearer about the exact return format, but nothing essential is missing.

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

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

Schema coverage is 100% and the one parameter's schema description already says 'your human's email.' The description repeats this as 'Takes their email' without adding format, constraints, or behavior 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 identifies the tool's output as the watched items for the user's 'btw agent' and enumerates the three possible statuses. It is more specific than the name/title, but it never uses an explicit verb like 'get' or 'list' and does not contrast with sibling tools such as status or list_chains.

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 call this tool instead of a sibling, and no alternatives or exclusions are mentioned. The only usage-related information is that it takes the user's email and that the list appears only after confirmation, which is a precondition rather than a selection 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 are all false and provide no safety or mutability signal, so the description must carry behavioral disclosure. It only says to 'park' a want and gives no information about side effects, persistence, idempotency, or what happens after parking. The phrase 'old style' hints at legacy behavior but does not explain it.

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 short and front-loads the core action before giving routing guidance. 'Old style' is slightly cryptic but not bloated; every sentence earns its place in a compact definition.

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 three-parameter tool with 100% schema coverage, the description is nearly sufficient to invoke it correctly. However, it does not explain what 'park' returns, whether email is needed for notifications, or how this relates to siblings like park_intent and want, leaving some contextual ambiguity.

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 three parameters. The description adds minor semantic color—'plain words' maps to description and 'most they'd pay' maps to max_price_usd—but provides no format, constraints, or edge-case guidance 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 says to 'park what your human wants in plain words with the most they'd pay,' which conveys the resource and action in a loose, jargon-heavy way. The verb 'park' is not clearly defined as creating or storing a want, and the description does not distinguish this from the sibling 'park_intent' or 'want' beyond the vague 'old style' phrase.

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 'Prefer want with a link,' which gives clear routing guidance toward an alternative tool when a link is available. It does not state exact conditions or exclusions, but the preference is useful enough for an agent to make a reasonable choice.

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 deprecation disclosure ('old', 'v1') is significant behavioral context that annotations don't convey — it tells the agent this tool is obsolete and should be avoided. readOnlyHint=true is consistent with a read operation and is not contradicted. What's missing is whether calling it still succeeds or errors, but the deprecation flag itself is 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?

Two short sentences with the deprecation warning front-loaded ahead of the alternative tool. Extremely economical for its purpose. It loses a point only because it's so minimal that it borders on under-specification — but for a deprecation stub, this is near-ideal conciseness.

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 deprecated tool with 5 parameters and no output schema, the description covers the essential facts: it's legacy, and want should be used instead. It omits what happens if the tool is called anyway (success vs error) and doesn't clarify that parameters are irrelevant. This is adequate but not complete for an agent that might encounter this tool in legacy data.

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 carries full responsibility for parameter meaning, yet it explains none of the five parameters (note, category, provider, monthly_cap_usd, min_discount_pct). Since the tool is deprecated and the agent is told to use want instead, parameters may be moot, but by the rubric the gap is severe — no semantic help is provided.

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 identifies this as 'The old v1 park' and instructs using 'want' instead, but never actually states what parking a standing order accomplishes. For an agent encountering this tool cold, the core action is undefined — it only knows it's a deprecated alternative to want. The reference to sibling 'park' is a shorthand that assumes prior knowledge.

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 instruction 'Use want with a link instead' is explicit routing to a sibling tool, which is strong guidance for a deprecated entry point. It clearly implies this tool should not be called. It doesn't elaborate on when want is preferred over other siblings like hold or waitlist, but for a deprecation notice the routing is sufficient.

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

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

Annotations already mark this as destructive, so the description does not need to repeat that. It adds a meaningful behavioral detail: 'Nothing is charged for a released spot.' This gives the agent useful side-effect information beyond the annotation hints.

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 terse sentences with no filler. The action is front-loaded, followed by the required inputs and a key side effect. Every sentence contributes value.

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

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

Given the modest complexity and the presence of annotations, the description covers what is needed to call the tool: required parameters, where the commitment id comes from, and the no-charge consequence. It does not describe the response format, but for a simple mutation without an output schema this is a minor gap.

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

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

Schema coverage is only 33%, but the description compensates by mapping all three parameters to their meaning: product slug, email that holds the spot, and commitment id from hold or status. It does not give format details, but it provides enough semantic grounding for correct invocation.

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

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

The description states a specific verb and resource: 'Release a held spot.' This clearly conveys the tool's action. It does not explicitly differentiate from sibling tools like leave, but 'release' and 'commitment id from hold or status' make the operation distinct enough.

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 prerequisites—product slug, email, and commitment id—and indicates the commitment id comes from hold or status. However, it does not explicitly state when to prefer this tool over alternatives such as leave or release-related siblings, so usage is implied rather than fully specified.

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, so the description carries a lower burden for safety disclosure. The description adds valuable behavioral detail by enumerating exactly what data is returned (list price, group price, buyer counts, committed counts, want counts, spots left, deadline) and how the optional parameters affect the response. This transparency goes beyond the annotation's binary read-only flag.

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 core output list, then explains parameter usage. Every phrase earns its place, with no redundancy or filler. The structure is 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 read-only status tool with no output schema, the description covers the essential return data and parameter semantics. It does not detail error cases or pagination, but given the tool's simplicity and the annotations covering safety, it is sufficiently complete for an agent to call it correctly. The only minor gap is lack of explicit guidance on when to choose this over a sibling tool.

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

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

Schema coverage is 100%, with both parameters described. The description reinforces and extends the schema by clarifying that 'chain' defaults to the live product when omitted and that 'email' reveals a specific person's spot. This adds contextual meaning beyond the schema's simple descriptions, such as the default behavior for the chain parameter.

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 function: it reports live status of a product chain, including price, counts, spots left, and deadline. It also explains how to query a specific product via slug, distinguishing it from a generic list tool. The verb 'what's live' plus the resource and specific data fields make the purpose 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 implies usage: it defaults to the live product unless a slug is given, and an email shows a person's spot. However, it does not explicitly mention when to use this tool over alternatives like get_chain or list_chains, nor does it state any exclusions or prerequisites. The guidance is adequate but not explicit about tool 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 provide readOnlyHint=false, openWorldHint=true, idempotentHint=true, destructiveHint=false, but the description adds substantial context beyond them: the side effect that a new email creates an agent, the return shape (items found and how many other agents want each), the server-failure behavior, and the boundary that btw doesn't buy from Amazon. These are exactly the behavioral disclosures annotations can't capture.

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 core action is front-loaded in the first sentence, and the description is dense with actionable information. However, the final sentence ('The link is how we know what you want; the group price comes from the brand.') is partly redundant with the purpose statement and adds only marginal value, keeping this from a 5.

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 correctly explains return values, failure modes, and side effects, giving the agent a complete decision tree for the fallback path. The one gap is that url and asins are both optional in the schema and the description only implies they are alternatives, never stating exclusivity or what happens when both are provided.

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 on top by explaining the fallback relationship between `url` and `asins` (pass ASINs only if the server can't read the list), the email side effect (a new email gets an agent), and that the URL is the signal for what the human wants. This goes beyond restating the schema fields.

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

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

The first sentence states a specific verb and resource: 'Read a public wishlist and add every item to your human's btw agent.' It names the supported sources (Amazon, Steam) and explicitly differentiates from the sibling `want` by describing it as the per-product fallback ('call want once per product link'), so an agent can tell this bulk-import tool apart from the single-item tools.

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

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

The description gives an explicit conditional routing path: if the server can't read the list, the agent should open it itself and pass ASINs, or call `want` per product link. It also notes the new-email side effect. This is clear context with named alternatives, though it doesn't state a primary when-to-use/when-not-to-use rule beyond the implied 'bulk wishlist import' case.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true, covering the basic safety profile. The description adds 'Old style' (legacy connotation) and the email requirement, but does not explain side effects (e.g., confirmation, list size) or what happens on success. It does not contradict annotations, and given the annotations, the added value is moderate.

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 brief and front-loaded with the core purpose. The 'Prefer want...' guidance is concise and useful, though the informal tone and 'Old style' label add slight ambiguity. It earns points for efficiency.

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 tool with 4 params and no output schema, the description covers the essential action and usage. However, it conflicts with the schema by stating email is needed when the schema marks it optional, and it omits any explanation of the 'referral' parameter. Given the low complexity and annotations, this is slightly 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 coverage is 100%, so all parameters are documented. The description highlights email as needed and names 'want' and 'platform' as optional, but does not mention 'referral'. This adds minimal value beyond the schema, so a 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 the action: putting the human on a list to hear about a product launch. It also differentiates itself from siblings by labeling itself 'Old style' and directing to prefer 'want' or 'hold', giving context on its role. However, the phrasing is informal and slightly ambiguous (e.g., 'next product'), which prevents a 5.

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

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

The description explicitly advises when not to use this tool: 'Prefer want with a link, or hold on what's live.' It also states a prerequisite ('Needs their email') and optional inputs. This gives clear routing guidance against siblings, exceeding the typical standard.

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 goes beyond the annotations by explaining side effects: a new email creates an agent, the agent starts watching the item, and the reply reports how many other agents already want it. It also adds the caveat that btw doesn't buy from Amazon, though idempotency and failure behavior are left to the annotations.

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

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

The description is information-dense and front-loaded with the core purpose and input format. The remaining sentences cover inference rules, explicit type fields, side effects, and caveats; a few terms like 'group price' and 'brand' are left unexplained, so it is not perfectly crisp.

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 14-parameter tool with full schema coveragechers, the description covers auto-detection, explicit types, required fields, side effects, and reply content. It omits the gym and gear field requirements and does not route to sibling tools, but those gaps are partially filled by the schema and enum.

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 adds meaningful relationships not present in the schema: link or ASIN plus email, conditional field requirements per type, and the alternative asins array when the page was already read. Since schema description coverage is 100%, this extra relational guidance is genuinely valuable.

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 clear operation: 'Add something to your human's btw agent,' and elaborates with auto-detection rules and explicit type/field combinations. It does not distinguish itself from the dedicated want_gym, want_home, want_software, and want_stay sibling tools, so an agent still has to infer the relationship.

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

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

It provides concrete invocation guidance: pass a link or ASIN plus email, use asins if you already read a page, and either let link type auto-detect or set type with required fields. However, it never says when to choose this generic tool over the sibling want_* tools, nor does it state any exclusions.

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

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

The description adds significant behavioral context beyond annotations: it explains the aggregation mechanism ('People near the same gym on the same plan count together') and the side effect ('when enough do, btw asks for a group rate'). This is valuable behavior disclosure that annotations (readOnlyHint false, idempotentHint true) do not cover. 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 concise sentences that front-load the purpose, then list the parameters, then state the behavioral nuance. There is no filler or redundancy; every clause contributes to understanding.

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 4 simple parameters, no output schema, and clear annotations, the description covers purpose, parameters, and the key aggregation behavior. It could optionally mention what happens after the want is recorded, but that is likely covered by the overall btw flow. Overall it is complete enough 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%, and the description essentially restates the parameters (name, five-digit zip, plan enum, email). It adds no new meaning beyond what the schema already provides, such as format, constraints, or purpose. The baseline of 3 is appropriate since the schema carries the semantic load.

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

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

The description clearly states the tool records a desire for a gym or studio membership: 'Your human wants a membership at a gym or studio near them.' It names the specific resource type and lists the key parameters, making it easily distinguishable from siblings like want_home, want_software, and want_stay.

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

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

The description makes it obvious when to use this tool: whenever the want is for a gym or studio. It does not explicitly mention alternatives, but the contrast with sibling tools is implicitly clear from the specific resource type. No exclusions or competing conditions are stated, but the scope is 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 goes beyond the annotations by explaining the aggregation behavior: nearby homes wanting the same job count together and can trigger a group quote. It also discloses the return value (how many others nearby want it). It does not define the threshold for 'enough' homes, but the key side effects and outcomes are stated.

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 tightly worded sentences with no filler. It front-loads the purpose and accepted job types, then covers inputs and behavior/return value. Every sentence earns its place and the structure makes the tool easy to understand quickly.

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 submission tool with no output schema, the description explains the inputs, the aggregation behavior, the group-quote outcome, and what is returned. It does not specify the exact response format, but the high-level return value is clear. This is sufficient for an agent to invoke the tool correctly.

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

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

Schema description coverage is 100%, and the schema already explains each parameter: job, zip, note, and email. The description repeats the optional note and email details without adding deeper semantic context. Since the schema carries the full parameter burden, the 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 states a specific action and resource: the human wants a home job done, and the tool accepts that job along with zip, note, and email. It enumerates the exact job categories (solar, heat-pump, etc.), so the agent can identify the intended domain and distinguish it from sibling tools like want_gym or want_software. The title and description together unambiguously define what this tool is for.

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

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

The description makes the use case clear through its home-job framing and job-type enum, so an agent can infer when to choose it. However, it does not explicitly state when not to use it or point to alternatives such as want_stay or want_gym. The guidance is implied rather than explicit.

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

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

Annotations already flag idempotentHint=true and readOnlyHint=false, and the description adds that it returns the number of other people wanting the same product on the same plan. However, it does not clearly state that it registers or writes a new want, leaving some side-effect ambiguity. The additional flavor about vendor volume tiers is helpful but not fully precise.

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 short: purpose first, then inputs, then an annual-plans/volume note, then the return value. The sentence 'vendors already have volume tiers and btw brings the volume' is cryptic and slightly distracting, but the overall structure is efficient and 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?

Given full schema coverageщается, an idempotency annotation, and an explicit return value, the core invocation details are present. The ambiguities around 'Annual plans;' and the unexplained 'btw' phrase leave the agent uncertain about billing-cycle constraints and volume mechanics, and the write side-effervis not clearly 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?

The input schema already provides complete descriptions for all three parameters, including the plan enum. The description largely restates what the schema covers (product name or link, plan choices, email) without adding new semantic details, so it meets the baseline for full 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 names a specific verb and resource: registering that the user wants a software subscription at group pricing. It enumerates the inputs and return value, but does not explicitly contrast with sibling tools like want_gym or want_home, so it stops short of full 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?

The intended scenario is implied through 'software subscription at group pricing' and the note about volume tiers, but there is no explicit guidance about when to use this tool over want/want_gym/want_stay or when it should not be used. The 'Annual plans' and 'vendors already have volume tiers' lines hint at context rather than directing tool 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?

Adds side-effect information: when enough people want the same hotel in the same month, btw asks for a group rate. Also states the return value (count of others). Annotations already indicate idempotency and non-read-only, but the group-rate trigger is unique to the description.

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 wasted words. Purpose is front-loaded, and the side-effect and return value are concisely stated.

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

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

Covers core behavior, return value, and side effects. Lacks details about the note parameter and potential error conditions, but for a moderate tool with annotations and schema descriptions, it is largely sufficient.

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 80% with descriptions for hotel, month, nights, and email. The description confirms hotel can be name or link, month format YYYY-MM, nights optional, and email is the human's. It adds 'nights if known' which clarifies optionality, but does not explain the note parameter, which lacks schema description.

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

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

Description states a specific verb (want) and resource (hotel), clearly distinguishing from siblings like want_gym and want_home. It explains the exact action: recording a hotel wish for a month and returning the count of other interested people.

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 clear context that this tool is for hotel stays, but does not explicitly name alternatives or when not to use it. With siblings like want, want_gym, want_home, an explicit exclusion would strengthen guidance.

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