Hawaii Vehicle Registrations

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

Beyond annotations (readOnly, idempotent, openWorld), the description adds that the default model is free, Anthropic requires BYO key, and details the return 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?

The description is concise with three sentences, front-loading the main action and using no filler. Every sentence adds value.

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

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

Given no output schema, the description adequately describes return values (per-model object with fields) and provides complete usage context 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%, but the description adds context beyond the schema: default model, BYO key for Anthropic, and entity examples. This enhances 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 the tool probes LLMs for AI visibility of a business/brand/topic and returns a score. It distinguishes from sibling tools by focusing on visibility scoring for marketing audits.

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 specifies use cases: 'AI-marketing audits, pre-launch brand checks, competitive monitoring.' It does not explicitly mention when not to use or name alternatives, but provides clear 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?

The description explains that the tool routes the question, fills arguments, and returns structured answers with stable pipeworx:// citation URIs, adding useful behavioral context beyond the readOnly/idempotent annotations. It does not contradict annotations, and no side effects are claimed.

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

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

The description is front-loaded with the most important guidance and includes useful examples, but it has some redundancy ('PREFER OVER WEB SEARCH' vs. 'even if web search could also answer it') and a slightly tacked-on closing phrase.

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

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

For a single-required-parameter tool with no output schema, the description is complete enough: it explains input type, routing behavior, source coverage, and citation output. It could be more complete by naming sibling variants and when to prefer them.

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

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

Schema description coverage is 100% and the description does not add substantial parameter meaning beyond what the schema states: question is a natural-language query. The examples in the description illustrate phrasing but are largely redundant with the input schema examples.

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

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

The description clearly identifies the tool as a factual question-answering router that queries 5,908 tools across 1,540 verified sources and returns cited answers. It is specific about verb and resource and contrasts with web search, but it does not differentiate among sibling Pipeworx variants such as 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 triggers ('what is', 'look up', 'find', 'get the latest'), example queries, and instructs 'PREFER OVER WEB SEARCH' and 'START HERE for most questions.' It lacks explicit when-not-to-use guidance for sibling alternatives, so it stops 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?

Beyond readOnly/openWorld/idempotent annotations, the description discloses that candidate routing improvements may be live, that none is active now, that results are compared against the stable router, and that it is a full working router with no fallback. This is rich behavioral context that annotations alone would not 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?

The description is a bit longer than minimal, but every sentence earns its place: it establishes identity, explains experimentation status, gives usage instructions, and resolves ambiguity about fallback. It is front-loaded with the core 'beta version of ask_pipeworx' identity.

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 single-required-parameter router with no output schema, the description provides the critical operational context: what it is, current state, how to use it, and safety profile. Missing details about the actual response shape are mitigated by stating it matches ask_pipeworx exactly, though that shape is not described.

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

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

Schema coverage is 100% and the schema already documents the question parameter plus aliases. The description mentions 'same arguments' but adds no meaningful parameter-level semantics beyond what the schema already provides, 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 states a specific subject and role: a beta version of ask_pipeworx that is an identical universal router with the same 5,908 tools, arguments, and response shape. It also distinguishes itself from the stable ask_pipeworx by noting experimental candidate routing, so an agent can tell them apart.

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 to use it exactly like ask_pipeworx when wanting the newest routing, and clarifies current behavior matches the stable router. It does not give explicit exclusionary guidance or compare against ask_pipeworx_grounded, but the primary use condition 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?

Beyond the readOnlyHint and idempotentHint annotations, the description discloses the extra LLM call cost, the strict extraction-only behavior, and the full refusal_reason contract. It also describes what happens when data doesn't directly answer the question, which is valuable behavioral context the annotations do not 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?

The description is information-dense but well-organized, leading with the core value proposition, then the return/refusal contract, then usage guidance and cost tradeoff. Every sentence contributes meaningful information, and there is no filler.

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

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

For a tool with no output schema, the description fully specifies the success and refusal return shapes, the conditions triggering each refusal reason, usage context, and cost tradeoffs. The input side is covered by the schema. An agent has everything needed to select and invoke 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 description coverage is 100%, with all six parameters documented as aliases for the single required 'question' parameter. The description doesn't need to add much here, and it doesn't, so the baseline of 3 is appropriate.

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

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

The description clearly identifies this as a hallucination-resistant answer mode for high-stakes reads, and explicitly contrasts it with ask_pipeworx while sharing the same tool routing. The verb 'extracts' and the refusal contract make it easy to understand what the tool does and how it differs from its sibling.

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

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

