Fda Drug Competition

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

Discloses default free model, BYO key for Anthropic, cost implications, return structure (score, confidence, signals, raw_response, combined view). Complements annotations well.

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: purpose, default behavior, API key note, return structure, use cases. No fluff, 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?

No output schema but description covers return structure. Explains default model and optional Anthropic. Sufficient for agent to understand inputs and outputs.

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% but description adds examples and clarifies usage (e.g., entity can be name/product/person/topic, models supported, _apiKey only needed if anthropic selected).

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?

Clearly states it probes LLMs for visibility scoring (0-100) per model, with default model and optional Anthropic. No sibling tool overlaps exactly, so it distinguishes well.

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 provided (AI-marketing audits, pre-launch brand checks, competitive monitoring). Lacks explicit non-usage or alternatives but context is clear.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds useful behavioral context beyond those: it routes to downstream tools, fills arguments automatically, returns structured answers with citation URIs, and advises a retry-once strategy on errors. 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 longer than minimal, but nearly every sentence earns its place: scope, behavior, examples, decision rule, and fallback guidance are all useful. It is front-loaded with the most important instruction ('PREFER OVER WEB SEARCH'). Slight redundancy in the repeated 'even if web search could also answer it' theme keeps it from a 5.

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

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

For a complex meta-router with no output schema, the description is unusually complete: it covers the domain categories, the routing behavior, the return format with citations, concrete examples, when to use it, when not to use it, and what to do on errors. The safety-relevant aspects are already covered by annotations, so nothing essential is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning by clarifying that the single question parameter accepts broad natural-language queries and that the tool will 'fill arguments' on its own — so the agent does not need to pre-specify tool-specific parameters. Examples reinforce acceptable query shapes.

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 ('routes', 'returns') and resource ('questions to one of 5,908 tools... returns structured answer with stable pipeworx:// citation URIs'). It is unmistakable what the tool does, but it does not explicitly differentiate itself from sibling tools like ask_pipeworx_beta or ask_pipeworx_grounded.

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 when-to-use guidance ('PREFER OVER WEB SEARCH', 'Use whenever the user asks...', 'START HERE for most questions'), explicit when-not-to-use ('unless you already have authoritative data in context, or the user is asking about your own capabilities'), and explicitly names web search as the alternative it should be preferred over.

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, open-world, and idempotent behavior. The description adds the experimental nature: candidate improvements may be live, results are compared against the stable router, and the tool currently matches ask_pipeworx exactly. This gives useful dynamic context beyond the static 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 detailed yet each sentence earns its place: it defines the tool, states the current experimental state, gives usage direction, and clarifies it is fully functional. The structure is front-loaded with the core definition and uses concrete detail like tool count and retirement date to make the beta status precise.

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 single-required-parameter schema and rich annotations, the description covers everything an agent needs: what it is, how to use it, current behavior, how it relates to ask_pipeworx, and that it returns the same response shape. No critical context is missing.

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

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

Schema description coverage is 100%, and all parameters are documented as aliases for question. The description's reference to 'same arguments' links to ask_pipeworx but does not meaningfully add parameter-level 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?

States a specific purpose: an experimental beta variant of ask_pipeworx that routes the same 5,908 tools with identical arguments and response shape. This clearly differentiates it from the stable ask_pipeworx and other siblings.

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

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

Explicitly instructs to use exactly like ask_pipeworx when the newest routing is desired, and contrasts it with the stable router for comparison. It also explains the current state (no active candidate) and confirms it is a fully working router, removing ambiguity about fallback behavior.

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 with readOnlyHint and openWorldHint in annotations, the description adds significant behavior: refusal reasons (not_in_source, no_tool_match, tool_error, data_truncated, llm_error), verbatim evidence extraction, confidence scoring, fetched_at, and an extra LLM call cost. This is exactly the transparency needed for a tool that an agent will trust with high-stakes answers. 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 three sentences are dense but efficient: they front-load the core purpose, then add return/refusal detail, use cases, and cost trade-off. Every clause contributes; only the full refusal enum could reasonably be deferred to an output 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?

With no output schema, the description supplies the full success return shape, the refusal shape with all enum values, the routing mechanism, and the cost/usage trade-offs. An agent has everything needed to invoke this tool correctly and interpret any response, including failures.

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?

All six parameters are aliases for the single required question, and the schema already provides full descriptions (100% coverage). The description adds only the context that the tool 'fills arguments' for the routed tool, which is helpful but doesn't change what the question parameter means or how it should be formed. 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 behavior ('Hallucination-resistant answer mode') and explains it routes like ask_pipeworx but only extracts answers from tool results. This clearly distinguishes it from ask_pipeworx and ask_pipeworx_beta, naming the exact mechanism that makes it grounded.

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 when to use it: 'Use whenever an answer will be quoted, cited, or acted on' and when to avoid it: 'prefer ask_pipeworx for casual lookups.' It also surfaces the cost trade-off (one extra LLM call) so the agent can make a rational selection.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds extensive behavioral details: fan-out to category-specific data packs, market resolution, classification, evidence packet return, error handling (low-confidence matches short-circuit, closed markets skip fan-out), tradeability flags, and resolution-rule risk. 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 long but well-structured with labeled sections (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, etc.), making it scannable. Every sentence adds value, though some redundancy (e.g., repeated examples) could be trimmed. Forefront loading of purpose and usage is good.

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 (3 params, no output schema), the description is exceptionally thorough. It covers response shapes, error cases, edge conditions (closed markets, wide spreads, low-confidence matches), and even resolves arbitration rule risk. An agent has sufficient information to invoke and interpret 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?

The description adds meaning beyond the input schema: it explains that 'market' can be slug, URL, or question text; clarifies 'depth' options (quick vs thorough) and default; and explains when to use 'include_raw' (true for recompute/cite/post-process, false for smaller responses). Schema coverage is 100%, but the description significantly enriches 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?

The description clearly states it researches a Polymarket bet by pulling Pipeworx data, with specific verb 'research' and resource 'Polymarket bet'. It distinguishes from siblings like ask_pipeworx and polymarket_edges by being the go-to tool for bet-specific research, explicitly listing use cases such as 'should I bet on X'.

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 for "should I bet on X", "what does the data say about Y", or "is there edge in Z"', giving clear context for when to use. It does not explicitly exclude alternatives or mention when not to use, but the list of siblings and the specialized nature imply boundaries.

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, idempotent, non-destructive behavior. The description adds value by detailing data sources (SEC EDGAR/XBRL, FAERS), handling of off-calendar fiscal years, result sorting by primary metric, and the inclusion of citation URIs. No contradictions 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 front-loaded with common query patterns and is well-structured, but it is somewhat verbose. Every sentence adds value, but it could be slightly more concise for 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 no output schema, the description explains the return format (paired data + citation URIs) and sorting. It covers data sources and edge cases like fiscal year handling. Missing error handling or limits, but adequate for a two-parameter tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context about what each type pulls and example values, but does not provide new parameter semantics beyond what the schema already contains.

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 performs side-by-side comparisons of 2-5 companies or drugs. It provides concrete example queries and differentiates itself from sequential single-pack lookups, which is a key distinction from sibling tools like entity_profile.

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

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

The description explicitly advises to prefer this tool over sequential lookups when comparing entities, and gives examples of when to use it (e.g., comparing, ranking). However, it does not explicitly state when not to use it, which would make it 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 signal readOnly/openWorld/idempotent/destructive, but the description adds substantial behavioral context: account/gating requirements, parallel decomposition across 5,908 tools, the findings packet shape (verbatim evidence, confidence, gaps[], contradictions[], hop fields, resolvable citation_uri), semantic excerpting, and 15–90s latency. This far exceeds 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?

