GleanMark Trademark Search

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

Beyond the annotations (readOnlyHint, non-destructive), the description discloses significant behavioral traits: asynchronous execution, typical duration ('usually done in under a minute'), the return of a processing handle, and the instruction to tell the user it is running. This adds value well beyond the annotation metadata.

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 long and front-loaded with purpose. Each sentence delivers essential information: the scope of analysis, the async flow and timing, and the user-facing instruction. No 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?

Despite having no output schema, the description thoroughly covers the workflow: what it does, how it launches asynchronously, what it returns (a processing handle), and the required follow-up via get_prosecution_history_status. It also includes the user-facing instruction to keep the user informed.

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 fully describes the only parameter (serial_number) as 'USPTO serial number' with 100% coverage. The description adds no further parameter-level details, so 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 uses a specific verb ('Analyze') and resource ('full prosecution history of a trademark'), listing concrete elements like narrative timeline of office actions, responses, examiner decisions, and examiner-behavior patterns. This clearly distinguishes it from sibling tools such as get_prosecution_timeline or get_mark_prosecution_summary.

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 clear context: it requires authentication, launches asynchronously, and directs the user to call get_prosecution_history_status to fetch the result. However, it does not explicitly compare with alternative tools or state 'when not to use', so it lacks explicit 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 discloses important behavioral traits beyond the annotations: async execution (1-2 minutes), returning a processing handle, requiring a follow-up status call, and instructing the agent to tell the user it is running. This significantly extends the readOnly/openWorld hints from 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 two sentences long, front-loaded with the core purpose, and every clause earns its place—including the essential async behavior and user-facing instruction. It is concise without omitting critical operational details.

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

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

For a complex analysis tool with no output schema, the description explains what it returns (structured summary), how to handle the async flow, and the next step (status call). It is sufficiently complete for an agent to invoke correctly and manage expectations.

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% for both parameters (proceeding_number and quick_mode). The description does not add meaningful parameter-level information beyond what the schema already provides, so the baseline 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 clearly states a specific verb ('Analyze'), resource ('TTAB proceeding'), and depth ('in depth'), with detailed outputs (timeline, party positions, strategic assessment). It distinguishes itself from siblings like get_ttab_proceeding_details and get_ttab_document by emphasizing analysis rather than retrieval.

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 clear context on what the tool does and the async workflow (returns a processing handle, then call get_ttab_proceeding_analysis_status). It does not explicitly mention alternatives or when-not-to-use, but the guidance is sufficient for an agent to understand the intended use 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 read-only, open-world, and non-destructive behavior. The description adds meaningful context by explaining that it combines two signals (domain and trademark) and that it returns a recommendation tier, which gives the agent a clear behavioral model without needing to invoke the tool.

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

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

The description is three tight sentences: what it does, what it returns, and when to use it. No redundant words, no repetition of schema details, and the most important info (purpose and output) is up front.

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

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

The tool is lightweight (one required parameter, simple output) and the description covers the core value: combining domain and trademark signals into a recommendation tier. It doesn't need to explain return format in detail, as the output is described in plain language, and the schema covers optional inputs. A slightly fuller note on what happens if optional params are omitted would make it a 5, but it's still complete enough.

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 has 100% description coverage for all parameters, so the schema already explains what each parameter does. The description does not add any extra parameter-specific guidance, but it also doesn't need to—the baseline of 3 is appropriate when the schema carries the 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's function: 'combines domain availability with a trademark conflict signal' and lists the exact output (recommendation tier). This distinguishes it from siblings like check_domain_availability, which likely only covers domain checks, and run_knockout_search, which is a deeper search.

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 phrase 'Good first step before a full clearance search' provides clear situational guidance, implying the tool is for initial screening rather than exhaustive analysis. It does not explicitly name an alternative sibling, but the context is sufficient to indicate when to use it versus more comprehensive tools.

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

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

Annotations already convey read-only and non-destructive behavior. The description adds value by specifying the return statuses and .com variations, but doesn't disclose additional behavioral details like rate limits or data freshness.

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

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

Two clear, front-loaded sentences with no redundancy. Every word contributes 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?

With no output schema, the description explains return statuses and .com variations, which is substantial. It could optionally mention that results are per-TLD, but the coverage is solid for a simple read-only 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 100%, so parameters are well-documented. The description adds context about .com variations corresponding to the brand_name parameter, but doesn't go beyond what the schema already explains for tlds.

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 it checks domain availability for a brand name and lists return statuses. It is distinct from most trademark tools due to domain focus, but does not explicitly differentiate from the sibling check_brand_availability.

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: it's for domain availability checks. However, no explicit guidance is given on when to use this tool versus alternatives like check_brand_availability or web_research, and no exclusion criteria are mentioned.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool is known to be safe. The description adds methodology (DuPont-style analysis) and output type (similarity scores, risk assessment), which provides some behavioral context beyond the annotations. However, it does not disclose potential limitations, data sources, or scope nuances, so transparency is adequate but not rich.

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 purpose, and contains zero wasted words. Every sentence earns its place: the first states the function, the second summarizes the output.

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

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

Given the tool has an output schema, annotations, and a clear two-sentence description, it is reasonably complete for a pairwise comparison tool. The description covers what it does and what it returns. It could benefit from clarifying the relationship to run_dupont_analysis or the jurisdictional scope, but these are not critical gaps given the existing structured metadata.

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 does not add meaningful semantic details beyond the schema; it simply reiterates that two marks are compared. The nice_classes parameter is already described as 'Nice classes for overlap analysis,' and the description adds no clarification about mark formats or analysis scope.

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: compare two trademarks for likelihood of confusion using DuPont-style analysis. It names the specific resource (two trademarks) and the analytical approach, which distinguishes it from siblings like get_similar_marks or phonetic_search. However, it does not explicitly differentiate from the closely related sibling run_dupont_analysis, which may perform a similar role, so not a full 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 implies usage when a user needs to compare two specific trademarks for confusion risk, but it does not explicitly state when to use this tool over alternatives such as run_dupont_analysis or get_similar_marks. No exclusions or alternative recommendations are provided, leaving the choice ambiguous among similar tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds context beyond this: it mentions 'preview' behavior and 'metadata coverage,' and clarifies that it can intersect color criteria. This gives the agent a clearer sense of the tool's functional scope without contradicting 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 two sentences with no filler. The first sentence front-loads the purpose and key differentiators; the second delivers usage scope and exclusions. Every phrase earns its place, making it compact and efficient.

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 9-parameter tool with no output schema, the description gives a good high-level orientation but omits important invocation details: whether limit affects counts or only previews, how class_match_mode behaves, and the exact return structure. It is sufficient for tool selection but not fully complete for a complex 9-param 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 44% (low), and the description compensates partially by mapping core concepts: 'mark-type' to mark_types, 'standard-character' to standard_characters, 'Nice-class' to nice_classes, 'status' to status_filter, and 'claimed-color criteria' to the color params. However, it does not explain limit, class_match_mode, or interaction nuances, leaving some parameters underspecified.

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

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

The description clearly states a specific verb+resource: 'Count and preview USPTO marks by record attributes.' It distinguishes from sibling tools by emphasizing 'rather than owner identity' and explicitly excluding 'color-only counts, rankings, lists, and vocabulary,' which differentiates it from tools like search_by_owner or color-focused searches.

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

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

The description provides explicit when-to-use guidance: 'Use this for drawing type, standard-character, Nice-class, status, and cross-attribute counts.' It also gives exclusions ('color-only counts... are outside its scope'), helping the agent decide against this tool for those needs. However, it does not name specific alternative sibling tools, so it falls short of perfect alternative 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds useful behavioral context by explicitly mentioning two distinct result types (coordinated vs related), which maps to the relationship_type parameter and is not apparent from annotations alone.

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, front-loaded sentence with no superfluous words. Every word contributes to the core 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 read-only lookup tool with well-described schema parameters, the one-sentence description is adequate. However, it could benefit from a brief note clarifying the difference between 'coordinated' and 'related' to prevent ambiguity, though the parameter description for relationship_type partially compensates.

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 descriptions for all four parameters, so the baseline of 3 applies. The description adds no parameter-specific detail beyond what the schema already provides.

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 ('look up') with a clear resource ('coordinated Nice classes or related Nice classes') and scope ('for a given class number'). It distinguishes itself from sibling tools like get_nice_classes (which likely lists all classes) and recommend_nice_classes (which recommends classes).

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_nice_classes or recommend_nice_classes. It only states the function, not the context or 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?