The description gives explicit guidance on when to use this tool: whenever an answer will be quoted, cited, or acted on and the agent must not invent facts. It also explicitly tells the agent to prefer ask_pipeworx for casual lookups, which is clear and actionable.

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 extensively covers behavioral traits beyond annotations: low-confidence match short-circuit, closed market handling, wide-spread tradeability flag, cancellation rule parsing, and news fallback mechanisms. Annotations indicate read-only, idempotent, open-world, non-destructive – all consistent.

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

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

The description is very long (multiple paragraphs) and front-loads the main purpose, but then dives into extensive details (classifiers, fan-out examples, response shapes, resolver contract, parent event extractor, news fields, safety, wide spread, cancellation rule). While well-structured, it could be more concise by referencing more detailed documentation.

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 (multiple data sources, classifiers, error states, cancellation rules) and no output schema, the description provides exhaustive coverage. It explains response fields, edge cases, and how to trust results. Almost every aspect an agent would need is addressed.

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 value: explains market parameter accepts slug, URL, or question text; depth parameter quick vs thorough; include_raw default and when to use. Examples provided in schema also supplement.

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 explicitly states the tool researches a Polymarket bet by pulling Pipeworx data, covering multiple input formats (slug, URL, question text). It distinguishes itself from siblings like polymarket_arbitrage and polymarket_edges by focusing on single-market research with evidence fan-out.

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

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

Provides clear usage examples: 'should I bet on X', 'what does the data say about Y', 'is there edge in Z'. Also details fan-out examples for different bet types. However, it does not explicitly state when not to use this tool vs alternatives, though the sibling context helps.

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, openWorldHint, idempotentHint, destructiveHint), the description details exactly what data is pulled per type: latest 10-K financials for companies (with off-calendar FY handling) and FAERS/FDA/trials for drugs. It also mentions result sorting and citation URIs, providing full disclosure of behavior.

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 that effectively front-loads the purpose with examples. It conveys a lot of information without verbosity, though it could be slightly more structured (e.g., separate sections for company vs drug).

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?