The description is long but every sentence carries operational information: auth prerequisite, alternative routing, research mechanics, return contract, gap behavior, citation resolvability, excerpting, and latency. It is front-loaded with the account requirement and sibling routing, and despite its length it avoids 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 no output schema, the description fully explains return values: a findings packet with verbatim evidence, confidence, source, fetched_at, a stable citation URI, hop fields, explicit gaps[], and contradictions[] for standard/thorough. It also covers required auth/paid plan, latency, and when the tool will fail (empty gaps for non-structured topics). Nothing an agent needs to invoke or interpret it is missing.

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

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

Schema coverage is 100% for both params, so baseline is 3. The prose meaningfully enriches this: the depth parameter's hop semantics, facet counts, contradictions scan, and paid tier are explained in the description beyond the schema's enum, and the question parameter is contextualized with concrete examples. This justifies a point above baseline, though schema already carried the core definitions.

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: grounded multi-source research over Pipeworx's structured catalog, delivered in one call. It explicitly contrasts itself with open-web search and single-lookup siblings, making its identity and scope unmistakable.

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 when-to-use guidance: best for broad/multi-part structured-data questions, with clear alternatives — ask_pipeworx for single lookups and live/current-news topics. It also names the exact sibling to use when signed out, and explains depth-level trade-offs.

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 readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable behavioral context: it returns 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples) — each result is ready to call directly, no second schema lookup needed.' 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 moderately long but well-structured. It front-loads the purpose, then provides usage context, and finally details return format. Each sentence is informative and avoids redundancy. Could be slightly tighter but is efficient overall.

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 (1 required param, no output schema, 6 params total with aliases), the description adequately explains input format (natural language query), output format (list of tools with schemas), and behavior (top-N, ready to call). No gaps significant enough to hinder usage.

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 description adds limited new meaning beyond the schema. However, it provides example queries and clarifies that multiple aliases ('q', 'task', 'search', 'description') map to 'query', which reinforces understanding but does not significantly elevate parameter semantics beyond baseline.

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: 'Find tools by describing the data or task.' It lists numerous specific data sources (SEC filings, FDA drugs, etc.) and explicitly differentiates from sibling tools by positioning itself as a discovery tool to call first, contrasting with siblings that are domain-specific data 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 provides explicit usage guidance: 'Use when you need to browse, search, look up, or discover what tools exist for...' and 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This clearly indicates when to use, though it does not explicitly state when not to use or name alternative 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, openWorldHint, idempotentHint, and non-destructive behavior. The description adds meaningful context: it specifies the record sources (FDA Orange Book, PTAB, ANDA dockets) and includes an important caveat that dates are raw records, not legal conclusions about enforceability or launch. This exceeds the annotation baseline without contradicting 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?

Every sentence earns its place: an attention-grabbing opening, a concise explanation of the three joined sources, a clear statement of return values, direct use cases, and a necessary legal disclaimer. It is dense but not bloated, and the most distinctive 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 tool's complexity, the description is thorough: it names the data sources, the exact outputs, the intended use cases, and a legal caveat. The output schema exists to cover return structure, and the parameter schema fully documents the four optional parameters, so nothing critical is missing for an agent to select and call this 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 all four parameters are already documented in the input schema. The description does not add parameter-level semantics beyond what the schema 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 uses specific actions ('Joins...', 'Returns...') and clearly names the resource ('one brand drug's patent protection'). It explicitly lists the three data sources it combines, which differentiates it from single-source siblings like orange_book_competition_profile. The output is concrete: earliest unexpired unchallenged expiry, actively contested patents, and litigating generic firms.

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 use cases: 'loss-of-exclusivity diligence, generic-entry timing, or 'who is attacking this drug and where''. It implies this is the comprehensive single-call alternative to manually querying three sources, but it does not explicitly name sibling tools to use instead, so it falls just 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, openWorldHint=true, idempotentHint=true, destructiveHint=false, so safety is covered. The description adds real behavioral context: sources_failed and empty sections are real negatives rather than bugs, USPTO soft-fails until reactivated, FDA products only cover biologics so a small-molecule company may show none, and private companies return resolved:false with a notes line rather than an error. 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 front-loaded with concrete user utterances and the core directive (ALWAYS PREFER over chaining), then flows into a compact but efficient enumeration of sources and outputs. Every clause earns its place — examples, soft-fail warnings, empty-section semantics, private-company behavior — and the dense structure avoids repetition despite the volume of information.

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

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

For a read-only, idempotent, multi-source profile tool with two well-documented parameters and no output schema, the description covers inputs, output fields, source-failure semantics, and edge cases. The main missing piece is an explicit note that this is US-public-company-only and that it does not provide valuation or forward-looking data, but the description already states 'US public company' and the holistic framing makes scope reasonably clear.

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

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

Schema coverage is 100% and the description reinforces parameter semantics by giving concrete examples for value ("AAPL", "0000320193", "Moderna") and explaining type's interchangeability. It also adds the resolution behavior detail (resolved_from/resolved_to when value is a name), which is not present in the schema. The description meaningfully augments the already-covered parameters.

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

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

The description states a specific verb ('profile', 'brief', 'research') plus a resource (US public company) and enumerates the exact data sources and output fields. It clearly distinguishes itself from single-source lookups (SEC/XBRL/news) and sibling tools by positioning itself as the holistic cross-source profile. Examples make intent unmistakable.

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 ALWAYS PREFER over chaining single-pack lookups when the user asks for a holistic view, and it names the alternatives it supersedes. It also states accepted input shapes (ticker, zero-padded CIK, company name) and the expected result for private companies, so an agent knows exactly when invocation is appropriate and what to expect.

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 destructiveHint=true, so description adds context about clearing sensitive data, justifying the destructiveness. No contradiction.

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

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

Two efficient sentences front-loaded with action and condition. Every word earns its place.

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

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

For a simple 1-parameter tool with no output schema, the description fully covers purpose, usage, and relationships. No 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 already describes the key parameter at 100% coverage. Description adds no new parameter information beyond 'by key', so baseline 3 applies.

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

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

Clearly states 'delete a previously stored memory by key', specifying the verb and resource. Distinguishes itself from siblings by mentioning pair with remember and recall.

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 lists when to use: when context is stale, task is done, or want to clear sensitive data. Also directs to pair with related 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?

Description details behavioral steps beyond annotations: fetches the page, extracts title/description/key links, emits standard markdown. Annotations confirm read-only, idempotent, non-destructive, and description aligns without contradiction.

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

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

Three sentences: first explains purpose and action, second details process and output, third lists use cases. No wasted words, front-loaded with key 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?

With 2 params, full schema coverage, rich annotations, and no output schema, the description fully explains what the tool does, how it works, and what output to expect (text blob). Use cases cover typical scenarios.

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 clear descriptions. Description adds context by explaining that url is used to fetch the page, and mentions extraction process. For max_links, it adds no new info but reinforces schema. Overall adds value beyond 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 verb 'generate', resource 'llms.txt file', and purpose 'so AI crawlers can index the site cleanly'. It distinguishes the tool from all siblings (e.g., ai_visibility_check, ask_pipeworx) which are unrelated.

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?

Description lists three explicit use cases: getting a client's site indexed, drafting for your own project, auditing competitor. No exclusions or alternatives mentioned, but siblings are so dissimilar that context is sufficient.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds no behavioral details beyond listing return fields, which is sufficient but not extra.

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 main action, and no unnecessary words. Every part serves a purpose.

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 schema, rich annotations, and no output schema, the description covers all needed context: return fields, usage guidance, and no gaps.

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

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