Annotations already mark this as a safe read-only operation, and the description adds substantial behavior: it returns averages/medians/percentiles, counts marks lacking the start event, and discloses sampling behavior ('Samples up to max_sample marks from the start of the window and says so when truncated'). It also explains the max 366-day date window.

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

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

The description is front-loaded with the main action, uses a concrete example, and every sentence adds detail about parameters, return value, or usage. It is compact yet thorough, with 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 complex analytics tool with no output schema, the description adequately specifies return values (avg/median/percentiles, missing-start counts, example marks), explains the sampling behavior, and gives a full workflow. It also cross-references a sibling tool for code lookup, making the tool self-contained.

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 covers all 9 parameters with descriptions (100% coverage). The description adds semantic context by explaining how the cohort anchor, interval start/end, and raw event codes work together, and it defines the prefix wildcard ('trailing *') behavior, which is only partially present in the schema.

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

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

The description opens with a specific verb 'Aggregate' and identifies the resource 'event-to-event pendency across a COHORT of marks', followed by a concrete example. It distinguishes itself from sibling individual-mark tools by emphasizing the cohort scope and by referencing get_event_code_reference for event codes.

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 a clear use scenario with an example and instructs users to 'Pick the cohort by an anchor event... within a date window... and an interval start/end event.' It also explicitly directs to 'Use get_event_code_reference first' for non-preset codes, offering an alternative workflow. However, it does not explicitly state when not to use the tool (e.g., for single-mark queries).

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds behavioral context by stating the sort order ('sorted by prosecution history length') and the inclusion of event counts and office action flags, going beyond 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?

Three sentences, front-loaded with the core purpose, followed by return characteristics and usage guidance. Every sentence earns its place with no redundancy or filler.

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

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

The description effectively conveys the tool's scope and output characteristics, including sort order and included data types. It does not detail return fields or parameter selection logic, but the schema covers parameter semantics, and the annotations handle safety, making this sufficient for the tool's complexity.

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%, with all seven parameters having descriptions. The description does not add significant meaning beyond the schema, but it does reinforce that search_term/correspondent_name relate to attorney identity, matching the tool's purpose.

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 retrieves all trademarks handled by a specific attorney/correspondent, including prosecution event counts and office action flags. The phrase 'attorney-specific mark queries' distinguishes it from general trademark search tools like search_trademarks.

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 'Use this for attorney-specific mark queries,' providing a clear when-to-use context. It does not mention alternatives or when not to use the tool, but the use case is specific enough.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe read-only nature is covered. The description adds useful behavioral context about the output (top clients, Nice classes, prosecution/TTAB profile) but does not disclose potential resolution behaviors or edge cases. It contributes some value beyond annotations without contradicting them.

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

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

The description is a single sentence that front-loads the main action and then adds usage guidance. No wasted words; every clause earns its place. It is highly concise while remaining informative.

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?

This is a read-only summarization tool with a rich output schema and full parameter documentation. The description explains the tool's purpose, when to use it, and key output elements, which is sufficient for an agent to select and invoke it. It does not describe return format, but the output schema compensates for that.

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 all five parameters described. The description does not add extra meaning beyond the schema, so the baseline score of 3 applies. It does not explain how parameters interact (e.g., url_key vs search_term priority), but the schema descriptions already cover each parameter individually.

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 summarizes what a named correspondent specializes in, with specific output components (top clients, Nice classes, prosecution vs. TTAB profile). This distinct 'specialization' focus differentiates it from sibling tools like get_correspondent_marks or get_firm_top_correspondents.

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

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

The description explicitly says to use this tool when the user asks what a specific correspondent or attorney specializes in. It provides clear contextual guidance, though it does not mention alternatives or exclusion cases, so it earns a 4 rather than a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the behavioral nuance that the tool performs a satisfaction check, implying a boolean result, and enumerates example deadline families. This goes beyond the annotations without contradicting them.

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

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

The description is a single, efficient sentence that immediately conveys the tool's purpose and includes helpful examples. No filler or redundant 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?

The tool is simple with two well-described parameters and strong annotations. The description adequately explains the core function. However, without an output schema, it leaves slight ambiguity about whether the result is simply boolean or a richer mapping, which could be clarified.

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%, with event_code and deadline_type both described in the schema. The description repeats a few deadline types ('office action response', 'opposition period') but does not add new meaning beyond the existing enum values. Thus the baseline of 3 applies.

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

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

The description clearly states the verb 'Check whether' and the specific resource 'a specific USPTO event code satisfies a specific deadline type', with concrete examples (office action response, opposition period, Section 8, Section 15). This distinguishes it from sibling reference tools like get_event_code_reference and get_event_status_mapping.

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 clear context for when to use the tool: to determine if a USPTO event code satisfies a deadline type. It does not explicitly list exclusions or alternatives, but the purpose is specific enough that an agent can infer when this tool is appropriate versus other deadline-related tools like get_firm_deadlines.

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 indicate read-only and non-destructive behavior. The description adds value by stating return fields (code, description, category) and search modes, providing useful context that is not in the annotations. No contradictions with annotations were found.

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

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

Two concise sentences with no fluff. The main action is front-loaded, and every phrase adds useful information about search modes or return values. Excellent structure.

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 lookup tool with three optional parameters and no output schema, the description covers purpose, search modes, and return fields. It could mention the default behavior when no parameters are provided, but overall it is complete enough for effective 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?

The schema provides 100% coverage with descriptions for all three parameters. The description's mention of 'exact code, code prefix, or keyword' mirrors the schema's parameter descriptions without adding new meaning beyond what is already structured. Baseline 3 applies.

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

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

The description opens with a specific verb and resource: 'Look up USPTO event codes used in trademark prosecution.' This clearly distinguishes the tool from generic siblings like get_reference_lookup by focusing on event codes and the trademark prosecution domain.

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 explains how to search (by exact code, prefix, or keyword) but does not provide explicit when-to-use guidance or mention alternatives. The phrase 'used in trademark prosecution' implies its context, but no exclusions or comparisons 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?

Annotations already declare read-only and non-destructive behavior. The description adds that results are based on 'most commonly follow', implying a statistical or historical source, but it does not explain what happens if no mapping exists, whether results are sorted, or if the output is a list (though the 'limit' parameter suggests multiple). It adds some context beyond annotations but lacks depth.

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, clear sentence that front-loads the key action and object. Every word is necessary and there is no repetition of schema 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?

The tool is a simple lookup with a clear purpose, and the schema documents both parameters. However, with no output schema, the description does not clarify the return structure (e.g., whether it returns a single mapping or a list, or the fields included). This is a moderate gap that could confuse the agent.

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

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

The schema description covers both parameters fully (event_code and limit), so the baseline is 3. The description adds no additional parameter-specific details beyond what the schema already provides, such as formats or examples.

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 specifies a concrete action ('Look up') with a specific resource ('USPTO status code and status definition') and a condition ('most commonly follow a specific prosecution event code'). It distinguishes itself from siblings like 'get_event_code_reference' by focusing on status mapping rather than definition 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?

The description implies usage context but does not explicitly state when to use it versus alternatives or when not to use it. It lacks any mention of use cases, alternatives, or exclusions, so the agent must infer from the tool name and description.

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 signal read-only and non-destructive behavior. The description adds valuable behavioral context by framing the output as 'circumstantial signal, not statutory fame proof' and detailing the kind of data returned (fame tier, path, etc.), helping the agent understand the nature and limits of the response beyond the safety 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 somewhat long but well-organized, front-loading the core function, followed by a structured list of returned attributes and then usage guidance. The length is justified by the complexity of a fame profile, but a few redundancies (e.g., 'brand' and 'mark wording') could be tightened.

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

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

