Patlas — Patent Prior-Art Search

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about whether this is read-only, whether it is costly/rate-limited, how long a comparison takes, or what the output contains. 'Element-by-element comparison' hints at structured output but doesn't disclose its 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?

One efficient sentence with the comparison orientation front-loaded. It is not padded, but at this length it is also too thin to earn a 5; the front-loading is correct though.

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 two-param analytic tool with no annotations, no output schema, and 0% param coverage, the description leaves major gaps: output shape, patent_id format, and behavioral characteristics are all missing. The agent knows the intent but not the invocation details.

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 both required params are undescribed. The description implicitly maps invention_description and patent_id to the two inputs but adds no constraints (length limits in schema), format expectations, or examples—e.g., whether patent_id expects a patent number, internal ID, or publication number.

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 operation (element-by-element comparison) and both resources (invention description vs. patent's claims). It is clearly distinct from siblings like search_prior_art or get_patent_detail. Lacks the patent_id handoff detail but the core action 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 guidance on when to use this versus search_prior_art or get_patent_detail, no prerequisites, and no mention of what the comparison produces or when a result should influence a decision. Usage is implied by the name only.

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 and does disclose several real behavioral traits: ownership is assigned to the calling account, the call returns a checkout_url rather than an active resource, and the org remains inactive until payment completes. It omits permission/auth requirements, behavior on name collisions, and what happens if payment is abandoned.

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 tight sentences with the action and its return value front-loaded and the state caveat last. The parenthetical defining an org earns its place by clarifying domain vocabulary, and nothing is padded.

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, no output schema, and no annotations, the description covers most of what an agent needs: what is created, who owns it, what comes back (checkout_url), and that the resource is not yet active. Missing pieces are auth/permission requirements and error behavior, which are minor given the tool's simplicity.

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% (only machine-readable minLength/maxLength on 'name'), so the description technically owes the agent parameter meaning. However, the single parameter's semantics are self-evident from 'Creates a team/org', so the practical gap is small; the 2–100 character constraint and any naming rules go unmentioned.

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 gives a specific verb and resource ('Creates a team/org') and even defines what an org is (a shared Patlas account, one flat bill) plus who owns it. It stops short of differentiating from the adjacent sibling start_checkout, which also deals with the payment flow, so an agent can't fully rule that alternative out from the text alone.

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 is only implied: the text describes the resulting payment flow ('returns a checkout_url ... The org isn't active until payment completes'), which suggests when this tool is relevant, but there is no explicit when-to-use, when-not-to-use, or comparison to start_checkout or create_watch. Prerequisites (billing account, auth) are not stated.

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 behavioral burden and does so richly: paid ($299 one-time), returns a checkout_url requiring a repeat call with identical candidates after paying, otherwise returns the .docx directly, and delivery is confined to the authenticated session with no public link. Cost, idempotency, and delivery/security semantics are all 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?

Front-loads the core action and packs cost, return flow, and delivery constraints into essentially one dense sentence with em-dash asides. Every clause earns its place, though the run-on construction is slightly harder to scan than discrete sentences would be.

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 two-param tool with a nested candidates array, no output schema, and no annotations, the description covers everything an agent needs: prerequisite inputs, cost, the checkout re-call loop, and the return artifact. Nothing material 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, and it does: it defines `candidates` as every candidate mechanism found including its search_prior_art/compare_claims results. `project_name` is trivially self-evident. It could say more about the required sub-fields (mechanism/location/summary/matches), but coverage of the key parameter is solid.

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

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

States a specific verb and resource: packages patent_scan findings into a paid Word document. The description makes it unmistakable which sibling it follows (search_prior_art/compare_claims) and what artifact it produces, so an agent can distinguish it from the other creation tools without opening the schema.

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

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

Explains the sequencing context clearly: use it after a patent_scan session and pass the results found via search_prior_art/compare_claims. It also spells out the two-step payment re-invocation flow. It does not name when NOT to use it or any alternative, so it stops short of the 5-level.

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 behavioral burden and does so well: it discloses check cadence (once a day), the side effect (posting a JSON payload to the webhook), the quota (max 5 per account), the entitlement gate (payg/subscription/team), and data coverage (US only via PatentsView/ODP). These are exactly the traits an agent cannot infer from the 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?

Everything is packed into a single front-loaded sentence with no filler, and the core action plus constraints lead. The parenthetical stack makes it slightly dense, but nothing is wasted.

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 two-parameter creation tool with no output schema and no annotations, the description covers cadence, delivery, quota, coverage, and entitlement. What is missing is the shape of the delivered payload and the query's expected syntax, which an agent would need to invoke it precisely.

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 compensate for both parameters. It clarifies that webhook_url must be HTTPS and receives a JSON payload, and implies query is a technology-area query, but it never describes query syntax, matching semantics, or length expectations, leaving a meaningful 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 names a specific verb+resource ('Watches a technology area') and adds the delivery mechanism and scope, so the purpose is unmistakable. It never explicitly distinguishes itself from siblings like list_watches or delete_watch, though the create-style framing makes the distinction obvious in practice.

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 concrete eligibility and constraint guidance: payg/subscription/team plans only, up to 5 per account, US filings only. That is strong prerequisite context, but no alternative tool is named for users who want to list or remove watches, so it stops short of explicit when-to-use routing.

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

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

With no annotations, the description carries the full burden, and it does disclose the critical trait that deletion is permanent. It omits other behavioral context such as permission requirements, whether the call is idempotent, or what happens to existing check history; the schema's confirm field repeats the irreversibility note rather than extending 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?

A single tight sentence with the destructive nature and the required identifier front-loaded. Zero wasted words.

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 two-parameter destructive tool with no annotations and no output schema, the description covers permanence and id sourcing but leaves the confirm=true requirement entirely to the schema and says nothing about authorization or side effects. Adequate but with clear 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 coverage is only 50%, and watch_id has no schema description, so the description compensates by explaining the id's source (list_watches). The confirm parameter is well documented in the schema itself, so the description need not repeat it. It adds meaningful value over the bare 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 names a specific verb (permanently stops/delete) and resource (watch), plus the identifying key (watch_id). It points to list_watches for discovery, which lightly separates it from the sibling read tool, though it does not explicitly contrast with create_watch. Clear but not maximally differentiated.

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 parenthetical '(see list_watches)' tells the agent how to obtain the required watch_id, which is useful procedural guidance. However, there is no statement of when this tool is appropriate versus alternatives or any prerequisites beyond the id lookup.

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 load; it does disclose the return scope (including the member list, which can be sensitive/large) and the possible no-team case via '(if any)'. It does not state authentication/permission requirements or that the operation is strictly read-only, so there are real gaps.

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?

One sentence, front-loaded with the verb and resource, with the enumerated payload fields following. Nothing redundant or padded.

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 no-arg read tool with no output schema, the description usefully enumerates the returned fields (name, status, seat usage, role, member list) and covers the null/no-team case. Only auth and error behavior are left unspecified, which is a minor omission given the tool's simplicity.

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?

Zero parameters, so the baseline is 4. The description correctly adds nothing in the way of parameter syntax and instead spends its words on the return shape, which is the right call for a no-arg tool.

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 (Returns) and resource (the calling account's team) plus the exact payload fields, so an agent knows this reports the caller's own org rather than another org. It does not explicitly distinguish itself from siblings like get_patent_detail, but the resource 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?

No when-to-use or when-not-to-use guidance is given, and no alternative tool (e.g., landscape_summary for aggregate data) is named. The '(if any)' clause hints that a team may not exist, but there is no routing or precondition 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read operation by returning data, but does not clarify permissions, rate limits, or whether the data is cached or live. For a retrieval tool with no annotations, this is a significant gap.

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

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

The description is a single, efficient sentence that front-loads the purpose and lists the returned fields without any wasted words. It is appropriately sized for a simple tool.

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

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

With no annotations and no output schema, the description should provide more context about the returned data's structure and behavior. It lists the fields but does not explain their format or any limitations. For a read tool with a single parameter, it is minimally adequate but missing important details.

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 has 0% description coverage for the single parameter 'patent_id'. The description does not add any meaning beyond what is in the schema, such as the format or constraints of the patent ID. Baseline 3 is appropriate when schema coverage is low but parameter count is 1 and straightforward.

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 ('get') and resource ('patent detail'), and then enumerates the fields returned (claims, citations, family, assignee, status). This clearly distinguishes it from siblings like compare_claims or search_prior_art, though it doesn't explicitly mention those alternatives.

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 by listing the data types available, but it does not explicitly state when to use this tool versus alternatives like compare_claims or search_prior_art. No explicit exclusions or prerequisites are given.

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 and does meaningful work: it discloses the owner-only authorization requirement, that the link is one-time and expires in 24h, and the recipient flow (open in browser, sign in, accept). It omits what happens on expiry/revocation or whether multiple invites are possible, so it is strong but not exhaustive.

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?

A single front-loaded sentence: the permission constraint leads, followed by the generated artifact and the recipient flow. Every clause earns its place with no repetition 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-param tool with no output schema and no annotations, the description supplies the auth requirement, artifact behavior, expiry, and recipient mechanics an agent needs. Missing only edge-case behavior such as revocation or re-generation, which is a minor gap rather than a blocker.

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 takes zero parameters, which is the baseline-4 case. There is nothing further for the description to disambiguate, and it correctly does not invent parameter behavior.

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

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

States a specific verb and resource ('Generates a one-time invite link' to add someone to your team) that clearly identifies the operation as the inverse of sibling remove_org_member. An agent can distinguish it from every other sibling without opening a schema.

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

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

'Owner-only' states the prerequisite permission explicitly, and 'share with someone you want to add to your team' makes the intended scenario unambiguous. It stops short of naming an alternative or stating when not to use it, so it is clear context rather than full routing guidance.

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

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

No annotations provided, so the description carries the burden. It discloses key traits: deterministic computation in code (not model-estimated), 'representative sample' (implying not exhaustive), and US-only coverage via PatentsView/ODP. It does not specify rate limits, return shape, or sample size, but core behavioral aspects are covered.

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, front-loaded with the core purpose, followed by a clarification of computation method and coverage. No wasted words; 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 tool with one parameter and no output schema, the description should ideally explain the return values (even if narrative) or clarify the parameter format. It covers output types but not their structure or the single input's expected format. Adequate but with clear gaps 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 0%, so the description should compensate. It does not explain the single parameter 'technology_area' (e.g., expected format like 'semiconductor' or CPC code). With only one parameter, the schema provides type and length, but the description adds no semantic meaning. Baseline 3 for low coverage with no param info 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 ('Aggregate statistics') and resource (US patents matching a technology area), and lists the exact outputs (top assignees, filing-year trend, top CPC classes) plus a narrative. This clearly distinguishes it from sibling tools like get_patent_detail or search_prior_art.

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 is implied by 'matching a technology area', but there is no explicit when-to-use vs alternatives (e.g., vs search_prior_art) or when-not-to-use. The description gives a general context but lacks exclusions or guidance on selecting this tool over others.

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 usefully discloses that only 'active' watches are returned and that results are scoped to the calling account, but says nothing about permissions, pagination, or ordering for what is presumably a read operation.

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?

A single front-loaded sentence with zero filler; the resource and scope appear before the cross-reference.

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 list tool with no output schema and no annotations, the definition conveys enough to invoke it correctly and states the 'active' filtering. It leaves the shape of returned watch objects unspecified, which is a minor gap given no output schema exists.

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 takes zero parameters, so the baseline is 4 regardless of the schema coverage. There is nothing for the description to compensate for.

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 ('Lists') and resource ('calling account's active technology-area watches'), and scopes the result to the calling account's active watches. It cross-references create_watch but does not explicitly distinguish itself from delete_watch, so it falls just short of the sibling-differentiating 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 parenthesis '(see create_watch)' hints at the related create operation but gives no when-to-use/when-not guidance or explicit alternatives. Usage is only implied by the verb 'Lists'.

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 and does so: it discloses irreversibility, the permanent invalidation of the old key, and a non-obvious consequence—that signing in again via GitHub/Google/Microsoft/Clio will no longer recover the account. It also names the required user confirmation, which is exactly the behavioral context an agent needs.

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, front-loaded with the action and the immediate permanent-invalidation effect, followed by the critical recovery caveat and the precise usage condition. No sentence is redundant.

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, no-output, no-annotation mutation tool, the description covers the action, the destructive scope, the required confirmation, and the non-obvious recovery side effect. It does not mention any rate limits or what the returned new key looks like, but a return value is implied ('save the new key themselves'), so the remaining gaps are minor.

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

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

Schema coverage is 100% and the single 'confirm' parameter is already fully documented in the schema, including the const true constraint and the warning text. The description reinforces the confirmation requirement but adds no syntactic or semantic detail beyond what the schema provides. 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 states a specific verb ('Issues') and resource ('brand-new API key') and its destructiveness ('permanently invalidates the current one'). It is clearly distinct from all siblings, which concern entirely different resources (claims, scans, watches, orgs).

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 condition for use ('only use this when the caller has explicitly confirmed...') and excludes vague or ambiguous requests via the schema. A concrete trigger ('they suspect the current key leaked') is provided, leaving nothing 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?

With no annotations, the description carries the burden well: it discloses the auth requirement (owner-only), the immediacy of the effect ('revoked immediately'), and the blast radius (team tools/limits revoked, personal account unaffected). It stops short of stating reversibility or what the call returns, but the safety-critical behavior is covered.

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, zero filler, with the hard constraint ('Owner-only') front-loaded ahead of the mechanics and the impact statement. Every clause carries information.

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

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

For a destructive, 2-param tool with no annotations and no output schema, the description covers permissions, effect timing, scope of impact, and ID sourcing. Only the irreversibility/confirmation contract and error behavior are left implicit.

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 50%: confirm is fully documented in the schema, but member_user_id has no schema description. The description partially compensates by naming the source of that id (get_org_status), which is the genuinely useful addition, but adds no format or validation detail. Baseline 3 is appropriate for this coverage level.

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

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

States a specific verb+resource (removes a member) plus the identifier used to do it, and clearly distinguishes itself from invite_org_member and get_org_status. An agent can select this over its siblings without opening any schema.

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

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

Declares the prerequisite explicitly ('Owner-only') and routes the agent to get_org_status to obtain the required user id. It lacks an explicit when-not clause, but the context is unambiguous for a single-purpose removal tool.

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

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

No annotations are provided, so the description carries the full behavioral burden and largely fails: it does not state that this is a read-only lookup, what data source or coverage it searches, latency/cost characteristics, or how the ranking is derived. It only names the shape of the result.

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?

A single tight sentence with the key output information front-loaded and no filler. It loses a point only because the fragmentary structure omits an action verb, making it read as a return-value caption rather than a tool description.

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 annotations, no output schema, and no parameter descriptions, the description is expected to do more. It never explains usage conditions, input constraints, or behavioral properties, so an agent has enough to recognize the tool's domain but not enough to invoke it confidently.

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 compensate. It implicitly covers only 'invention_description' by naming it, and says nothing about the jurisdiction parameter (US/EP/WO enum) or the 20-4000 character input bound, leaving roughly half the parameters undocumented.

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 names the resource (patents) and the two outputs (ranked closeness list plus claim-overlap summary) so an agent knows what the call produces. However it is a noun phrase with no verb and does not differentiate itself from siblings like compare_claims or landscape_summary, which also operate on patent text.

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 when-to-use guidance at all, no indication of when to prefer compare_claims or landscape_summary, and no stated prerequisites or limits. The agent must infer context purely from the name.

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 must carry behavioral weight — and it does: it discloses that it returns a checkout_url, that the caller must open it in a browser, and critically that nothing changes until payment completes. It stops short of covering idempotency, auth/permission requirements, or behavior when already subscribed.

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, front-loaded with the action and immediately followed by the important side-effect caveat. Every clause earns its place; 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?

For a single-parameter, annotation-free, output-schema-free tool the description covers the essentials: what it does, the account it targets, the return value, and the deferred-effect behavior. Missing only edge cases (already-subscribed behavior, idempotency, pricing), which are secondary.

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 enum values 'payg'/'subscription' are undocumented in the schema; the description partially compensates by naming 'Pay-as-you-go or Subscription', mapping the values to human meaning. It does not explain how to choose between them or any prerequisites, so it only partially fills the coverage 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?

States a specific verb and resource ('Starts a Stripe Checkout session to upgrade this account') and identifies the target account as the already-authenticated one. No sibling tool touches billing/checkout, so the purpose is unambiguous within the toolset.

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?

Clearly frames the tool as the upgrade path to 'Pay-as-you-go or Subscription', giving the agent enough context to know when to reach for it. There are no named alternatives or explicit when-not conditions, but no sibling competes for this job, so the gap is minor.

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 the full behavioral burden. It discloses the referential semantics of request_id (it points at a prior response) and that comment is optional, but not whether this writes to a store, requires auth, is idempotent, or what happens on an unknown/invalid request_id. For a mutation with zero annotation coverage that is a notable gap.

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?

A single sentence with no filler, front-loaded with the action and immediately qualifying which response is being rated and what the optional payload is. Nothing could be trimmed without losing meaning.

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 no output schema, the description covers the purpose, the keying parameter, and the optional field. It leaves error/duplicate handling unstated, but the agent has enough to call it correctly in normal use.

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 compensate. It partially does: it explains request_id as the identifier of the prior tool response and flags comment as optional, and 'was helpful' conveys the boolean meaning of helpful. It does not mention the 2000-character comment limit or the UUID format expected for request_id.

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: it records the helpfulness of a prior tool response plus an optional comment. An agent immediately understands the operation without opening the schema. It does not explicitly differentiate itself from any sibling, but no sibling covers feedback, so there is no real ambiguity.

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 is implied by 'a prior tool response', which tells the agent this is called after receiving a response. However, there is no explicit when-to-use framing, no statement of when not to call it, and no alternative tool named.

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