Schema coverage is 100% with a well-described parameter ('include_inactive'). The description does not add extra meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the verb 'list' and the resource 'subscriptions', specifying it's the caller's active subscriptions. It lists the return fields, distinguishing it from sibling tools like 'subscribe' and 'unsubscribe'.

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 guidelines: use it to review what you're monitoring before adding more or to find an ID to cancel. This implies context and alternatives, though not 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?

Beyond the annotations (readOnlyHint, idempotentHint), the description adds critical context: 'Patent and exclusivity dates are FDA listings, not a legal conclusion about enforceability or actual generic entry.' This warns users about data limitations and legal implications, which 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?

Two sentences with no redundancy. The first sentence states the core purpose, and the second provides an essential caveat. Every sentence adds value without waste.

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

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

The description covers what data is retrieved (product, patent, exclusivity rows) and the scope (single application). An output schema exists, so return values are defined. A mention of any limits or error handling could improve completeness, but it is sufficient.

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

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

Schema coverage is 100% with a clear description for the only parameter 'application_number'. The tool description adds no extra parameter information beyond the schema, so 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 'Retrieve' and clearly defines the resource: 'all FDA Orange Book product, patent, and exclusivity rows for one NDA or ANDA application'. This distinguishes it from sibling tools like 'orange_book_product_search' (broader search) and 'orange_book_patent_expirations' (expiration-focused).

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 states the tool is for 'one NDA or ANDA application', implying it is for single-application detail rather than bulk queries. However, it does not explicitly mention when not to use it or provide alternatives from the sibling list, such as the expiration tools for aggregate views.

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, openWorldHint, idempotentHint, and destructiveHint. The description adds a valuable behavioral note that 'Approved ANDAs indicate regulatory approval, not launch, supply, substitution, or market share.' This clarifies output interpretation beyond what annotations provide, though it could mention more about data freshness or rate limits.

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 wasted words. The first sentence concisely states the purpose, and the second adds a critical caveat. It is front-loaded 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?

Given the tool's complexity (2 parameters, output schema present, annotations rich), the description covers the core purpose and a key behavioral note. It does not address pagination or error cases, but with openWorldHint and a well-defined schema, 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 100% with descriptions for both parameters (drug and limit). The description does not add new information about parameters beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Profile' and the resource 'FDA Orange Book competition' for a specific input (ingredient or trade name). It lists the key outputs (matched applications/products, holders, RLD, patents, exclusivities) and includes a clarifying caveat about ANDAs. This distinguishes it from sibling tools like orange_book_product_search and orange_book_application_detail.

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 profiling Orange Book competition but does not provide explicit guidance on when to use this tool versus alternatives. No when-not or alternative recommendations are given, though the context of Orange Book (small molecules) versus Purple Book (biosimilars) may be inferred from sibling names.

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 readOnly/idempotent annotations, the description discloses meaningful behavior: it returns earliest/latest dates, counts and dates back excluded items, and warns that expiration alone does not guarantee generic approval or launch. This adds useful context 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 three sentences with no fluff: purpose is front-loaded, usage guidance follows, and a necessary caveat closes it. 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?

For a read-only query tool with zero required params and an output schema already present, the description covers purpose, parameter usage, and an important interpretation caveat. The only minor flaw is slight ambiguity in 'anything excluded is counted', but overall it is complete 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 coverage is 100%, but the description adds semantics beyond the schema by explaining the interaction between drug and date parameters ('Ask by drug alone... add from_date/to_date only when you want a window') and clarifies drug can be brand or ingredient. This elevates it above the baseline 3.

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

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

The description clearly states the tool's function: it returns FDA marketing exclusivity expiration dates for a drug, with earliest and latest across the schedule. This specific verb+resource combination distinguishes it from sibling tools like orange_book_patent_expirations.

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 parameter guidance: ask by drug alone for everything, add from_date/to_date for a window. However, it does not explicitly contrast this tool with alternatives in the sibling list, so it lacks explicit exclusion criteria for when not to use 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?

Annotations already disclose read-only, idempotent, non-destructive behavior. The description adds that the tool returns dated events with ingredient, trade name, applicant, application, patent/use-code, and exclusivity-code context, which is useful beyond the schema. It omits minor details like limit clamping or event_type filtering, but the annotation coverage lowers the burden.

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

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

Two concise sentences with no filler. The core action is front-loaded and the return-value context is summarized efficiently.

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

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

With read-only annotations and an output schema present, the description provides enough context for an agent to understand the tool's purpose and output. Date format is demonstrated in the schema example, and event_type is enumerable. Minor gaps around filtering behavior exist but do not block correct invocation.

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

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

Schema description coverage is only 40%, and the description does not compensate. from_date and to_date have no schema descriptions and the description does not explain date range semantics or event_type filtering. It only implicitly references patent and exclusivity event types.

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

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

The description states a specific action and resource: it creates a combined calendar of Orange Book patent and regulatory-exclusivity expirations. By emphasizing 'combined,' it clearly differentiates this tool from sibling tools like orange_book_patent_expirations and orange_book_exclusivity_expirations.

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 'combined calendar' and 'cliff monitoring' imply usage for a broad patent/exclusivity expiration view, but the description does not explicitly say when to prefer this tool over dedicated patent-only or exclusivity-only siblings. Usage guidance is present by implication, not by direct contrast.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds meaningful behavioral detail beyond annotations: results are deduplicated across strengths and products, ordered chronologically, and include specific fields like first approval dates, TE codes, and active-product counts.

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 carry all necessary information with no filler. The first sentence front-loads the core function and dedup behavior; the second enumerates return fields. Every clause earns its place.

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

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

Given the output schema exists and annotations cover safety and idempotency, the description provides the missing context: what the tool returns, how it deduplicates, and what input means. No critical information for selecting or invoking the tool is absent.

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 limit and include_discontinued with descriptions, but the required drug parameter has no schema description. The description compensates by clarifying that drug matches an ingredient or trade name, which is essential for correct invocation.

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

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

The description specifies a precise operation (chronologically summarize), a clear resource (FDA-approved ANDA applications matching ingredient or trade name), and a distinctive analytic goal (generic-entry analysis). It is clearly differentiated from sibling tools like orange_book_product_search or orange_book_application_detail by its timeline focus and deduplication behavior.

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 'for generic-entry analysis' implies when the tool should be used, and the name signals it is the generic counterpart to purple_book_biosimilar_entry_timeline. However, it never explicitly names alternatives or states when not to use this tool, so the agent must infer routing from context.

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, openWorldHint, idempotentHint, and destructiveHint. The description adds meaningful behavioral scope by specifying 'approved ANDA counts' (excludes unapproved/tentative) and distinguishing 'active and elapsed' date ranges, which informs the agent about what the tool filters or computes. 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?

Two tightly written sentences with no redundancy. The first sentence front-loads the action and resource; the second lists the return contents. Every clause contributes useful 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?

With a full input schema, an output schema, and annotations covering safety, the description is sufficient for correct invocation. It clearly states what the tool does and what it returns. It is slightly incomplete for tool selection because it does not explicitly distinguish among the many Orange Book siblings, but overall it is adequate.

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

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