Without an output schema, the description explains what is returned (paired data + pipeworx:// citation URIs) and the efficiency gain (replaces 8-15 lookups). It covers key aspects but could optionally mention pagination or sorting details more explicitly.

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 the schema covers all parameters, the description adds meaning by explaining that 'values' expects tickers/CIKs for company and drug names, and specifies the 2-5 range. It also clarifies that the 'type' parameter determines the data source, adding value beyond the enum description.

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

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

The description starts with clear example queries and states 'side-by-side comparison of 2–5 companies or drugs in ONE parallel call.' It explicitly distinguishes from sequential single-pack lookups, making the tool's purpose unmistakable and setting it apart 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 provides explicit guidance to 'ALWAYS PREFER over sequential single-pack lookups when comparing entities' and gives example queries (compare, rank, head-to-head). It does not explicitly state when not to use it, but the context implies it is for comparisons of 2-5 entities, leaving some ambiguity.

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

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

Even though annotations already declare read-only, open-world, and idempotent behavior, the description adds substantial context beyond those hints: what the findings packet contains, how gaps[] and contradictions[] behave, the latency profile, that citations are only returned when resolvable, and that it never invents answers. This goes well beyond the annotation surface and helps an agent set expectations correctly.

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 it is well-structured and front-loaded with the most decision-critical information: account requirement, alternative tool, and what the tool is not. Every substantial block adds a distinct behavioral fact, though a slightly tighter organization would reduce cognitive load for an agent scanning for invocation rules.

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 correctly carries the burden of explaining return values: findings, evidence quotes, confidence, source, fetched_at, citation_uri, gaps[], and contradictions[]. It also covers prerequisites, latency, depth semantics, and alternative routing, making it complete for a complex tool with only two parameters.

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

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

Schema description coverage is 100%, and the input schema already explains both `question` and the depth enum in detail. The description reinforces depth behavior (gaps, contradictions, latency) but largely restates what the schema already captures, with only marginal extra context like the explicit quick/standard/thorough distinction and paid-plan constraint.

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

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

The description states a specific verb and resource: it performs grounded multi-source research over Pipeworx's structured data sources in one call. It explicitly contrasts itself with open-web search and names the key sibling alternative (ask_pipeworx), so an agent can tell them apart without inspecting either tool's schema.

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

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

It gives explicit when-to-use guidance: best for broad/multi-part questions over structured data, and explicitly says to use ask_pipeworx instead for single lookups or when not signed in. It also explains the depth-level selection and the account/plan gate, leaving little to inference.

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

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

Annotations already declare safe operations (readOnlyHint, idempotentHint, destructiveHint false). Description adds valuable context: returns top-N tools with full schemas ready to call, enhancing behavioral understanding 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?

Description is front-loaded with purpose, contains multiple sentences each adding value (purpose, domains, output, usage). Slightly verbose but justified by the tool's meta nature.

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 provided, but description fully explains return format (tools with schemas, ready to call) and usage context (call first). Complete for a discovery 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. Description repeats alias information but does not add significant new meaning beyond the schema's own parameter descriptions.

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

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

The description uses specific verb 'find' and resource 'tools', and lists many domain examples. It clearly distinguishes from sibling tools by being the discovery tool, while siblings are application-specific 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?

Explicitly states 'Call this FIRST when you have many tools available' and describes use cases (browse, search, look up). Does not mention when not to use, 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 readOnly, idempotent, openWorld, and non-destructive. Beyond that, the description adds substantial behavioral detail: it fans out across multiple sources, reports sources_used and sources_failed, treats empty sections as real no-data, soft-fails patents, uses a GDELT-to-GNews fallback, and explains resolved:false behavior for private companies.

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 user intent examples and a clear primary statement, but it is a long, dense single paragraph with some redundancy between the examples and the schema text. The length is largely justified by the tool's complexity, though tighter structure would improve scannability.

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?

Even with no output schema, the description explains returned fields, source fallback behavior, failure semantics, URI formats for filings, and input edge cases. An agent has enough context to select and invoke the tool correctly and interpret partial or empty results.

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

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

The input schema already covers both parameters thoroughly with examples and 100% coverage. The description adds extra value by clarifying that type accepts company or ticker interchangeably, that names resolve via SEC EDGAR, and that private companies yield resolved:false with an explicit notes line rather than a bare failure.

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

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

The description states a specific verb and resource: it produces a full cross-source profile of a US public company in one parallel call. It is also differentiated from single-pack SEC/XBRL/news lookups, so an agent can clearly tell it apart from more narrow 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 to prefer this tool over chaining single-pack lookups when the user asks for a holistic view, and gives concrete trigger examples. It also sets boundaries by scoping to US public companies and noting that private companies return resolved:false, plus person/place support as not yet available.

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 destructiveHint=true and idempotentHint=true, covering safety and idempotency. The description adds context about the tool's purpose (clearing stale or sensitive data) without contradicting annotations. No additional behavioral details beyond annotations are provided, but the combination is sufficient.

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: first specifies purpose, second provides usage guidance and links to siblings. No wasted words; information is front-loaded and efficiently presented.

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 single-parameter tool with clear annotations and no output schema, the description covers purpose and usage context completely. No gaps remain for an agent to misinterpret.

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 one parameter. The parameter description 'Memory key to delete' adds some meaning beyond the schema's basic type, but it does not significantly enrich the agent's understanding. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states 'Delete a previously stored memory by key', using a specific verb (delete) and resource (memory by key). It distinguishes itself from sibling tools 'remember' and 'recall' by explicitly naming them.

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

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

The description provides explicit guidance: 'Use when context is stale, the task is done, or you want to clear sensitive data the agent saved earlier.' It also suggests pairing with related tools, giving clear context on when to use this tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. Description adds significant context: fetches the page, extracts title/description/key links, emits standard markdown format, and outputs a single text blob ready for deployment. 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?

Two sentences with bullet points; front-loaded with main action, followed by use cases. Every sentence is informative with no fluff.

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

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

Given rich annotations and full schema coverage, description is complete. It explains output format ('single text blob') despite no output schema, and covers use cases adequately.

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 does not add extra meaning beyond the schema (e.g., default and max for max_links are already in schema description). No additional value provided.

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

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

Description clearly states the tool generates an llms.txt file for a URL, specifying the verb 'generate' and the resource 'llms.txt for any URL'. It distinguishes itself from sibling tools by being highly specific to this task, with no overlap observed.

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: indexing a client's site, drafting for own project, or auditing competitor. It does not explicitly state when not to use or compare to alternatives, but the specificity makes usage 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?

The description adds significant behavioral context beyond annotations: it explains data source (Hawaii DBEDT), registration administration (four counties), and that figures are cumulative statewide. 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 a single paragraph with front-loaded main function and example questions. It is slightly verbose due to listing multiple questions, but still efficient and well-organized.

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 details the returned data (time series, separate and combined counts, YoY change, growth rate) and data provenance (state level, DBEDT, four counties). Complete for the tool's complexity.

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

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

Schema coverage is 100%, and the description largely repeats schema info (year format, optional, limit default). It adds context about 'newest first' but does not substantially enhance parameter understanding beyond what the input schema already provides.

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

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

The description clearly states the tool counts electric and hybrid vehicles in Hawaii as an annual time series, with specific components (battery-electric, hybrid, combined total, YoY change, growth rate). It lists example questions, making the purpose unmistakable and distinct from sibling tools.

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

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

The description provides explicit example questions to guide usage, but does not explicitly state when NOT to use it or suggest alternatives. However, the tool is niche enough that the usage context is clear from the examples.

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 value by listing return fields and noting that it returns active subscriptions by default, which is 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?

Two sentences: one for functionality and return fields, one for usage guidance. No unnecessary words, well-structured.

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

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

For a simple list tool with no required params and rich annotations, the description covers purpose, return fields, and usage. Missing details like pagination or error handling, but still adequate given 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% (include_inactive description in schema). The description does not add meaning beyond the schema; it only implies the default behavior. 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 it lists the caller's active subscriptions and specifies the returned fields (id, type, params, created_at, last_fired_at, fire_count). This distinguishes 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 explicitly says 'Use this to review what you're monitoring before adding more or to find an id to cancel,' providing clear when-to-use guidance and implying when not to use (e.g., not for creation or modification).

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 annotations (all false flags), the description discloses rate limiting (5 per identifier per day), the claim_token workflow for checking resolution status, cost/free nature, no impact on tool-call quota, and daily review / roadmap influence. 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, well-structured paragraph that front-loads purpose, then covers usage, exclusions, operational details, and constraints. It is thorough and mostly non-redundant; only the claim_token detail overlaps with the schema, preventing a perfect score.

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

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

Given the tool's nuanced routing and absence of an output schema, the description is remarkably complete. It covers when to use, when not, how to phrase feedback, the claim_token workflow, rate limits, and quota impact, leaving no practical gap 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?

Input schema coverage is 100% with detailed per-parameter descriptions, so the baseline is met. The description's claim_token explanation largely mirrors the schema's own semantics and adds little new information about the other parameters beyond what the schema already provides.

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

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

The description opens with a clear imperative — 'Tell the Pipeworx team something is broken, missing, or needs to exist' — and specifies the exact resource and action. It distinguishes the tool from siblings by explicitly limiting it to tools served by this Pipeworx connection.

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 positive triggers ('Use when a tool returns wrong/stale data... feature/data_gap... praise') and a clear negative exclusion for tools from other MCP servers. It also gives practical guidance on identifying Pipeworx tools and avoiding user-prompt content.

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?

Given annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false, the description adds valuable context: it is self-aggregating, derived from CF analytics-engine, contains no PII, and is cached 5min-1h. This goes beyond the 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 front-loaded with the core functionality in the first sentence, followed by bullet-point use cases and technical details. It is concise without being terse, though could potentially shorten the use-case list without losing 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?

Despite lacking an output schema, the description explains the return format (top tools, top packs, total call volume, with tuple (pack, tool, count)) and caching behavior. This provides sufficient context for an agent to understand what the tool returns and its freshness characteristics.

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 description for the 'window' parameter. The description adds semantic guidance on window choice ('hot right now' vs 'steady-state demand'), which helps the agent select the appropriate value beyond the enum options.

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 returns 'top tools, top packs, and total call volume' over a recent window, using a specific verb ('Returns') and resource ('Pipeworx trending data'). It distinguishes from sibling tools like 'discover_tools' by focusing on trending aggregates rather than listing all 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 lists three explicit use cases (discovering hot data sources, confirming canonical choice, checking alignment). It also explains window selection trade-offs ('Shorter windows surface what's hot right now; longer windows show steady-state demand'). However, it does not explicitly state when not to use the tool or suggest alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint true and destructiveHint false. The description adds rich behavioral context: internal checks (semantic anchor with Jaccard threshold, partition filter for placeholders, fill check against CLOB depth), explanation of output signals, and warning about overround only at last trade. 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 well-structured with clear sections separated by periods and capital letters. It is comprehensive but slightly verbose; however, every sentence adds value. It could be tightened slightly 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 the response structure (opportunities[], partition_check, fill check results) and mentions fallback to polymarket_fill_risk. It covers modes, algorithms, filters, and edge cases. The tool's complexity is high, but the description addresses all relevant aspects.

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?

Input schema has 2 parameters with 100% description coverage. The description adds significant meaning beyond the schema: explains the mode each parameter triggers, provides example values (slugs, URLs, seed questions), and states recommendations (event recommended for specific market). It clarifies the scope and behavior of each 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 finds arbitrage opportunities via monotonicity violations and partition-sum checks. It distinguishes the three modes: no args for trending scan, event mode for specific market, topic mode for cross-event scanning. The verb 'find' and resource 'arbitrage opportunities on Polymarket' are specific and differentiate it from siblings like polymarket_edges or 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 on when to use each mode: no args for trending scan, event for specific market (recommended), topic for cross-event. It also explains when not to trade (realizable edge ≤ 0 after fill check) and refers to polymarket_fill_risk for custom sizing, providing an alternative.

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 declare readOnlyHint, openWorldHint, idempotentHint, and no destructiveness. The description adds extensive behavioral context: caching policy, detailed model families, output structure, diagnostic information for empty segments, and edge case handling (Fed bets disclaimer). 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 long but well-organized, front-loading the purpose and then detailing the three segments, knobs, and diagnostics. Every sentence adds value, though some detail could be trimmed for even better conciseness.

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

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

The description explains the full response structure (by_segment, fed_candidates, _diagnostics), covers why segments might be empty, and addresses edge cases like Fed bet unreliability. No output schema exists, so the description fully compensates.

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

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

Schema coverage is 100% with descriptions for all 9 parameters. The description adds value by explaining parameter interactions (e.g., min_partition_leg_kelly with partition arbs, slippage_pp with Polymarket liquidity) and providing default values and context 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 scans top Polymarket markets to find opportunities where Pipeworx data disagrees with market price, specifically for 'what should I bet on today'. It distinguishes itself from siblings like polymarket_arbitrage by focusing on model-driven and structural arbitrage opportunities from Pipeworx data.

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

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

The description implies usage for discovering daily betting opportunities without paging, but does not explicitly state when not to use this tool or mention alternatives like polymarket_arbitrage or polymarket_edge_tracker. No guidance on when to choose 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?

The description thoroughly explains behavioral traits beyond annotations: it reads snapshots, returns tracked/expired data with time-series, notes snapshot generation on cache-miss, gaps meaning no scan, 60-day TTL, and decay from daily closes. 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 dense but well-structured: purpose first, then response format details, then limitations. Every sentence adds value, though it could be slightly more 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 no output schema, the description fully explains the response structure (tracked[], expired[], snapshot_dates[]) and field meanings. It covers parameter usage, response format, and caveats like TTL and decay computation, making it complete for the tool's complexity.

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

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

Schema coverage is 100%, but the description adds meaningful context: default values (14, '1wk'), clamping for days (2-30), and clarifies 'window' as snapshot family. This enriches understanding beyond schema 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 clearly states the tool's purpose: edge persistence and decay telemetry from daily snapshots. It answers a specific question about edge age and shrinkage, distinguishing it from the sibling tool 'polymarket_edges' which likely provides current edges without history.

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

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

The description implies when to use this tool (for historical persistence) vs. alternatives (current edges from polymarket_edges), but does not explicitly state exclusions or provide direct comparisons with 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?

Despite annotations providing readOnlyHint, the description adds significant behavioral context: explains parameter requirements, ladder walking for single-market, per-leg fill details for baskets, identification of thin legs, and risk of forced directional exposure. 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 well-structured with sections (REQUIRES, SINGLE-MARKET, BASKET) and uses all-caps for emphasis. It is relatively long but every sentence adds value. Could be slightly more concise 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 (two modes, multiple return fields), the description covers all necessary details: parameter combinations, return values (listed explicitly), and risk warnings. No output schema exists, so the description must explain return values, which it does thoroughly.

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

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

Schema_description_coverage is 100%, so baseline is 3. The description adds extra meaning beyond schema descriptions by explaining mode selection logic, default behaviors (e.g., auto side for basket), and interpretation of size_usd for buys vs sells. This is a meaningful enhancement.

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 specifies two modes (single-market and basket) and distinguishes itself from sibling tools like polymarket_arbitrage by being a prerequisite risk check.

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: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' Also explains the consequences of not using it (partial basket fills converting arbs into directional positions).

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

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

Annotations already mark the tool read-only/idempotent, and the description adds substantial non-obvious behavior: compatibility codes can be non-empty even with matched_pairs>0, pairing_unverified is always set, legs with 'unknown' metric_type or match_subtype are never paired, temporal_alignment null means unknown rather than aligned, and spread_pp is gross because Kalshi fees are not modeled. This is exactly the kind of context beyond schema and annotations that prevents mis-invocation.

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

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

The description is long but deliberately structured with labeled sections (TWO MODES, RESPONSE, SAFETY FIELDS, Codes) and front-loaded with the core purpose. A few points are repeated across sections, but given the number of safety flags and edge-case meanings, almost 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?

With no output schema, the description must carry return-value semantics, and it does: top_spreads_pp, flags[], skipped_unclassified, low_confidence_pairs[], temporal_alignment{}, fees_note, and skipped counters are all defined. The caveats about unverified pairing, temporal_mismatch, and gross-vs-net spread make it safe for an agent to interpret results without guessing.

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

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

The schema already covers all three parameters with descriptions and examples (coverage 100%), so the baseline is 3. The description adds meaningful semantics: topic is a shortcut that auto-fetches the mapped event, explicit ticker/slug override the mapped side, and both modes run the identical token-overlap matcher with the same disclosures, taking it to 4.

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 resource and output clearly—'Cross-venue spread between Kalshi and Polymarket for the same resolving question'—and enumerates concrete modes, so a caller knows what the tool does. It stops short of an explicit action verb and never names a sibling contrast like polymarket_arbitrage, so it is clear but not maximally differentiated.

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

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

It gives explicit mode-selection guidance: use one of the 10 pre-mapped topic shortcuts, or supply kalshi_event_ticker + polymarket_event_slug for custom pairings, and both modes run the same matcher. It also warns that most pre-mapped topics currently return compatibility_warning and that 'pre-mapped ≠ tradeable.' It does not explicitly say when to prefer this tool over sibling tools, which keeps it a notch below 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, idempotentHint=true, destructiveHint=false. The description adds scoping (by identifier) and listing behavior (omit key), which complements annotations 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?

The description is concise (three sentences), front-loads the action, and every sentence adds value. No extraneous 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 rich annotations, simple schema (1 optional param), and no output schema, the description provides sufficient context: purpose, usage scenario, scoping, and sibling relationships.

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 the single parameter with 100% coverage, but the description adds the crucial behavior that omitting the key lists all keys, which is not evident from the schema alone.

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 ('Retrieve' or 'list') and resource ('value previously saved via remember' or 'all saved keys'). It distinguishes from siblings like 'remember' and 'forget' by explicitly referencing them.

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

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

It explains when to use ('look up context the agent stored earlier') and provides context (scoped to identifier, pairs with remember/forget). However, it lacks explicit when-not-to-use guidance or alternatives beyond 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?

The description states that setting mark_read:true flags events as read, which is a write side effect. However, annotations include readOnlyHint: true, which implies no data modification. This is a direct contradiction between description and annotations.

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

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

The description is concise (4 sentences), front-loaded with purpose, and each sentence adds value: purpose, return fields, filtering, mark_read behavior, polling guidance, and alternative endpoint.

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 the contradiction, the description thoroughly explains the tool's functionality: return format, filter parameters, side effects, and usage guidance (polls, alternative endpoint). It is complete for a read-heavy tool with no output schema.

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

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

Schema coverage is 100% with parameter descriptions. The description adds context for type (example 'sec_8k'), since (ISO timestamp), and mark_read behavior, but does not mention the unread_only parameter. It adds some value beyond schema but not all 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 clearly states the tool pulls fired events from subscription feed, describes return fields (source, citation_uri, payload), and explains filtering options. The verb 'Pull' is specific and the resource is well-defined.

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 mentions that polls work fine and provides an alternative HTTP endpoint for scripts/dashboards, giving some context on when to use this tool vs. the direct API. However, it does not explicitly differentiate from sibling tools like list_subscriptions or subscribe.

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. The description adds substantial behavioral context: fan-out to SEC EDGAR, GDELT→GNews fallback, USPTO soft-failure, return structure, and citation URIs. 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 informative and well-structured with examples and bullet-like clauses, but it is slightly verbose. Every sentence adds value, though it could be tightened without losing 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?

The tool has no output schema, so the description fully covers the return structure (changes[], total_changes, citation URIs), fallback behavior, and soft-fail. Given the complexity (multiple sources, three parameters), the description is 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% with each parameter having a description. The description adds further clarity on 'since' (examples of ISO and relative formats) and 'value' (ticker or CIK), going beyond the schema alone.

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 a change feed for a company in a recent time window, fanning out to multiple sources. It distinguishes itself from the sibling 'entity_profile' by explicitly stating when to use that tool instead.

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 example queries that indicate appropriate use cases and directly contrasts with 'entity_profile' for static profiles. However, it does not explicitly list scenarios where the tool should not be used besides that alternative.

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 idempotent and non-destructive. Description adds context about persistence (24-hour vs permanent) and scoping. No contradictions, but annotations already provide safety info.

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 all valuable. Front-loaded with purpose. No wasted words; appropriate 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?

Covers persistence, scoping, pairing with other tools. No output schema needed; description provides complete context for 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 descriptions already cover key and value with examples. Description reinforces examples but adds little beyond schema given 100% 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?

Description clearly states 'Save data the agent will need to reuse later' and specifies scoping by identifier. It distinguishes from siblings recall and forget, showing clear purpose.

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

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

Explicitly says when to use: 'when you discover something worth carrying forward' with concrete examples. Mentions alternatives (recall, forget) but does not explicitly say when not to use.

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 (read-only, idempotent, open-world), the description discloses important runtime behavior: it 'asserts nothing' when multiple instruments match and returns figi_candidates, it reports unresolved identifiers explicitly under unresolved, LEI/FIGI enrichment 'degrades gracefully' if upstream sources are unavailable, and it cascades through multiple internal endpoints. This substantially enriches what annotations alone would 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 dense and front-loaded with trigger examples and the core rule, and every clause carries operational meaning. It is, however, long and heavily parenthetical, which slightly hurts skimmability even though the content is valuable and well organized by supported type.

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 carries the burden of explaining results, and it does so thoroughly: it names figi_candidates, unresolved, source labels, per-type drug returns, and degradation behavior. An agent has enough to decide when to call it and what to expect back.

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%, the description adds a great deal of practical meaning: concrete examples (AAPL, 0000320193, ozempic), per-type behavior for company vs drug, the exact 'ENTITY NAME ONLY' rule, and the bond-specific warning about trailing security-class words. This goes far beyond the schema's terse property 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 a specific verb and resource: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' It also enumerates the exact supported entity types (company, drug) and the identifier families returned, making it clearly distinguishable from lookalike siblings like entity_profile or validate_claim.

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 strong when-to-use guidance: 'Use FIRST whenever you have a name but need an ID' and notes that it 'replaces 2-3 manual lookups.' It does not, however, explicitly state when not to use it or name a concrete alternative tool for different needs, so it stops short of a full exclusions/alternatives treatment.

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

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

The description adds behavioral context beyond annotations: it explains that the tool probes each entity with ai_visibility_check, aggregates results, and returns a ranked list. Annotations already declare idempotent/read-only, but the description clarifies the multi-probe behavior.

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, each packed with information. No filler words. Front-loaded with the core purpose, then details. Very 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 explains the return format (ranked list with score, confidence, signal density). Combined with annotations and schema, this provides complete information for a comparison 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%, but the description adds meaning by noting that the first entity is treated as the 'subject' for narrative. This nuance is not in the schema description. Models and context explanations match 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 compares AI visibility across multiple entities side-by-side, using specific verbs like 'probes' and 'ranks'. It distinguishes itself from sibling tools like ai_visibility_check (single entity) by emphasizing comparison.

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 ('useful for competitive AI-marketing audits') and implies when to use (multiple entities). It does not explicitly state when not to use or give alternatives, but the purpose is clear enough to avoid misuse.

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

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

Adds details beyond readOnly/ idempotent annotations: explains partial failures, bundlephobia first-measurement delay (5-30s), and that sources_failed will list timeouts. 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?

Packed with useful info, front-loaded with main purpose. Slightly long but every sentence earns its place. Could be trimmed slightly but remains clear.

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 fully explains return content (summary block, advisories, links, alternatives). Covers ecosystem scope, partial failures, and services used – complete for effective use.

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

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

Schema has 100% description coverage. Description adds extra context: scoped packages accepted, version defaults to latest. This meaningfully enhances 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 is a composite check for npm packages, combining deps.dev and bundlephobia data. It specifies the verb 'scan' and resource 'dependency', and distinguishes from siblings by limiting to npm ecosystem.

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 asked about safety, popularity, size, or cost of adding a package. Also states when not to use: only npm ecosystem in v1, with fallback tools mentioned.

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

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

Annotations already indicate the tool is read-only, idempotent, and non-destructive. The description adds specific behavioral details: uses BGE-base-en embeddings with cosine similarity over 500-char overlapping windows, a 200K char cap with truncation and flagging, and returns passages with offsets and scores. 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 about 100 words, front-loaded with the core purpose, and each sentence adds essential information. 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?

No output schema, but the description details the return format (passages with offsets and similarity scores), explains the embedding and windowing approach, and specifies input limits. This is comprehensive for a 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 coverage is 100%, so baseline is 3. The description enhances understanding by explaining the text parameter as something the agent already pulled, giving natural-language query examples, and clarifying the limit's range. This 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 that the tool performs semantic search inside a fetched record, distinguishing it from siblings like ask_pipeworx by specifying it is for large records that are too big to fit in the prompt. Examples of use cases are provided.

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 tells when to use this tool: 'when the record is too big to cram into the prompt.' It also pairs it with ask_pipeworx_grounded for grounding over passages, providing clear alternatives and 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 indicate readOnlyHint=false, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds behavioral context beyond annotations: requires OAuth, type-specific filters, delivery channels with limitations (10/day SMS cap, email verification). It does not contradict annotations but does not explicitly address idempotency.

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 quite long but front-loaded with the main purpose. Each sentence adds necessary detail (e.g., account requirements, types, delivery channels). Slightly verbose but well-structured and informative.

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

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

Given the complexity (3 params, nested objects, no output schema), the description is fairly complete. It explains the return value, covers all supported types and delivery channels, and includes constraints. However, it could mention error conditions or idempotency semantics for 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 coverage is 100%, and the description adds significant meaning beyond the schema. For each parameter, it provides concrete examples (e.g., sec_8k items, polymarket_edge topic, delivery validation) and constraints (e.g., phone must be verified, webhook auto-disabled).

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 creates a proactive monitoring subscription to a live-data event stream and returns the subscription id. It specifies the verb (Create) and resource (subscription), and distinguishes from siblings like list_subscriptions 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 explicitly mentions the requirement for a Pipeworx OAuth account and provides examples of supported types and their parameters. However, it does not explicitly state when not to use this tool (e.g., for listing or removing subscriptions), though context from siblings implies 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 indicate read-only, idempotent, non-destructive behavior. Description adds that it draws from a live catalog and returns structured examples. 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 fairly long but front-loaded with the core purpose. All sentences add value, though some colloquial phrases could be tightened. No 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?

Despite no output schema, the description fully explains return structure (category-bucketed example questions with tool+argument shapes). Parameter count is low, annotations are rich, and the description covers all needed aspects for this onboarding 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 has 100% coverage with descriptions. Description adds meaning by listing allowed topics and explaining default behavior (full spread) versus focused. This goes beyond the bare schema.

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

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

The description clearly states the tool's purpose: returns category-bucketed example questions with tool+argument shapes for new users. It distinguishes itself from siblings as the first tool to use for onboarding.

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 to use this FIRST when unsure about Pipeworx's capabilities. Provides guidance on calling with or without the topic parameter. However, it does not explicitly list when not to use this tool or give negative examples.

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 annotations ('destructiveHint': false, 'idempotentHint': true), the description adds critical behavioral detail: 'The row is deactivated (not deleted) so its historical events stay available via recent_alerts.' This clarifies the exact side effect and historical data retention.

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 that front-load the action and key constraints. No extraneous words; every sentence adds value.

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

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

For a tool with one required parameter, no output schema, and moderate annotations, the description fully covers the operation's purpose, ownership restriction, and side effect (deactivation vs deletion). No gaps remain.

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 single parameter 'id' is fully documented in the input schema with description 'Subscription id (uuid) returned by subscribe.' The description does not add further semantic meaning beyond referencing the sibling tool, which is sufficient given 100% schema coverage.

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

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

The description starts with a clear action verb 'Cancel' and the resource 'subscription by id'. It immediately distinguishes from siblings like 'subscribe' and 'list_subscriptions' by specifying the reverse operation.

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 an important usage condition: 'Ownership is enforced — you can only cancel your own subscriptions.' This helps the agent decide when to invoke the tool, though it does not explicitly mention when not to use it or alternatives.

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

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

The description adds significant behavioral context beyond the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint). It discloses the two-path pipeline, the meaning of each verdict type, the critical distinction between could_not_verify (check did not happen) and unsupported (no source covers it), and the warning that could_not_verify must not be used as evidence. It also notes the use of verbatim evidence and pipeworx:// citations, which are not visible in annotations or schema.

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

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

The description is long but information-dense. It is front-loaded with trigger phrases and clear purpose, then explains the pipeline, returns, and important caveats. Every sentence contributes useful guidance, such as the 'Replaces 4–6 sequential calls' note and the could_not_verify warning. While slightly verbose, the complexity of the tool justifies the length, making it appropriately sized.

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 carries the full burden of explaining return values, which it does thoroughly: verdicts, grounded/structured value, citation, and reasoning. It also explains failure modes (could_not_verify, unsupported) and the routing logic. The description is complete for the tool's complexity, covering what the tool does, when to use it, how it behaves, and what it returns.

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

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

The input schema already provides detailed descriptions for both parameters (claim with examples, tolerance_pct with range, override behavior, and defaults), and coverage is 100%. The main description adds little beyond the schema, only mentioning 'exact percent-delta math' and 'tolerance_pct' in passing. Since the schema carries the full burden, the description provides only marginal additional value, so a baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'natural-language claim verification against authoritative sources' with a specific verb and resource. It also includes trigger phrases ('fact check', 'verify the claim that…') and distinguishes itself from general Q&A by focusing on verdict-based verification and providing a verdict list. It differentiates from siblings like ask_pipeworx_grounded by emphasizing claim verification with a structured verdict and evidence.

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' and gives example phrasings. It also describes two usage paths (SEC EDGAR for company-financial claims, grounded pipeline for other claims) and mentions that it replaces 4–6 sequential calls, implying it's the one-stop tool for claim verification. It does not explicitly name sibling tools to avoid, but the guidance is clear and context-rich.

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