Given the tool's complexity and the absence of an output schema, the description thoroughly covers what data will be returned (fame tier, path, footprint, portfolio size, crowding, TTAB history), how to invoke it (by mark or stem), and a critical limitation (circumstantial, not statutory proof). This makes it highly complete for an agent to understand the tool's scope.

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 sole parameter mark_or_stem has a detailed schema description (100% coverage) explaining that a mark or bare brand stem resolves to the same family. The tool description only briefly repeats this ('by mark wording or brand stem') without adding substantial new meaning, so the schema carries the semantic burden.

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

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

The description clearly states the verb ('Get') and specific resource ('full fame profile for a brand'), enumerating the profile's components (fame tier, path, class footprint, portfolio size, brand-stem crowding, TTAB history). This distinguishes it from sibling tools like is_mark_famous, which presumably only returns a yes/no fame determination.

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

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

Explicit use cases are provided: 'explain WHY a mark is (or is not) famous' and 'profile a senior mark before a §2(d) / opposition / dilution strategy.' The caveat 'Circumstantial signal, not statutory fame proof' serves as a when-not-to-rely-on guidance. However, it does not explicitly name alternative tools, such as is_mark_famous, for simpler fame checks.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral detail: it resolves/normalizes a firm name, aggregates deadlines and recent OAs from dual sources (case-file events and prosecution documents), and includes ROA-filed and §2(d) indicators. This goes beyond the basic safety profile, though it does not discuss pagination, rate limits, or exact return formatting.

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: the first packs the core function and scope, the second provides concrete example queries. Every sentence earns its place with no redundancy or filler.

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

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

For a 4-parameter, no-output-schema tool, the description covers purpose, data sources, and inclusion criteria well. It does not list alternatives or return structure, but the example questions and explicit content summary suffice for the tool's complexity. Slight gap: no mention of how results are ordered or whether both deadlines and OAs are always present.

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

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

Schema description coverage is 100%, and each parameter has a clear description with defaults and bounds. The tool description adds little to parameter semantics—only the example 'over the next 30 days' hints at deadline_days usage. Baseline 3 is appropriate since the schema carries the full burden.

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 ('Resolve a trademark law firm and return') and clearly identifies the resource ('firm correspondent tasks'). It enumerates exactly what is returned (overdue/next-window deadlines, recent Office Actions from case-file events and prosecution documents, ROA-filed and §2(d) indicators), distinguishing it from simpler firm-deadline or OA-only tools. Example questions reinforce the purpose.

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 clear usage context with example questions ('what correspondent tasks should this firm focus on over the next 30 days?'). It implies when to use the tool but does not explicitly mention exclusions or alternative sibling tools, so it stops short of full when/when-not guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds meaningful detail beyond them: the data source ('public firm resolution and prosecution mappings only') and explicit exclusions (workspace, client, reminder, user-created data). This enriches the agent's understanding of the tool's limitations without contradicting 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?

Two sentences, front-loaded with the primary verb and resource, followed by a clarifying limitation. Every word earns its place; no fluff or repetition.

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

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

With an output schema present and a read-only tool of moderate complexity (7 params, all documented), the description sufficiently covers the tool's scope, data source, and exclusions. It gives the agent enough to correctly decide invocation without needing to parse the schema.

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 provides 100% description coverage for all 7 parameters, including defaults and enum values. The description itself does not add parameter-specific information, but per the rubric, a baseline of 3 applies when the schema carries the load. No compensation needed.

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 the specific verb 'Get' and precisely identifies the resource: 'public, system-generated trademark deadlines across marks handled by a specific law firm.' This clearly distinguishes it from sibling tools like get_mark_deadlines and get_owner_deadlines by the firm-level scope.

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 clear context ('public, system-generated' and 'Does not expose any workspace, client, reminder, or user-created deadline data') that tells the agent when to use this tool and what it will not return. However, it does not explicitly name alternative tools for those excluded cases, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is established. The description adds meaningful behavioral detail: it resolves/normalizes the firm name, computes rates at mark level, and distinguishes raw counts versus excluding pending matters. This gives context beyond the annotations, though edge cases like unknown firms or empty result sets are not disclosed.

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

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

The description is two sentences, front-loaded with the primary action, and includes illustrative user questions. Every sentence earns its place with no redundancy, making it both concise and well-structured.

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

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