Schema description coverage is 100%, so all parameters are already documented (drug, limit, as_of_date). The tool description does not add new parameter meaning beyond the schema; it only restates the overall purpose. 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 uses a specific verb and resource: 'Build an FDA Orange Book loss-of-exclusivity evidence profile for a drug.' It also lists concrete outputs such as reference applications, approved ANDA counts, and patent/exclusivity date ranges. However, it does not explicitly differentiate this tool from siblings like orange_book_exclusivity_expirations or orange_book_patent_expirations, relying on the unique 'loss-of-exclusivity evidence profile' wording.

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 'for LOE diligence' gives a clear intended context, and the output list implies when an agent would need this tool. But there is no explicit when-to-use-versus-alternatives guidance or exclusions, which is a notable gap given many similar Orange Book siblings such as orange_book_competition_profile and orange_book_generic_entry_timeline.

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 readOnly/openWorld/idempotent annotations, the description reveals the exclusion-counting behavior: anything the date window excludes is counted and dated back so a filtered view is not mistaken for the full picture. It also discloses that FDA listings are sponsor-submitted and do not establish freedom to operate or launch date, adding meaningful caveats beyond annotation-provided hints.

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

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

Three dense sentences, each earning its place: purpose and ordering in the first, usage guidance in the second, and scope/caveats in the third. The content is front-loaded and free of 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 an output schema present, return values are already covered. The description supplies the remaining context an agent needs: what the tool does, when to use it, the small-molecule vs biologic boundary, filter semantics, and important data limitations. No critical information is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by clarifying that drug alone returns the full schedule, that from_date/to_date create a window, and that excluded results are still reported. Limit is not discussed in the description, but the schema fully documents it, so this is not a major gap.

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

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

The description clearly states the verb and resource: it returns Orange Book patent expiration dates for a drug, organized in order with earliest and latest across the schedule. It also distinguishes itself from Purple Book biologics tools, which is enough to separate it from sibling tools like orange_book_exclusivity_expirations and purple_book_biosimilars.

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 when-to-use guidance: ask by drug alone for a full schedule, add from_date/to_date only for a window, and notes that biologics belong in the Purple Book. This tells the agent when to use this tool versus alternatives, including a pointer to a different resource.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context by enumerating the returned data fields, which is valuable beyond the annotations. It does not disclose behavioral details like pagination behavior, result-limit defaults, or how partial matches are handled, but with the safety profile fully covered by annotations, 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 economical sentences. The first front-loads the action and search scope; the second enumerates return fields. No filler, no repetition of schema content, and every clause adds information an agent needs.

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?

Strongly complete for a search tool: it covers what can be searched, what is returned, and an output schema exists so return structures need no further explanation. Minor gaps remain — no guidance on combining query with application_number, and no note on result-limit behavior — but these are covered partly by the schema, so they only mildly detract from 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 four parameters (limit, query, application_number, include_discontinued) are already documented in the schema. The description's 'ingredient, trade name, applicant, or application number' loosely maps to query and application_number but adds no new format or usage detail beyond what the schema states (including the substring vs exact-match distinction already present in the schema). 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?

States a specific verb ('Search'), a specific resource ('FDA Orange Book products'), enumerates the search keys (ingredient, trade name, applicant, application number), and lists the returned fields (NDA/ANDA status, TE codes, RLD/reference-standard flags, etc.). This clearly distinguishes it from siblings like orange_book_application_detail and purple_book_product_search, since the Orange Book scope and search-oriented behavior are explicit.

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 'Search FDA Orange Book products by...' implies when to use it, and the Orange Book vs Purple Book scope in sibling names gives natural context. However, there is no explicit when-to-use vs alternatives guidance (e.g., when to prefer orange_book_application_detail for a single application, or purple_book_product_search for biologics), and no mention that this is the general-purpose entry point versus the more specialized orange_book_* siblings.

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, open-world, idempotent, and non-destructive, so the bar for additional behavioral disclosure is lower. The description adds what outputs are returned (reference applications, ANDA counts/applicants, TE-code groupings) and the grouping dimensions, but does not disclose limitations such as data currency, filtering behavior, or how 'open-world' results may vary.

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 filler. The primary action and target are front-loaded, and the return payload is summarized compactly. Every phrase 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 annotations (read-only, idempotent, open-world), an output schema, and a clear two-sentence description, the definition is largely complete for a safe query tool. It loses a point only because it does not guide selection among the numerous closely related Orange Book tools and leaves the drug parameter format unspecified.

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 'limit' and 'include_discontinued' adequately described in the schema, but the required 'drug' parameter has no schema description and the tool description only hints at 'reference listed drugs' without specifying acceptable formats (brand name, generic name, NDC). The description adds little clarity for the core parameter, leaving agents to guess how to pass the drug 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 uses a specific verb ('Map') and identifies the exact resource (FDA Orange Book reference listed drugs and reference standards) and the mapping target (approved ANDA competition by dosage-form/route and TE-code). It also lists the concrete returns, making the tool's function distinct from related Orange Book siblings like product_search or application_detail.

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 the use case of analyzing competitive ANDA landscape for reference drugs, but it does not explicitly state when to choose this tool over the many overlapping Orange Book siblings (e.g., orange_book_competition_profile, orange_book_generic_entry_timeline) or when not to use it. Guidance is only implicit in the 'landscape' framing.

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

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

Annotations provide no useful hints (all false), so the description carries the burden—and it delivers. It discloses rate limiting (5/day), quota impact (free, no call quota), the token-return behavior, how to read the resolution status, and the scope boundary. This goes well beyond what annotations offer.

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?

Although the description is long, every sentence carries actionable information: use cases, scope exclusions, token mechanics, rate limit, and quota note. It is front-loaded with the purpose and never wanders into filler. The structure follows a logical flow from 'what' to 'when' to 'how'.

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, yet the description covers the essential output behavior: filing returns a claim_token, and passing that token later returns status/fix information. It also addresses rate limits, scope boundaries, and content best practices. For a feedback tool with four optional params, this is fully 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 100%, so baseline is 3. The description adds meaningful context beyond the schema: it explains that filing without an account returns a claim_token and how to use it later with the example pipeworx_feedback({claim_token:"pwfb_…"}). It also gives content guidance ('describe in terms of Pipeworx tools/packs') that clarifies message and context parameters.

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

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

The description opens with a specific verb and resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It enumerates distinct feedback categories (bug, feature/data_gap, praise), and this clear scope differentiates it from sibling tools like ask_pipeworx or forget, none of which serve as a feedback channel.

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

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

It gives explicit 'Use when' conditions (wrong/stale data, missing tool, praise) and explicit exclusions: ONLY for Pipeworx-served tools, not other MCP servers, with a named alternative ('file it with that server instead'). It also explains when to use claim_token for follow-up, leaving no ambiguity about when to select 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 indicate read-only, idempotent, non-destructive. The description adds valuable details: data source (CF analytics-engine), no PII, and caching behavior (5min-1h). No contradictions.

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?

Four tight sentences, front-loaded with main purpose, every sentence adds value. No 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 one optional parameter, no output schema, and rich annotations, the description fully covers return values, privacy, caching, and use cases. No gaps.

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

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

Schema coverage is 100%, and schema description already explains parameter meaning. The description adds minimal extra context (e.g., shorter windows for hot, longer for steady), but this is not substantial beyond 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 returns top tools, packs, and call volume over recent windows, distinguishing it from siblings like discover_tools or entity_profile by focusing on aggregated trending data from other agents.

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?

Three explicit use cases are provided, but no when-not-to-use or alternative tools are mentioned. Context is clear enough for effective selection.

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

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

Annotations indicate read-only, idempotent, non-destructive behavior. The description adds extensive behavioral context: scan logic, partition filter, placeholder rejection, fill check, and return structure. No contradictions 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 detailed and well-structured with clear sections (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK). It is front-loaded with the main purpose. However, it is somewhat lengthy and could be slightly tighter without losing essential 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?

Given the complexity of the tool (multiple modes, algorithmic filters, output structure) and the lack of an output schema, the description covers all necessary aspects: input modes, algorithm, filters, return format, and even a caution about fill check. No gaps.

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

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

Schema coverage is 100%, and the description adds significant meaning beyond the schema: clarifies mode differences, provides example inputs (slugs, URLs), and explains the semantic anchor and partition filter. This helps the agent select and invoke the correct parameter.

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

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

The description clearly states the tool's purpose: finding arbitrage opportunities via monotonicity violations and partition-sum checks. It distinguishes three modes (no args, event, topic) and contrasts with siblings like polymarket_edges and polymarket_fill_risk.

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 guidance is given for each mode: no args for trending scan, event for specific markets, topic for cross-event scanning. It also explains when to use polymarket_fill_risk for custom sizing and warns against trading when fill check shows zero realizable edge.

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 extensive behavioral traits beyond annotations: three segments with model details, response structure including diagnostics, caching behavior (1h KV-level), Fed bet exclusion rationale, and edge/Kelly field definitions. All consistent with readOnlyHint, idempotentHint, and openWorldHint 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 thorough and well-structured with sections, but somewhat verbose. Every sentence serves a purpose, providing necessary detail for a complex tool. Could be tightened slightly but maintains clarity.

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

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

For a complex tool with 9 parameters and no output schema, the description is remarkably complete. It covers purpose, all parameters with usage advice, response structure with segments and diagnostics, caching, and edge cases like empty segment reasons. No gaps identified.

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 meaningful extra context for parameters like slippage_pp (suggesting bump for thin partitions), min_liquidity, max_spread_pp, and min_partition_leg_kelly (explaining behavior with partition arbs). This enhances understanding 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 scans top Polymarket markets and returns opportunities where Pipeworx data disagrees with market price, using a specific verb and resource. It distinguishes from siblings by highlighting its unique discovery purpose for 'what should I bet on today' without paging hundreds of markets.

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 (opportunity discovery) and includes detailed guidance on tradeable-edge knobs and parameter settings. However, it does not explicitly state when not to use it compared to alternative tools like polymarket_arbitrage or polymarket_fill_risk.

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 indicate read-only, open-world, idempotent, non-destructive behavior. The description adds significant context by explaining the return structure (tracked, expired, snapshot_dates) and limitations (60-day TTL, daily closes). No contradictions 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 comprehensive but slightly verbose. It is well-structured with clear sections for args, response, and limits. However, some sentences could be merged for brevity.

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

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

Despite lacking an output schema, the description fully details the return format (tracked, expired, snapshot_dates) and covers limitations. It provides all necessary context for a tool with two optional parameters and a rich response.

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%, but the description adds meaning by explaining the 'days' parameter as lookback with default and max, and 'window' as snapshot family with examples. It also mentions defaults, adding value 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 states that the tool provides 'edge persistence and decay telemetry' and answers a specific question about edge freshness. It clearly distinguishes from siblings like 'polymarket_edges' by focusing on historical time-series and decay 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 explains when to use the tool (e.g., to differentiate between a fresh edge and an old one) but does not explicitly mention when not to use it or provide direct alternatives. The context of sibling tools provides implicit differentiation.

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, etc.) already indicate a safe read operation. Description adds useful behavioral context: walks the order-book ladder, returns fill details, slippage, and risk warnings like forced_directional_risk. No contradictions 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?

Description is long but well-structured with clear section labels (SINGLE-MARKET, BASKET). All sentences add value; no filler. Could be slightly shorter but complexity justifies length.

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 no output schema, description thoroughly lists return fields for both modes, including risk indicators and verdicts. It covers prerequisites (requires market or event), explains edge cases (thin books, partial fills), and provides enough detail for an agent to 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 description coverage is 100%, but description adds significant value: clarifies market vs event mutual exclusivity, explains side defaults per mode, and defines size_usd interpretation (max spend vs target proceeds vs settlement notional). This goes well 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's purpose: 'Realizable-vs-theoretical edge check against live CLOB order-book depth'. It distinguishes from siblings by explicitly directing use before acting on polymarket_arbitrage signals or polymarket_edges trades above ~$500, differentiating it from those 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?

Description provides explicit when-to-use guidance: before acting on polymarket_arbitrage signals or polymarket_edges trades above ~$500. It explains why (unrealizable edge, unhedged directional risk) and implicitly defines when not needed (small trades). Alternatives are named in sibling tools.

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

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

Annotations already state readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description goes far beyond that by explaining the matching method (keyword/word overlap, not shared resolution source), the meaning of every compatibility code, the fee disclosure (Kalshi fees not modeled, spreads are gross), and the behavior for unclassified legs. It also clarifies that compatibility codes can appear on returned pairs, preventing misinterpretation. 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 long (several paragraphs) and covers many nuances, but it is well-structured with clear sections (modes, response, safety fields, codes, fees note, skipped counters). Some points are repeated (e.g., temporal_alignment_unknown explained twice, compatibility warning emphasized twice), but the complexity of the tool justifies most of the length. Front-loaded with the core purpose and modes, so agents get the gist quickly.

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

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

There is no output schema, so the description must fully specify the response shape and edge cases. It does: explains the spread array, top_spreads_pp, per-entry flags, temporal_alignment object, fees_note, skipped_cross_type/subtype counters, and the handling of unclassified legs (never paired, placed in skipped_unclassified/low_confidence_pairs). It also covers required parameter behavior and caveats about pre-mapped topics. Nothing essential is missing for an agent to call the tool correctly and interpret results.

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

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

Schema coverage is 100% with each parameter having a clear description (e.g., topic enumerates the shortcuts, ticker/slug specify overrides). The description adds crucial behavioral context about how parameters interact (both modes run identical matcher, explicit overrides the mapped side), and it notes that topic is 'pre-mapped' but not guaranteed to resolve. This enriches the schema without repeating it.

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 statement of purpose: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It clearly distinguishes this from sibling tools (polymarket_arbitrage, polymarket_edges, etc.) by focusing on the spread between venues, and it details what the tool returns and its safety caveats. No ambiguity.

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

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

The description explicitly defines two usage modes ('topic' for pre-mapped shortcuts, explicit ticker/slug for custom pairings) and explains when to use each. It warns that pre-mapped topics often return compatibility_warning and are not necessarily tradeable, guiding the agent to interpret results cautiously. It also clarifies that both modes run the same matcher, so usage expectations are consistent.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the bar is lower. The description adds genuinely useful behavioral context beyond those hints: 'unique' signals deduplication of 351(k) BLAs, and 'chronologically summarize' signals temporal ordering and aggregation rather than a raw list.

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 filler: the first front-loads the core behavior and resource, the second lists return fields and the use case. Every sentence earns its place and nothing is redundant 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 simple two-parameter, read-only query tool with 100% schema coverage and an output schema, the description plus structured fields cover invocation and expectations well. The one gap is the missing routing guidance relative to the purple_book_* sibling family, but nothing essential for calling the tool correctly is absent.

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% — limit (1-100, default 50) and reference_product (proper/proprietary or related name) are both documented in the schema. The description's 'reference biologic' loosely echoes the reference_product parameter but adds no new parameter-level detail, so the 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?

States a specific verb (chronologically summarize), a precise resource (unique FDA-licensed 351(k) BLAs associated with a reference biologic), and lists the returned fields (approval dates, applicants, product names, reference products, designations). The 'entry timeline' angle distinguishes it from the seven purple_book_* siblings covering biosimilar lists, interchangeables, and product 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 'for entry analysis' implies a use case, but no alternatives or when-not-to-use guidance is provided. With seven purple_book_* siblings, including purple_book_biosimilars and purple_book_competition_profile, an agent gets no explicit cue for choosing this tool over them. Usage is implied rather than stated.

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

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