With two parameters, no output schema, and annotations that confirm read-only behavior, the description supplies the essential context: what the tool computes, the distinction between raw and excluding pending matters, and example questions. It does not fully specify the exact response format, but enough is conveyed for an agent to use the tool correctly in most situations.

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 has 100% description coverage for both parameters: firm_name and limit, each with clear descriptions. The tool description does not add additional parameter semantics beyond what the schema already provides, so the baseline 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 (resolve a law firm and compute mark-level Office Action outcome rates) and resource (firm's OA outcomes). It includes example questions that clarify intended use, and it distinguishes itself from sibling tools like get_latest_office_action (single mark) and research_office_action (likely OA strategy) by focusing on firm-level aggregated metrics.

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 'Use this for questions like...' giving concrete query examples, which provides clear context for when to invoke the tool. However, it does not mention when NOT to use it or name alternative sibling tools for different scenarios, so it falls short of explicit exclusion guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds valuable context about ranking criteria (filing volume, prosecution, TTAB activity counts) and the one-firm scope, going beyond simple read-only labeling.

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: the first states the function and criteria, the second gives usage context with an example query. Every word earns its place; no redundancy or filler.

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

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

For a two-parameter tool with full schema annotations, an output schema, and explicit usage guidance, the description is complete. It covers the core purpose, ranking metrics, one-firm scope, and a practical trigger example.

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%, with both firm_name and limit having clear descriptions in the input schema. The description adds no parameter-specific details beyond what the schema already provides, so the baseline 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 clearly states the tool retrieves leading correspondents/attorneys at a named law firm, ranked by filing volume with prosecution and TTAB activity counts. It distinguishes this from sibling tools like get_correspondent_marks by focusing on firm-level ranking and specific metrics.

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 instructs using this tool when the user asks for top correspondents at a specific firm, with a concrete example query. However, it doesn't mention alternatives or when not to use it, so it falls short of full exclusion guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds valuable behavioral context: it returns the latest response 'if one exists,' and it parses and VERIFIED refusal grounds with cited registration numbers from the OA text. It also establishes an authoritative-data rule (refusal_grounds over document title), which is a behavioral trait not inferable from annotations or 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?

Two sentences: the first front-loads the core functionality plus additions, the second delivers a critical usage rule. No filler or redundancy.

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

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

For a read-only tool with one well-described parameter and no output schema, the description sufficiently explains inputs and expected outputs (OA, optional response, refusal grounds). It also includes a directive that prevents common errors. The absence of explicit return-format details is acceptable given there is no output schema.

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 a description for serial_number ('USPTO serial number'), so the baseline is 3. The description does not add format examples or constraints beyond the schema, but no additional semantics are needed given the single, well-described 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 uses a specific verb and resource: 'Get the latest office action for a trademark serial number,' and further specifies it also returns the latest recorded response and verified refusal grounds with cited registration numbers. This clearly distinguishes it from sibling tools like get_prosecution_document or list_prosecution_documents by focusing on the latest OA and parsed refusal grounds.

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

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

The description clearly implies when to use this tool: whenever you need the latest office action and its refusal basis. It provides an explicit usage instruction: 'Use refusal_grounds as the authoritative answer... never infer the basis from the document title or general knowledge.' However, it does not explicitly name alternative tools or state when not to use it, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds that the summary is AI-generated and includes specific content areas, but does not disclose potential latency, cost, or that AI-generated output may be interpretive. This is acceptable given annotations but lacks deeper behavioral context.

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

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

Two sentences with no fluff. The first sentence front-loads the core purpose, and the second enumerates coverage without redundant wording. 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?

No output schema exists, but the description enumerates what the summary covers (mark details, goods/services, status, owner, prosecution context, active legal proceedings). While it doesn't describe the exact return format or error behavior, for a single-parameter summary tool, this is largely sufficient. Slight gap: no mention of what happens if the serial number is invalid or not found.

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%: the only parameter serial_number is described as 'USPTO serial number'. The description adds no additional parameter syntax or format details, staying at baseline where the schema fully handles parameter semantics.

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 ('AI-generated deep-dive summary of a specific trademark'), and lists the content areas covered. This distinguishes it from siblings like get_mark_prosecution_summary (narrower scope) and lookup_trademark (basic details) by emphasizing the AI-generated, comprehensive nature.

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

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

The description implies when to use the tool: when a comprehensive AI-generated overview of a mark is needed, including prosecution context and legal proceedings. It does not explicitly exclude alternatives or name sibling tools, but the clear scope provides enough contextual guidance for 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?

The description adds behavioral context beyond the annotations: it discloses that deadlines are system-generated, that mark names are resolved to serial numbers first, and that no user-created data is exposed. These are meaningful details not covered by readOnlyHint and destructiveHint.

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, with the primary purpose and scope front-loaded. Every clause adds useful information—scope, resolution behavior, and exclusions—with no filler or repetition.

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

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

Given the output schema and annotations, the description is complete for tool selection and invocation. It covers the target resource, scope, resolution behavior, and exclusions, which is sufficient to distinguish from siblings and use 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 coverage is 100%, so the baseline is 3. The description adds value by explaining the relationship between serial_number and subject_name (resolving a mark name to a serial first), which is not in the schema. This helps the agent decide which parameter to use.

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 it gets public, system-generated trademark deadlines for a specific mark, with a specific verb and resource. It distinguishes from siblings like get_firm_deadlines and get_owner_deadlines by emphasizing mark-specific scope and excluding workspace/client/user-created data.

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 clear context for when to use this tool (for public, system-generated mark deadlines) and an explicit exclusion (not for workspace/client/user data). However, it does not name specific alternative tools, so it stops short of full when-not-to-use guidance.

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

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

Annotations already indicate read-only, non-destructive behavior. The description adds essential context beyond annotations by disclosing the data source limitation: 'Data comes from USPTO records, so it is only available for marks with a USPTO record — it does not query WIPO/EUIPO live.' This is a critical behavioral trait.

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 well-structured and front-loaded with the core purpose, followed by usage guidance and a caveat. Every sentence adds value with no 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?

There is no output schema, so the description carries the burden of explaining return values. It does so in detail, listing IR number, date, status, renewal, 66(a) extension, Madrid maintenance, and foreign applications/registrations with fields. Combined with the data source caveat, it is complete for a complex 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 100% since serial_number is described as 'USPTO serial number'. The description restates 'by serial number' but adds no new parameter semantics or format details. 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 tool's function: 'Get the international / foreign footprint of a U.S. trademark by serial number' and enumerates specific data elements (IR number, date, status, renewal, 66(a) extension, etc.). This distinguishes it from sibling tools, none of which focus on international/Madrid filings.

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 'Use this for ANY question about a mark's foreign, international, Madrid Protocol, WIPO, or EUIPO registrations,' and also provides a when-not-to-use caveat: 'it does not query WIPO/EUIPO live.' This gives clear usage direction and 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds behavioral context by explaining the output is 'ranked by footprint' and includes 'wider portfolio context,' which goes beyond the annotations. It does not contradict them.

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

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

The description is two sentences, front-loaded with the core action, and delivers clear value without wasted words. It is appropriately concise for the tool's complexity.

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 an output schema present and annotations covering safety, the description effectively conveys the tool's purpose and expected output. It does not detail every parameter, but the schema fills that gap. The description is sufficient for selecting and invoking the tool correctly, though slightly more context on filtering (e.g., defaults) would enhance completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions 'shared trademark term' referencing mark_text and gives examples like COMET, but does not add syntax or format details beyond what the schema already provides. It effectively reinforces the schema without introducing new semantic value.

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: 'Show which owners hold marks matching a shared trademark term' and summarizes broader portfolios. This specific verb+resource pairing distinguishes it from siblings like search_trademarks or get_similar_marks, which focus on marks themselves rather than owner landscape.

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

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

Provides explicit use cases with examples ('Use this for crowded owner-landscape questions like...'), giving clear context for when to employ this tool. However, it does not explicitly mention when not to use it or name alternative tools, so it falls short of a perfect score.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds context about what data is returned (status, counts, dates, milestones), but does not disclose additional behavioral traits like error handling, data freshness, or limitations. This is adequate but not exceptional given the existing 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 two sentences: the first states the purpose, the second lists return contents. It is front-loaded, succinct, and every phrase adds value. No redundant or verbose language.

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

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

Given the tool's simplicity (one parameter, no output schema), the description adequately explains what the tool does and what it returns. It lists the key return categories, which is sufficient for an agent to decide whether to use it. However, it does not mention edge cases like empty results or error behavior, which would make it more complete.

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

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

Schema description coverage is 100%, with serial_number described as 'USPTO serial number.' The tool description does not add extra meaning beyond the schema, such as format requirements or examples. Since the schema already documents the parameter, the baseline 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 clearly states the tool's function: 'Get a compact prosecution summary for a trademark serial number.' It specifies the resource (trademark serial number) and the output contents (current status, document counts, dates, milestones, key event). This distinguishes it from sibling tools like get_prosecution_timeline or get_latest_office_action, which focus on specific aspects.

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

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

The description implies usage for a quick overview ('compact summary') but does not explicitly state when to use this tool over alternatives. No exclusions or alternative recommendations are provided, so the usage context is only implied rather than clearly 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?

Annotations already declare this as a safe read-only operation (readOnlyHint=true, destructiveHint=false). The description adds context about trademark registration and the two lookup modes, but does not disclose additional behavioral traits beyond what annotations provide. This aligns with the calibration where a read-only lookup with annotation coverage earns a 3.

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

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

The description is two sentences, front-loaded with the core purpose, and every phrase adds value. It efficiently conveys the tool's function and its two input modes without redundancy or fluff.

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 simple tool nature, strong annotations, full schema coverage, and presence of an output schema, the description is complete. It covers the essential lookup capabilities and is sufficient for an agent to understand when and how to invoke the tool, especially with sibling tools providing related but distinct functions.

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 search_term and class_numbers already described in the input schema. The description mentions the two modes but adds no extra detail about parameter syntax, constraints, or interactions. This meets the baseline for schema-covered parameters without needing further compensation from the 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?

The description clearly states the tool's purpose: getting information about Nice Classification classes for trademark registration. It distinguishes from siblings like recommend_nice_classes by focusing on lookup and search rather than recommendation, and from get_class_relationships by targeting class details rather than relationships.

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 explains the two primary usage modes: looking up specific class numbers or searching by keyword. This implies when to use the tool, but it does not explicitly mention alternatives or exclusions, such as using recommend_nice_classes for class suggestions. The context is clear enough for an agent to select this tool for direct class information needs.

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 caching behavior ('Results are cached for 30 days') and the AI-generated nature of the output, supplementing the readOnlyHint and destructiveHint annotations. It also outlines the analysis dimensions, which sets expectations for the response content beyond what annotations convey.

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

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

Three sentences, each adding value: purpose, content areas, and caching. Front-loaded and free of 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?

With one well-documented parameter and robust annotations, the description sufficiently covers the tool's behavior. The absence of an output schema is mitigated by the explicit list of analysis areas, though it could mention response format or variability, leaving a small 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 description coverage is 100%, with the parameter fully documented including format examples and prerequisite instruction. The description adds no additional parameter semantics, so the baseline of 3 applies when schema does the heavy lifting.

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

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

The description states 'Get an AI-generated strategic analysis of a trademark owner' and enumerates five specific content areas (brand protection philosophy, litigation posture, portfolio evolution, class distribution, likely future behavior), making the purpose unmistakable and distinguishing it from sibling tools like get_mark_ai_summary.

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 schema explicitly instructs to 'Use search_by_owner first to find the correct normalized name,' providing a clear prerequisite for correct usage. However, the description does not name alternatives for specific owner analyses (e.g., get_owner_filing_trends) nor explicitly state when not to use this tool, so it's clear but lacks 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 annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds meaningful context: data source (public USPTO owner resolution), nature (system-generated), and explicit exclusion of private workspace data. This goes beyond annotations by clarifying the data scope and what the tool will not return.

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 function, and every clause adds value. No redundant information 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?

With full schema coverage, an output schema, and annotations declaring safe read behavior, the description adequately covers the tool's scope and exclusions. It is complete for an owner-level read-only query tool, and the exclusion of workspace data helps avoid misuse.

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% with all seven parameters fully documented, so the description does not need to compensate. The description's phrase 'across a specific owner’s marks' adds mild context for owner_name but does not add new parameter-level semantics beyond the schema.

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

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

The description clearly states the tool gets public, system-generated trademark deadlines across a specific owner's marks, using a specific verb and resource. It distinguishes itself from sibling tools like get_mark_deadlines and get_firm_deadlines by emphasizing owner-level scope and public system-generated data.

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

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

The description implies when to use this tool: for owner-level public USPTO deadlines, not workspace/client/reminder data. It explicitly states exclusions ('Does not expose any workspace, client, reminder, or user-created deadline data'), though it doesn't name alternative sibling tools directly.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds context beyond annotations by specifying that results are yearly counts broken down by Nice class and that they reflect portfolio evolution. It does not disclose any surprising behaviors, but it adds useful detail about the output granularity.

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 primary purpose ('Get a trademark owner's filing trends over time'), and includes a useful secondary sentence about portfolio evolution. No redundant or filler content.

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

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

Given the simple read-only nature, the schema covers all parameters, and annotations cover safety, the description sufficiently conveys the output (yearly filing counts by Nice class) and its interpretive value. No output schema exists, but the description outlines the key structure of the returned 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 100%, so all three parameters have clear descriptions. The main description does not add any parameter-specific meaning beyond what the schema already provides. Baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the tool's function: retrieving a trademark owner's filing trends over time, broken down by Nice class. It uses a specific verb ('Get') and resource, and the mention of 'yearly filing counts broken down by Nice class' distinguishes it from other owner-related tools like get_owner_ai_summary or get_owner_deadlines.

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 clear context for when to use the tool ('Shows how the owner's trademark portfolio has evolved'), which implies a use case. However, it does not explicitly name alternatives or exclusion scenarios, so it falls short of a 5. The schema parameter description for owner_name does suggest using search_by_owner first, but that is outside the main description.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds behavioral context by noting results are 'most frequent' and that they reflect owner focus, but it does not describe the return format, how ordering works, or how frequency is computed. This adds some value but lacks richer behavioral detail.

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

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

The description is two sentences, front-loaded with the core action ('Get...') and immediately followed by the value statement. Every word contributes to understanding the tool; there is no wasted content. This is an efficient, well-structured 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?

For a read-only list tool with two well-documented parameters and no output schema, the description covers the purpose and use case sufficiently. It could mention the output format or limit behavior, but given the simplicity of the tool and the rich sibling context (which clarifies its niche), it is complete enough.

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% (both owner_name and limit have descriptions). The tool description does not add significant meaning beyond the schema; it mentions the concept of owner and keywords but does not elaborate on parameter usage or relationships. Given the full schema coverage, the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and clearly identifies the resource ('most frequent goods/services keywords for a trademark owner'). It distinguishes this from sibling owner-focused tools like get_owner_ai_summary or get_owner_filing_trends by focusing on keyword frequency. The added phrase about brand strategy and class patterns clarifies the tool's value proposition.

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 a clear use case ('useful for understanding their brand strategy and identifying class patterns') but does not explicitly state when to use this tool over alternatives or mention exclusions. It implies usage context rather than giving direct guidance, so it earns an implied-usage score.

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 readOnlyHint annotation by disclosing the evidence types used, the exclusion of agent addresses, and the confidence tiers ('high/possible'). It also warns that 'possible' results are tentative, setting clear expectations about output reliability.

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

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

Three sentences that pack a dense payload: purpose, methodology, output caveats, and usage guidance. No redundant filler; every sentence contributes meaningfully.

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?

Despite lacking an output schema, the description communicates what the tool returns (evidence + confidence tier) and how to interpret it. The context signals (read-only, non-destructive) align with the described behavior. For a complex analytical tool, this provides adequate context for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds valuable guidance for owner_name by emphasizing exact-as-recorded matching and suggesting resolve_trademark_subject for ambiguity, which compensates for schema's generic description. The limit parameter is already fully documented in the schema.

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

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

The description clearly states the tool's purpose: finding entities likely related to a trademark owner via USPTO evidence, with specific signals (shared ownership history, addresses, name tokens). It distinguishes itself from sibling tools like get_owner_filing_trends or get_mark_owner_landscape by focusing on corporate family relationships.

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

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

Explicit usage scenarios are provided (analyzing corporate family, portfolio scope, affiliation between owners) and it instructs to resolve ambiguous owner names with resolve_trademark_subject first. This is precise, actionable guidance that helps an agent decide when to use this 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context: filtering/counting only qualifying target marks, separately reporting all targets attached to qualifying proceedings, and a caveat that claimed-color metadata does not prove pleading allegations. This goes beyond the annotations without contradicting them.

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

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

Three sentences, front-loaded with the primary action. Every sentence earns its place: main purpose, filtering/reporting behavior, and a caveat with alternative. No filler or redundant restatement of schema fields.

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 13 parameters and no output schema, the description gives a solid high-level picture of outputs: counts of filtered target marks and separate reporting of all targets. It covers key nuances (exact class-only, color caveat) and points to an alternative for deeper evidence. It does not detail all return fields, but for an analytic tool this is acceptable.

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 77%, so baseline is 3. The description adds value for target_class_match by explaining 'exact class-only questions,' and clarifies the limited evidentiary weight of color claims (relevant to target_claims_color and target_color_families). This compensates for the missing 23% and enriches parameter understanding.

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 opens with a specific verb-resource combo: 'Analyze one trademark owner's TTAB enforcement in a single call.' It clearly distinguishes from siblings by emphasizing the single-call analysis and by pointing to analyze_ttab_proceeding for deeper color-evidence verification. The scope is unambiguous and not a tautology.

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 for use: analyzing a single owner's TTAB enforcement, including class/type/color filters and exact class-only needs. It explicitly directs to analyze_ttab_proceeding when color evidence must be confirmed in pleadings, giving a specific alternative. It lacks broader 'when not to use' guidance but is sufficient for most scenarios.

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 (readOnlyHint=true, destructiveHint=false) already establish safety, and the description adds meaningful semantic context: 'compact', the scope 'for one owner', and a caution about interpretation of totals. It doesn't describe output structure, but for a read-only stats tool with good annotations, this exceeds the baseline.

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 action and content, and every clause adds value—no filler, no repetition of schema details.

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

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

For a compact stats tool with no output schema, the description conveys the main output categories (opposition, cancellation, appeal, role breakdowns) and gives a clear alternative for deeper analysis. A slight gap is the lack of any indication of return shape or ordering, but the listed breakdowns and warning provide sufficient context.

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 67%, with owner_name and year described; limit lacks a description. The description reinforces 'one owner' and 'compact' but does not add parameter-specific semantics beyond the schema. Given moderate coverage, a baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and clear resource ('compact TTAB history for one owner'), enumerates the breakdown types (inter partes, opposition, cancellation, extension, appeal, role), and explicitly differentiates from the sibling tool get_owner_ttab_enforcement.

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 explicitly states when to use this tool versus an alternative: 'Use get_owner_ttab_enforcement for date ranges or challenged-mark/class analysis.' It also provides interpretive guidance ('Do not equate total records with initiated oppositions'), clarifying a common misuse.

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

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

Annotations already establish read-only and non-destructive behavior; the description adds meaningful output details (document link, extraction/readability status, cached text, excerpts). It doesn't contradict the annotations and provides behavioral context beyond the safety profile.

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

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

Three sentences, front-loaded with the action, and every sentence adds information—selectors, return types, and text_query guidance. No filler or redundancy, earning a top 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?

Given the tool's complexity (7 parameters, no output schema), the description covers the essential return fields and selector options. It doesn't address edge cases like 'document not found' or error behavior, but the annotation context and schema descriptions compensate, making it adequately complete for an agent.

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 high (86%), but the description adds key semantic context: it identifies document_id as the 'stable' and 'preferred exact selector', explains that code/date are alternative selectors, and clarifies text_query's excerpt behavior. This goes beyond the individual parameter descriptions.

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 begins with 'Retrieve one specific USPTO prosecution document,' using a specific verb and resource. It clearly distinguishes from sibling tools like list_prosecution_documents by emphasizing retrieval of a single document via various selectors, and from get_latest_office_action by covering any document type.

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

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

The description implies when to use it: when you have a specific document identifier. It also gives explicit instruction for text_query ('Use text_query when the user asks what the document says about a particular issue'). However, it doesn't explicitly contrast with similar retrieval tools like get_latest_office_action or research_office_action, so it lacks formal 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds behavioral context by clarifying that the output is 'raw data without AI analysis' and describes the chronological structure, which goes beyond what annotations provide. It does not discuss limits or auth, but that is not critical here.

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 purpose and followed by a clarifying statement about raw data. There is zero waste and it is appropriately sized for the tool's simplicity.

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 one parameter, read-only annotations, and no output schema, the description provides enough to understand what the tool does and what to expect (chronological list of events). It could be more specific about scope or limitations, but it is largely complete for a simple timeline retrieval 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?

The input schema has 100% description coverage for the single parameter serial_number, which is already described as a 'USPTO serial number.' The tool description adds no additional parameter-level detail beyond confirming it is for a trademark, so the baseline 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 clearly states the tool's function: 'Get the prosecution timeline for a trademark' and specifies the content as a 'chronological list of office actions, responses, and key events.' It distinguishes itself from siblings by noting it provides 'Raw data without AI analysis,' setting it apart from analysis-focused tools like analyze_prosecution_history and get_mark_prosecution_summary.

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 clear context on when to use the tool: for raw timeline data, and indicates a when-not by saying 'without AI analysis.' However, it does not explicitly name alternative tools for analysis, so it falls short of the highest standard for explicit alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds domain context (USPTO/TTAB) but discloses no additional behavioral traits like pagination behavior, though the after_code parameter hints at 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 sentence with a clear verb and a list of example table types. It is efficient and front-loaded, though the enumeration makes it slightly longer than strictly necessary.

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 lookup tool with a well-specified schema and annotations, the description conveys the core purpose and scope adequately. It doesn't explain pagination or return format, but these are not required given the schema and 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?

With 100% schema description coverage, the baseline is 3. The description does not add parameter-level detail beyond the schema; for instance, it doesn't explain the distinction between code, query, and after_code, but the schema already handles this.

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 ('Look up') and the resource ('USPTO or TTAB reference codes and small lookup tables'), with a helpful list of example table types. It is distinct in scope from sibling tools like get_nice_classes or search_design_codes, though it doesn't explicitly name them.

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 context: use when you need a reference code or small lookup table value. However, it doesn't state when not to use it or mention alternatives, such as more specialized sibling tools for specific tables.

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

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

Annotations already declare this as read-only and non-destructive. The description adds value by explaining the matching algorithm (phonetic, trigram, component) and the meaning of similarity_score vs confusion_score, including the commercial overlap concept. This goes beyond the annotations and 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?

Three concise sentences, front-loaded with the core purpose. Every sentence adds meaningful information without redundancy or fluff.

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 annotations covering safety, a rich schema, and an output schema (not shown but indicated), the description still adds context about the scoring semantics and intended use case. It is complete for a search tool of this complexity, providing enough for an agent to invoke 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 covers 100% of parameters, so baseline is 3. The description adds minimal param-specific context (e.g., mark_name, limit, include_dead) but does not go beyond the schema. It mentions scores which relate to output rather than parameters, so no extra param semantics.

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 it finds USPTO trademarks similar to a given mark name, specifying the search method (examiner-style knockout with phonetic, trigram, and component matching) and the purpose (identify potential conflicts). This distinguishes it from siblings like run_knockout_search and phonetic_search by highlighting the specialized output scores.

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 explicitly says 'Useful for trademark clearance searches,' providing a clear context. It does not mention exclusions or alternatives, but the use case is sufficiently clear for an agent to decide when to select 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?

Annotations already declare the tool read-only and non-destructive, so the description's added value is the return detail: 'per-filer live, registered, and pending counts plus corpus totals.' It does not contradict annotations and gives useful context about what the output contains.

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 focused sentences; the first states purpose and the second adds usage context and return summary. Every word earns its place, and key information is front-loaded.

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

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

Given the output schema exists and all parameters are documented, the description covers the essential use case, examples, and return highlights. Nothing critical is missing for an agent to select and 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 coverage is 100% with descriptions for all parameters, so the baseline is 3. The description mentions filer type and Nice classes but adds no additional semantic detail beyond what the schema already provides. It reinforces the ranking aspect but doesn't elaborate on 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?

The description clearly states a specific verb ('Get') and resource ('ranked filer table'), plus the key dimensions (date range, filer type, Nice classes). It also distinguishes from sibling tools by covering top owners, law firms, and correspondents, and provides a concrete example query.

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 explicitly says 'Use this when the user asks for top filers...' and gives an example, providing clear context for when to invoke. It does not explicitly mention when not to use it or name alternative tools, but the guidance is sufficient for a narrowed use 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?

The annotations already declare readOnlyHint=true and destructiveHint=false, so the safe read nature is known. The description adds scope (filings, registrations, TTAB proceedings) but does not disclose any additional behavioral traits such as data granularity, default time periods, or potential response shapes. This is adequate but not rich.

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, front-loaded sentence that clearly states the tool's function without any fluff. It is concise and 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?

Given the complexity (6 parameters, no output schema), the description is too sparse. It does not explain how metrics relate to parameters, what 'aggregate statistics' returns, or how to handle default vs. custom periods. The agent may struggle to know what to expect or how to construct a valid request.

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 50%, with three parameters lacking descriptions (group_by, nice_class, time_period). The tool description provides no parameter information whatsoever, failing to compensate for the gaps. The enums help somewhat, but the description adds no meaning beyond what the schema already provides.

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's purpose: retrieving aggregate statistics across USPTO trademark filings, registrations, and TTAB proceedings. It uses a specific verb ('Get') and resource ('aggregate statistics'), which distinguishes it from more specific analytics tools like get_owner_filing_trends or get_top_filers, though it doesn't explicitly name 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 provides no guidance on when to use this tool versus sibling analytics tools. It does not mention alternatives, exclusions, or prerequisites. The metric enum in the schema implies some usage context, but the description itself offers no direction.

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, openWorldHint=true, and destructiveHint=false, so the agent knows this is a safe read. The description adds valuable behavioral context by detailing the return payload (metadata, viewer link, PDF link, extraction status, document text, optional excerpts) and conditions like 'direct PDF link when available'. This goes beyond the annotations and clarifies what the tool does.

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 and front-loaded with the core action, then return details, then a usage pointer. Every sentence serves a purpose—action, output, and alternative guidance—making it concise without losing substance.

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

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

No output schema is provided, so the description must explain return values, and it does so by listing metadata, viewer link, PDF link, extraction status, document text, and optional excerpts. It also covers the prerequisite of knowing the entry number. Minor details like max_chars behavior are not mentioned, but overall the description is sufficiently complete for an agent to know what to expect.

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 already documents 3 of 4 parameters with descriptive text (proceeding_number, entry_number, text_query). The description adds minimal parameter-level detail, only repeating 'query-centered excerpts' and the relationship of entry_number to get_ttab_proceeding_details, which is already in the schema. With schema coverage at 75%, the description does not significantly compensate for any gap, so the baseline 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 clearly states the tool 'Retrieve[s] and read[s] one specific TTABVUE filing by proceeding number and entry number', using a specific verb and resource. It also distinguishes itself from the sibling tool get_ttab_proceeding_details by noting that the entry number comes from that tool, making its 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 explicitly provides a usage rule: 'Use get_ttab_proceeding_details first when the entry number is unknown.' This tells the agent when to use an alternative tool, which qualifies as explicit guidance on when to use this tool versus a sibling. No other exclusion is needed.

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

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

Annotations already cover readOnlyHint=true and destructiveHint=false, so safety is known. The description adds useful behavioral context about the return content: specific components like parties, marks, counsel, and recent filings with entry numbers and links, which is not available elsewhere since there is no output schema.

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

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

Two sentences, front-loaded with the core purpose and an em-dash list of contents, followed by targeted sibling disambiguation. Every word earns its place with no fluff or repetition.

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

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

Given no output schema, the description adequately hints at the return structure by naming key fields (parties, marks, counsel, recent filings with links). It also contextualizes against sibling tools. Minor omission: no mention of pagination or typical number of filings, but not essential for a raw-details fetcher.

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 for the single parameter proceeding_number is 100%, including an example format. The description does not add parameter-specific details, but the schema already fully documents it. 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 opens with a specific verb, 'Get raw details for a TTAB proceeding,' and clearly delineates the scope: parties, involved marks, counsel, and recent filings with entry numbers and working TTABVUE document links. This distinguishes it from siblings like get_ttab_document (single filing) and analyze_ttab_proceeding (AI analysis).

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 names alternatives and when to use them: 'Use get_ttab_document to read one selected filing. Use get_owner_ttab_enforcement for owner-wide distributions and analyze_ttab_proceeding for AI-powered merits analysis.' This provides clear decision guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds substantial behavioral context: market-determined fame, no per-class fame doctrine, a legal citation, the concept of using Nice class as a market proxy, and a clear caveat that this is circumstantial, not statutory proof. This goes well beyond the structured 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 dense but well-organized: purpose, critical nuance, return fields, use cases, and caveat. It front-loads the primary action and every sentence earns its place by addressing selection, invocation, or interpretation of results.

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

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

No output schema exists, yet the description enumerates the key return fields (is_famous, famous_in_class, fame tier, market footprint, portfolio size, enforcement history), explains the market proxy, lists concrete use cases, and sets expectations with the 'circumstantial signal' caveat. This fully equips an agent to decide when to invoke and how to interpret the result.

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 baseline is 3. The description adds strong semantic value to the 'class' parameter by explaining it is a 'PROXY for that market' and why market-specificity matters, which the schema's generic 'Optional Nice class number' does not convey. The 'mark' parameter isn't enriched, but the class parameter guidance is excellent.

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 ('Check whether a trademark is FAMOUS') and immediately adds the key distinguishing nuance: fame is market-specific and tested via a Nice class proxy. It also lists the returns and use cases, clearly separating it from generic lookup 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 explicit use cases ('Use for "is X a famous trademark?"...') and a boundary ('It is a circumstantial signal, not statutory fame proof'). However, it does not name any alternative tool (e.g., get_fame_profile) or state when NOT to use this tool, so exclusion guidance is incomplete.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful behavioral details: includes stable document identifiers, working USPTO links 'when available', extraction/readability status, and types of filings. This goes beyond the schema and 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?

Two tight sentences. The first provides a clear list of what the tool returns; the second gives a direct pointer to the sibling tool. No waste, front-loaded with the primary action.

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 list operation with a fully described schema, the description covers the key context: what is returned (identifiers, links, status, document types) and how to proceed to read a specific doc. No output schema exists, but the described return content suffices.

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% (both serial_number and limit are described). The description adds no new parameter-specific guidance, though it reinforces that the tool is scoped to a serial number. Baseline 3 applies because the schema already carries the parameter semantics.

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 specific verb (list) and resource (prosecution documents for a trademark serial number), and enumerates included content types. Also distinguishes from sibling get_prosecution_document by explicitly directing to that tool for reading a single document.

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

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

Explicitly tells the agent to use get_prosecution_document for reading one selected document, clarifying the complementary relationship. However, it does not mention alternatives like get_prosecution_timeline, and lacks explicit 'when not to use' exclusions beyond the one 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?

Annotations already declare readOnlyHint and destructiveHint, so the bar is lower. The description adds value by detailing the returned fields (owner, status, filing dates, goods/services, correspondent) and highlights the correspondent usage, which is beyond what annotations provide. It does not disclose edge-case behavior (e.g., not-found handling), but this is minor for a read-only lookup.

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, front-loaded sentence that lists key returned data and a specific use case. There is no redundancy or filler; each clause earns its place, and the 'use this for' parenthetical is directly actionable.

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

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

The tool is simple (one parameter) and has an output schema, so the description does not need to explain return values. It covers the core purpose, key data fields, and a prominent use case. Given the low complexity and rich schema/annotations, the description is complete enough for an agent to select and 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 coverage is 100%: the description's wording 'by its serial number' aligns exactly with the parameter schema, which already explains the format and constraints. The description adds no new semantic information about the parameter, so the baseline score of 3 applies.

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

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

The description clearly states 'Get detailed information about a specific USPTO trademark by its serial number,' which is a specific verb-resource pair. It distinguishes itself from siblings by listing the types of information returned (owner, status, filing dates, goods/services, correspondent) and the targeted use case for correspondent questions.

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

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

The description provides explicit guidance for when to use the tool, specifically for 'which firm represents/is correspondent for' questions. However, it does not mention exclusions or explicitly name alternative tools for other scenarios, so it lacks the 'when-not-to-use' clarity of a fully scored guideline.

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

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

Beyond the annotations (readOnlyHint=true, destructiveHint=false), the description discloses significant behavioral limitations: whole-mark comparison misses containing sound-alikes, and thin/empty results are not evidence of absence. It explicitly cautions against using this for clearance conclusions, adding critical interpretive context that annotations cannot convey.

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

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

The description is front-loaded with the core function, then uses a clearly marked 'LIMITS' section for critical caveats. Every sentence contributes essential information—there is no fluff. The structure helps an agent quickly understand both capability and boundaries.

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

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

Given the tool's complexity and the presence of an output schema, the description is remarkably complete: it covers the algorithm, scope limitations, alternative tools, and explicit guidance for when not to use it. It fully equips an agent to make correct invocation decisions even without seeing the output schema.

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 40%, so the description must compensate. It does explain the key parameter via 'whole-mark similarity threshold', which directly clarifies similarity_threshold. It does not elaborate on limit or include_dead, but those are fairly self-explanatory. The description adds meaningful context beyond the schema for the core algorithm while leaving some minor gaps.

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

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

The description states a specific verb and resource: 'Find trademarks whose WHOLE mark sounds similar to the given mark', with a clear method (Metaphone + trigram). It distinguishes itself from sibling tools like get_similar_marks by emphasizing whole-mark comparison, making 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 explicitly says when to use this tool (whole-mark sound-alike searches) and when not to rely on it: it warns about multi-word marks containing sound-alikes and explicitly directs to list_marks_containing_term for variant spellings and run_knockout_search for availability/clearance questions. This is textbook usage guidance with named alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds that it returns 'the most relevant classes with confidence scores and explanations,' but it does not disclose how relevance is determined or any other behavioral traits beyond the output format. With annotations covering safety, a 3 is appropriate.

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 action, and no filler. Every word earns its place, making this a model of concise 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?

For a tool with 2 well-documented parameters and no output schema, the description sufficiently explains the input (business description) and output (relevant classes with confidence scores and explanations). It could mention how many classes are returned or how the optional industry parameter affects results, but these are nice-to-have rather than gaps.

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

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

Schema description coverage is 100%, with both parameters (business_description and industry) fully described, including a minLength and instruction to pass the full user description. The description itself adds no extra parameter-level detail, so it matches the baseline expected when schema carries the 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 uses a specific verb ('Recommend') and resource ('Nice trademark classes'), and clearly ties it to an input condition ('based on a business description'). This distinguishes it from sibling tools like get_nice_classes (which likely retrieves class data) and suggest_gs_descriptions (which suggests goods/services descriptions).

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

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

The description clearly implies when to use this tool: when the user has a business description and needs relevant trademark classes. However, it does not explicitly mention alternatives or exclusions, so it stops short of a full guidance score.

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?

Even though annotations already state readOnlyHint=true, the description adds behavioral specifics that annotations do not cover: asynchronous execution (1-2 minutes), the requirement for authenticated users, the return of a processing handle, the need to call a status endpoint, and a direct user-communication instruction ('Tell the user it is running'). This is rich, non-redundant transparency.

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

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

The description is front-loaded with the purpose and return values, then covers async behavior and usage. It is a bit dense—three tightly packed sentences with em-dashes—but every clause provides needed information. The 'Tell the user it is running.' sentence is abrupt but functional. Slightly awkward structure prevents 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?

Given there is no output schema, the description does a good job explaining the return content categories (refusal categories, context, cited marks, coexistence support) and the asynchronous workflow. It could mention error conditions or what to do if the handle is invalid, but for a complex tool with no output schema, this is largely complete and actionable.

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 the single parameter (serial_number) with a clear description ('USPTO serial number of the trademark with the Office Action'). The tool description does not add further parameter-level context, so the baseline of 3 applies; the schema already does the heavy lifting.

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

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

The description opens with a clear verb+resource: 'Research the Office Action for a trademark' and enumerates specific outputs (refusal categories, OA/response context, cited marks, third-party registrations) that distinguish it from generic search tools. It also explicitly positions the tool relative to a sibling-like action ('Use this before draft_oa_response'), removing ambiguity about its role.

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

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

The description gives explicit usage timing ('Use this before draft_oa_response for preliminary research') and instructs the agent on the follow-up step (call get_office_action_research_status). It does not list when *not* to use it versus alternatives like get_latest_office_action, but the clear context and asynchronous guidance are strong enough to score above average.

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

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

Annotations already cover read-only and non-destructive behavior. The description adds value by disclosing an authentication requirement for specific entity types and indicating the output is a 'best match,' which goes beyond the structured annotations and provides useful behavioral context.

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: the first states the core purpose, the second adds a critical prerequisite. Both sentences are necessary and information-dense, with no filler or repetition. It is front-loaded with the primary action.

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

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

The tool handles multiple entity types and has no output schema, yet the description does not clarify whether it returns a single best match or a list of candidates. The 'limit' parameter implies multiple candidates, but the description says 'best match' (singular), creating ambiguity. It could be more complete by describing the response structure or matching confidence.

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

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

Schema coverage is 100%, with each parameter already described in detail. The description adds no new parameter information beyond what the schema provides; it essentially restates the enum values. Baseline 3 is appropriate because the schema carries the full weight.

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 resolves an ambiguous name to the best trademark entity match, listing concrete entity types (owner, firm, correspondent, mark, TTAB proceeding, client, portfolio). This distinguishes it from sibling search/lookup tools by focusing on disambiguation rather than raw searching.

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

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

The description implies usage for resolving ambiguous names and adds a key prerequisite: 'Resolving clients and portfolios requires authentication.' It does not explicitly compare to alternatives or state when not to use, but the entity-type scope and auth note provide clear contextual guidance.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is known. The description adds behavioral context by detailing the process (web research, market overlap, scoring) and positioning it as the most thorough option, which implies longer runtime or more comprehensive output—valuable beyond the annotations. No contradiction with annotations.

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

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

The description is two concise, front-loaded sentences. The first states the tool's function and scope; the second provides actionable guidance about an alternative. No filler or repetition—every sentence earns its place.

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

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

Given the tool's complexity (13-factor analysis, web research) and the absence of an output schema, the description communicates the essential scope and output nature ('factor-by-factor scoring'). It doesn't specify output format or runtime expectations, but for an agent selecting between tools, this is sufficient to invoke correctly. The sibling context further clarifies its role as the thorough alternative.

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 serial_a and serial_b described as USPTO serial numbers. The description only confirms 'between two trademarks' without adding parameter-specific syntax or constraints beyond the schema, so the schema carries the informational weight. Baseline 3 applies.

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

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

The description clearly states the tool runs a full 13-factor DuPont likelihood of confusion analysis between two trademarks, using a specific verb ('Run') and resource. It explicitly differentiates from sibling tool compare_marks by labeling itself the 'most thorough' option, making its 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 provides explicit usage guidance: 'use compare_marks for a quick check first' identifies an alternative and implies this tool is for thorough, deep-dive analysis. It also outlines what the analysis includes (web research, market overlap, factor-by-factor scoring), giving clear context for when to choose it.

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

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

Beyond the readOnlyHint and destructiveHint annotations, the description discloses significant behavioral details: the return structure ('4-tier risk-grouped results...plus a dead-mark "naming territory" sample'), performance expectations ('Most searches finish in under a minute'), limitations ('It does NOT check domain availability'), and the impact of the goods_description parameter on scoring. This is rich behavioral context that the annotations do not cover.

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 dense but every sentence contributes unique value: purpose, search scope, output structure, critical input guidance, limitation and alternative, performance and user communication, and optional parameter behavior. It is well-structured, front-loaded with the core purpose, and avoids redundancy with the schema.

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

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

For a complex search tool with 7 parameters, no output schema, and only safety annotations, this description is exceptionally complete. It covers the return format, limitations, performance, input requirements, and alternative tools. The agent can confidently invoke this tool correctly without additional documentation.

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 baseline is 3. The description adds extra meaning beyond the schema for goods_description ('ALWAYS pass...risk bands score goods/services relatedness') and owner_name ('adds portfolio context — shows the applicant's existing marks in searched classes'). It does not elaborate on other parameters, but the schema already suffices for them, and the added emphasis on critical parameters is 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 clearly states the tool's function with a specific verb and resource: 'Run an examiner-style knockout search with scoring via the unified knockout engine.' It further specifies that this is a 'PURE USPTO conflict search over 14M trademark records' with detailed algorithmic components, and explicitly distinguishes it from domain/brand availability checks by naming the alternative tool. This leaves no ambiguity about what the tool does.

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

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

The description provides explicit when-to-use guidance: 'ALWAYS pass goods_description when the user has told you what they sell' and explains why. It also names a specific alternative for a different use case: 'for that, use check_brand_availability instead.' Additionally, it instructs the agent to give the user a heads-up before calling due to expected latency, which is clear operational guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful context: 'constrained', 'without exposing schema details', and its role as a safe fallback. It doesn't contradict annotations and offers non-obvious behavioral traits.

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

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

Three sentences, front-loaded with the core purpose, followed by scope and usage guidance. No wasted words; each sentence earns its place.

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

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

Given the rich schema and output schema, the description provides sufficient decision context: what it does, when to prefer it, and its constraints. It covers the essential behavioral contract without needing to repeat schema 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 coverage is high (83%), so the schema handles most parameter semantics. The description adds high-level context about analysis types and entities but doesn't explain individual parameters beyond the schema. 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 specifies the verb ('Run'), resource ('constrained business-level analytics query'), and scope ('rankings, counts, snapshots, and timelines across owners, firms, and correspondents'). It distinguishes from siblings by framing it as the 'default fallback' and a safer abstraction layer.

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

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

Explicitly states when to use: 'default fallback for bespoke...' and instructs to 'Prefer this before chaining search, summary, or web research tools for aggregate business questions.' This provides clear context and alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds useful context by specifying the return content (prosecution statistics, TTAB counts, contact info). It does not describe any additional behavioral traits like pagination or potential performance implications, but given annotation coverage, a score of 3 is appropriate.

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 main action and followed by return types. Every word adds value, with no fluff or redundancy. It is appropriately sized for the tool's complexity.

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

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

Given the tool's moderate complexity, the description covers the core functionality and return information. The presence of an output schema further completes the picture. It lacks explicit mention of edge cases (e.g., no results) or sorting, but the schema and output schema fill most gaps. A score of 4 reflects solid but not exhaustive completeness.

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

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

Schema description coverage is 100%, so all three parameters (limit, search_term, search_type) are already documented with meaningful descriptions. The tool description does not add extra parameter-level meaning beyond the schema. Baseline of 3 applies because the schema does the heavy lifting.

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