Annotations already declare read-only, open-world, idempotent, and non-destructive behavior. The description adds a valuable real-world caveat: FDA licensure does not mean commercial launch or current availability, which is exactly the kind of behavioral context an agent needs when interpreting results.

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 tight sentences: the first states the action and scope, the second provides a necessary interpretive caveat. No wasted words, and the most important information is front-loaded.

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

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

For a read-only listing tool with an output schema and strong annotations, the description covers the core purpose, filter semantics, and an important data-quality caveat. It is slightly less complete because it does not route the agent toward more specialized sibling tools, but nothing essential is missing.

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

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

The description defines what 'query' means (reference product, applicant, or product name), compensating for the schema's undocumented 'query' property. Both other parameters are already documented in the schema, so the description adds meaningful value without fully specifying matching 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 uses a specific verb ('List') with a clear resource ('FDA-licensed 351(k) biosimilar and interchangeable products') and names the optional filters (reference product, applicant, product name). This distinguishes it from sibling tools like purple_book_interchangeables or purple_book_reference_product.

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

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

The description makes clear this is a list-oriented search with optional filters, and the approval-versus-availability caveat adds important usage context. However, it does not explicitly name sibling alternatives or state when to prefer a more specialized tool like purple_book_product_search.

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

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

Annotations already flag readOnly and idempotent, and the description adds meaningful behavior: it counts unique BLAs and separates product categories rather than measuring market activity. The explicit exclusions (launches, availability, sales, market share) give an agent a clear model of what this tool can and cannot tell 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?

Three tight sentences with zero filler: purpose, method, and limitations are front-loaded. Every sentence earns its place, and the key exclusion is placed at the end as a useful caveat rather than cluttering the core definition.

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

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

For a two-parameter, read-only profile tool with an output schema available, the description covers the input semantics, output categories, and known limitations. It could be slightly stronger with an explicit nod to the sibling Orange Book tool for small-molecule equivalents, but it is complete enough for correct invocation.

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

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

The required 'biologic' parameter has no schema description, but the tool description fills this gap by defining the accepted name forms (proper, proprietary, or reference-product name). The 'limit' parameter is documented in the schema with range and default, so the description does not need to repeat it.

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

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

The description names a specific action ('Profile'), a specific resource ('FDA-licensed biologic competition'), and a precise input ('proper, proprietary, or reference-product name'). It also states the output categories (reference products, biosimilars, interchangeables), distinguishing it from sibling tools like purple_book_biosimilars or purple_book_reference_product.

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 clearly indicates when to use: when you need a competitive profile around a named biologic, and explicitly lists what it does not provide (launches, availability, sales, market share). It does not name an alternative sibling for those other needs, so it stops short of fully explicit substitution 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, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds a useful caveat about the legal meaning of interchangeability, but does not disclose any additional behavioral details 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?

Two concise sentences with no filler. The first sentence states the action and scope, and the second adds a necessary regulatory caveat without diluting the core message.

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 rich annotations, the description covers the core purpose and query semantics adequately. It would be slightly stronger if it explicitly positioned this tool against the related purple_book_* siblings, but nothing essential to invoking it correctly is missing.

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

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

Schema description coverage is 0%, but the description compensates by explaining that the query can filter by reference product, applicant, or product name. The limit parameter is not described, though its meaning is largely self-evident from the example and parameter name.

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 ('List') and a precisely defined resource ('FDA Purple Book products designated 351(k) Interchangeable'). It clearly distinguishes this from sibling tools like purple_book_biosimilars by foregrounding the interchangeability designation.

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 optional filtering by reference product, applicant, or product name, which gives some usage context. However, it does not explicitly state when to choose this tool over related sibling tools such as purple_book_biosimilars, purple_book_product_search, or purple_book_reference_product.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the operation's safety profile is established. The description adds valuable context by stating that it returns licensure and product-level attributes, and it includes an important interpretive caveat that a licensed biosimilar is not necessarily launched, available, interchangeable, or substitutable. This goes beyond the structured metadata without contradicting it.

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

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

The description is three sentences with no filler. The primary action and searchable fields are front-loaded, followed by a brief return-type statement and a useful legal caveat. Every sentence 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?

Given that an output schema exists, the description does not need to detail return values. The presence of annotations covers safety and idempotency, and the description covers search scope and data interpretation caveats. It could be more complete by naming sibling tools or clarifying when the specialized Purple Book views should be preferred, but nothing essential is missing for invoking the 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 75%, so the schema already documents most parameters. The description mirrors the query parameter's allowed search fields (name, applicant, reference product, BLA) and adds 'proper/proprietary' specificity, but it does not materially extend the schema's parameter semantics for limit, license_type, or include_discontinued.

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 verb (search), the resource (FDA Purple Book biologic products), and the search dimensions (name, applicant, reference product, BLA), making the tool's purpose easy to grasp. It is distinguishable from the sibling tools by its general product-search scope, though it does not explicitly name any sibling to differentiate itself.

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

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

The description implies usage for searching Purple Book products by name or BLA, but it provides no explicit guidance on when to choose this tool over the many related sibling tools such as purple_book_biosimilars or purple_book_interchangeables. There are no exclusions or alternative recommendations, so usage context is only implicit.

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

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

With readOnlyHint=true, idempotentHint=true, and destructiveHint=false, the safety profile is already carried by annotations. The description adds value beyond that: 'latest monthly' scoping and the semantic caveat that R/U codes do not necessarily mean newly licensed, which prevents misinterpretation of results. 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?

Two sentences and roughly 35 words with the core action front-loaded, followed by code decoding and a domain caution. Every clause earns its place, and nothing repeats what the schema or annotations already state.

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?

An output schema exists so return values are covered elsewhere, annotations carry the behavioral profile, and the description handles the domain-specific codes and scoping. The only residual gap is what the query parameter searches across, which is minor given the tool's simplicity.

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

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

Schema description coverage is 0%, so the description must compensate. It fully explains the ambiguous change_type enum (N=newly approved, R=added in current release, U=updated), which is the highest-value parameter, but says nothing about limit or query, leaving their semantics to be inferred from name and type.

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

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

States a specific verb and resource: 'Return the changes section of FDA's latest monthly Purple Book report.' It also decodes the N/R/U change codes and adds the important caveat that updated/added does not necessarily mean newly licensed, which clearly differentiates it from siblings like purple_book_product_search or the generic recent_changes.

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

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

The description gives clear context that this tool serves change-history queries for the latest monthly Purple Book report, so an agent can infer when to reach for it. However, it names no sibling alternatives or exclusion conditions (e.g., when to prefer purple_book_biosimilars or recent_changes), leaving differentiation to the agent.

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, idempotent, and non-destructive. The description adds valuable context by warning that 'Product rows and BLA counts must not be interpreted as market participants, launches, or market share,' preventing misinterpretation of regulatory data. This goes beyond the basic safety profile provided by 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 states the core action and target, the second provides an essential interpretive warning. Both sentences earn their place, and the key function 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 tool's simplicity, the presence of an output schema, and comprehensive read-only annotations, the description is largely complete. It covers the search action and an important caveat about data interpretation. The main missing elements are explicit guidance on when to use this tool versus similar purple_book tools and any explanation of the limit parameter.

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 0% schema description coverage, the description must compensate. It does add meaning to reference_product by specifying lookup 'by proper or proprietary name.' However, limit is left completely unexplained, including its purpose, default, or constraints, leaving a gap for one of the two parameters.

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

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

The description uses the specific verb 'Find' and clearly identifies the resource: a reference biologic and its FDA-licensed 351(k) products, searched by proper or proprietary name. This distinguishes it from sibling tools like purple_book_biosimilars or purple_book_product_search, which focus on broader listings rather than a reference product and its associated products.

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 the usage scenario (lookup by name for a reference biologic and its 351(k) products) but does not explicitly state when to prefer this tool over alternatives like purple_book_biosimilars or purple_book_product_search. It also provides no exclusions or routing guidance, which is notable given the large sibling set.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the tool's safety is clear. The description adds value by explaining scoping ('scoped to your identifier') and the behavior of omitting the key to list all keys, which is not covered by 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 concise (three sentences) and front-loaded with the core action. Every sentence adds value: purpose, usage guidance, and scoping/pairing. No redundant or extraneous 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 nature (one optional parameter, no output schema), the description covers the tool's purpose, usage context, scoping, and relationship with siblings. It provides enough information for an agent to correctly invoke the tool without needing additional details.

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

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

The parameter schema has 100% coverage with a description for 'key'. The description adds meaningful context by providing examples of what keys might contain (target ticker, address, research notes), enhancing understanding 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 retrieves values saved via 'remember' or lists all keys when the key argument is omitted. It specifies the verb 'retrieve' and resource 'values saved via remember', distinguishing it from sibling tools like 'remember' and 'forget'.

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 use cases (e.g., retrieving a target ticker, address, research notes) and explains why to use it (avoid re-deriving context). It also mentions pairing with remember and forget. However, it does not explicitly state when not to use this tool or compare it to other siblings.

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 readOnly, idempotent, openWorld. Description adds critical behavioral detail: setting mark_read:true flags events as read to affect future calls. 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?

Three sentences: first states purpose, second details features, third adds usage tips. Every sentence adds value, front-loaded, 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?

Given no output schema, description explains return structure (source, citation_uri, raw payload) and key behaviors (filtering, mark_read, polling). Completely adequate for a read-only 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?

Schema covers all 5 parameters with descriptions (100% coverage). Description adds examples (e.g., 'sec_8k' for type, ISO timestamps) and clarifies mark_read effect, providing meaning beyond 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?

Clearly states it pulls fired events from the subscription feed, specifies returned fields (source, citation_uri, raw payload), and mentions filtering options. Distinguishes itself from sibling tools like list_subscriptions.

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 polling works fine and provides an alternative REST endpoint for scripts/dashboards, guiding when to use the tool vs. direct API. Does not explicitly compare to siblings but offers clear usage context.

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?

Discloses that the tool fans out to multiple sources, with a fallback from GDELT to GNews when rate-limited or on 5xx, and a soft-fail for USPTO due to API sunset. Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so the description adds useful behavioral context beyond 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 well-structured with a clear purpose statement, parameter explanations, usage examples, and a sibling differentiation. Every sentence adds value without unnecessary fluff, making it both informative and concise.

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 (multiple data sources, fallback logic, parameter options, no output schema), the description is remarkably complete. It covers data sources, fallback behavior, parameter formats, and provides an explicit alternative tool, leaving no major gaps.

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

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

Schema coverage is 100%, but the description adds significant meaning: explains `since` accepts ISO dates or relative shorthand (e.g., '7d', '1y'), `value` can be ticker or CIK, and `type` is currently limited to 'company'. This goes well beyond the schema 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 clearly states that the tool provides a change feed for a company over a time window, aggregating from SEC EDGAR, GDELT/GNews, and USPTO. It gives example queries like 'What's new with X' and distinguishes from the sibling tool 'entity_profile'.

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 when to use this tool vs. 'entity_profile' (static profile). Provides parameter guidance for `since` (ISO date or relative shorthand) and examples for `value` (ticker or CIK). Also explains fallback behavior between GDELT and GNews.

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?

Discloses key traits beyond annotations: 'Stored as a key-value pair scoped by your identifier', 'Authenticated users get persistent memory; anonymous sessions retain memory for 24 hours.' Adds context on scoping and retention that annotations alone don't provide.

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?

Multiple sentences but tightly written with no waste. Front-loaded with core purpose, followed by usage triggers, then storage details, then pairing instructions. 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?

For a simple write-only tool with no output schema and clear annotations, the description provides all necessary context: purpose, when to use, storage behavior, scoping, retention, and sibling relationships. No gaps.

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

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

Schema coverage is 100%, so baseline is 3. Description adds extra meaning: explains that key-value is scoped by identifier, gives example patterns in key description ('subject_property', 'target_ticker'), and defines value as 'any text'. This goes beyond bare schema.

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

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

The description clearly states 'Save data the agent will need to reuse later', specifying the verb 'save' and resource 'data'. It distinguishes from sibling tools 'recall' and 'forget' by naming them for retrieval and deletion.

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 when to use: 'when you discover something worth carrying forward'. Provides clear alternatives: 'Pair with recall to retrieve later, forget to delete.' This gives solid guidance on selection among siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds substantial behavioral disclosure beyond that: it explains the internal cascade ('cascades through several lookup endpoints internally'), graceful degradation ('if GLEIF or OpenFIGI is unavailable, the EDGAR identifiers still return'), and how ambiguous matches are handled ('asserts nothing and returns figi_candidates'). This meaningfully exceeds the baseline, though it doesn't cover every edge case (e.g., rate limits), so a 4 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 long and dense, but every clause carries important information—edge cases, source labeling, fallback behavior. It front-loads examples and the primary directive ('Use FIRST'), then flows into details. While it could be trimmed, the length is justified by the tool's complexity. It's well-structured and readable, so a 4 is fair.

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 must explain return behavior, and it does thoroughly: it mentions returned identifiers are source-labelled, unresolved ones appear under 'unresolved', multiple security matches yield 'figi_candidates', and drug lookups return RxCUI + ingredient + brand. It even covers the non-US issuer case. An agent calling the tool knows what to expect and how to interpret results, making it complete for its 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?

Although schema coverage is 100% (both parameters have descriptions), the description adds critical meaning beyond the schema. For the 'value' parameter, it warns against passing the full noun phrase for bonds ('never the question's full noun phrase'), which is a crucial semantic distinction. For 'type', it enriches the enum with detailed behavior for each type. This goes well beyond the baseline 3 for 100% coverage, so a 5 is justified.

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 concrete example queries and then states the precise purpose: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' It names the resource (identifiers) and distinguishes itself from 30+ sibling tools by being the only one focused on name→ID resolution. No ambiguity about what it 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 explicitly directs 'Use FIRST whenever you have a name but need an ID,' which is a clear when-to-use instruction. It also explains what it replaces ('2-3 manual lookups'), giving useful context. However, it does not explicitly state when NOT to use it or name alternative tools (e.g., 'for a full entity profile use entity_profile'). The guidance is strong but lacks explicit exclusions or sibling comparisons, so a 4 is warranted.

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?

Discloses that the tool internally calls ai_visibility_check for each entity, ranks results, and surfaces most/least recognized. Adds behavioral context beyond annotations (readOnlyHint, openWorldHint, etc.) such as the probing process and output format. No contradictions.

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?

Four sentences, each serving a distinct purpose: purpose, process, use case, output. No redundancy. Front-loaded with the core 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?

With 4 parameters all described in schema and enriched by description, and no output schema needed because return type is clearly stated (ranked list with score, confidence, signal density per entity), the description is fully sufficient.

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

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

Adds meaning beyond the schema: explains that the first entity is the 'subject' for narrative purposes, gives examples for the context parameter, clarifies free default for models, and notes API key usage. Schema coverage is 100%, and description enriches it.

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?

Defines the tool as comparing AI visibility across multiple entities side-by-side, with clear verbs (compare, scan, probe) and a specific resource (AI presence). Distinguishes from sibling ai_visibility_check by emphasizing multi-entity comparison and ranking.

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 an explicit use case (competitive AI-marketing audits) and a concrete example question. Implies when to use this tool over ai_visibility_check (single vs. multiple entities), though does not explicitly list 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, idempotentHint, destructiveHint. Description adds valuable behavioral details: partial failures degrade gracefully, bundlephobia first measurement can take 5-30s, sources_failed lists timeout. 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?

Description is front-loaded with purpose, but slightly verbose with inline details. However, every sentence adds value. Could be tightened slightly, but still 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?

Despite no output schema, the description thoroughly explains return format: summary block with specific fields, per-advisory detail, links, alternative versions. Also covers ecosystem scope, partial failure, and timing. Complete for 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%, so baseline is 3. Description adds no additional meaning beyond what schema provides (package name and version). No extra guidance on default behavior or formatting.

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 is a composite check for npm packages covering license, advisories, version history, bundle size, etc. It uses specific verb 'scan' and resource 'dependency', and distinguishes from related tools like deps.dev:version.

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 when-to-use: 'whenever an agent asks 'is X safe / popular / small' or 'what does adding lodash cost me''. Also specifies limitations: 'NPM ecosystem only in v1; PyPI / Maven / Cargo / Go fall under deps.dev:version 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, openWorldHint, idempotentHint as true. The description adds beyond annotations: BGE-base-en embeddings, cosine similarity over 500-char overlapping windows, 200K char cap with truncation flag. No contradiction.

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

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

The description is 4-5 sentences, front-loads purpose and usage, then pairs with a sibling, then adds technical details. Every sentence adds value. 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?

Given 3 parameters, no output schema, the description covers purpose, usage, behavioral specifics, and parameter semantics. Mentions what is returned (passages with offsets and similarity scores). Adequate for a complete understanding.

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%. Description adds examples for the query parameter and explains the limit parameter's range and default. Adds nuance like 'text to search inside' and 'natural-language query' beyond the schema 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 states 'Semantic search INSIDE a fetched record' and provides specific examples (SEC 10-K, article, long tool result). It distinguishes itself from siblings by mentioning its pairing with ask_pipeworx_grounded, differentiating it from general search or retrieval 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 explicitly says 'Use when the record is too big to cram into the prompt' and explains that it returns top-N passages with offsets. It also pairs with ask_pipeworx_grounded for grounding. No explicit when-not or alternatives, but the context is clear.

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

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

Discloses key behavioral traits: idempotentHint from annotations is consistent with 'create' semantics. Adds context about delivery limits (10 SMS/day), webhook auto-disable after 10 failures, and verification requirements for phone. 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 a single dense paragraph, which packs a lot of information. Every sentence adds value, but it could benefit from bullet points or section breaks for readability. Still, front-loading with the purpose is good.

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 (3 params, nested objects, no output schema), the description covers all necessary aspects: requirements, supported types with examples, delivery options with limits and verification, and return value. It is self-contained and leaves no major 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?

Even though schema coverage is 100%, the description adds substantial meaning: concrete examples for each type's params (e.g., sec_8k items codes, polymarket_edge topics) and detailed delivery channel behavior including webhook HMAC signing. This goes well beyond the schema's basic 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 starts with 'Create a proactive monitoring subscription to a live-data event stream'—a specific verb+resource combo. It clearly distinguishes from sibling tools like 'list_subscriptions' and 'unsubscribe' by focusing on creation.

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 that a Pipeworx OAuth account is required and that anonymous/BYO cannot persist subscriptions. Provides examples for each subscription type and delivery channel. However, it doesn't explicitly advise against using this tool vs. alternatives like 'recent_alerts' for simple polling.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds behavioral context: it returns 'category-bucketed example questions' with 'exact tool + argument shape', drawn from the live catalog, and that calling with no arguments gives a full spread. No contradictions.

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 front-loaded with example queries and uses bullet-like structure (categories in parentheses). Every sentence adds value, though it could be slightly more concise without losing 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?

Despite no output schema, the description fully explains what the tool returns: category-bucketed example questions with tool and argument shapes. It covers the onboarding use case and how to focus via topic, making it 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 100% with a clear description of the topic parameter. The description adds meaning beyond the schema by listing example topic values and explaining that omitting yields a cross-category spread, which is useful for an agent.

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

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

The description states the tool returns category-bucketed example questions for what to ask Pipeworx, listing specific categories. It clearly identifies the verb-resource 'returns example questions' and distinguishes from sibling tools like ask_pipeworx by positioning it as an onboarding entry point.

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 says 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' It also explains when to omit the topic argument for a full spread or pass a specific topic to focus, providing clear decision criteria.

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?

Discloses that the row is deactivated not deleted, and historical events remain available via recent_alerts. Annotations already indicate non-destructive and idempotent, so description adds valuable context without contradiction.

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

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

Two succinct sentences front-loaded with core action, followed by key constraints and behavior. 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?

For a simple one-parameter tool with complete annotations and no output schema, the description fully covers purpose, usage condition, and behavioral side-effect. 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 coverage is 100% for the single parameter 'id'. Description adds no extra meaning beyond the schema's own description, meeting baseline for high coverage.

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

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

Clearly states 'Cancel a subscription by id'. Verb and resource are specific. Distinguishes from sibling 'subscribe' and 'list_subscriptions'.

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 ownership enforcement: 'you can only cancel your own subscriptions'. Provides clear usage condition but doesn't explicitly mention alternative tools for other cases.

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 far beyond the readOnlyHint and idempotentHint annotations by disclosing nuanced behavior: the distinction between 'could_not_verify' (verification did not happen, not evidence) and 'unsupported' (no source exists), the two routing paths, the return format with citations, and the tolerance math. This is critical behavioral context that the annotations do not provide, and it is consistent with the annotations.

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

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

The description is longer than average but well-structured: it leads with natural-language triggers, then explains the purpose, routing, output, and a clearly flagged 'IMPORTANT' caller note. Every sentence adds value, and the formatting (dashes, capitalization) improves scannability. It could be trimmed slightly, but it is not bloated.

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?

Since there is no output schema, the description fully specifies the return value: verdict types, actual value with citation, reasoning, and the meaning of two ambiguous verdicts. It also explains the two execution paths and covers the tool's scope. For a complex verification tool with nuanced outcomes, this is highly 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 coverage is 100%, so the baseline is 3. The description does not add extra meaning beyond the schema; it mentions 'exact percent-delta math' and 'tolerance implied by the claim wording' which are already captured in the parameter descriptions. The schema itself fully documents both parameters, so no additional semantics are 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 clearly states the tool's function: 'natural-language claim verification against authoritative sources.' It names specific verbs ('verify', 'confirm or refute', 'true or false') and the resource (claims), plus distinguishes two distinct processing paths (SEC EDGAR for company-financial claims, grounded pipeline for all others). This is a specific, actionable purpose that stands apart from generic research 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 explicitly says 'Use whenever the agent needs to check whether something a user said is factually correct,' providing a clear trigger. It also explains routing for different claim types and notes that it 'Replaces 4–6 sequential calls,' implying efficiency. However, it does not explicitly name alternative tools to use instead for different scenarios, so it lacks the when-not-to-use exclusions that would earn a 5.

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