Carbon Intensity Uk

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

The description adds significant value beyond annotations: it explains the default model (Workers AI Llama-3.3-70b, free), the need for an API key to probe Anthropic, and the return structure (per-model fields plus combined view). Annotations already confirm readOnly, idempotent, and non-destructive behavior, so the description enriches the safety profile with operational details.

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 with three sentences. It is front-loaded with the main purpose, then covers optional behavior, return format, and use cases. No word is wasted; 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 explains the return value (per-model score, confidence, signals, raw_response + combined view). It also covers parameter behavior, default model, and Anthropic integration. For a tool with moderate complexity, this 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?

All four parameters have schema descriptions (100% coverage), and the description adds meaningful context: it explains the default model behavior for the 'models' parameter, the direct key passthrough for '_apiKey', and the disambiguation purpose of 'context'. This goes beyond what the schema alone 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 'probes one or more LLMs' about a business/brand/product/topic and returns a visibility score. It includes the specific verb 'probe', the resource (LLMs), and the output format, distinguishing it from sibling tools like ask_pipeworx or entity_profile by focusing on AI visibility scoring.

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 ('AI-marketing audits, pre-launch brand checks, competitive monitoring') and context about cost (free vs. BYO key for Anthropic). However, it does not explicitly state when not to use this tool or suggest alternative tools, leaving some room for improvement.

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

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

Annotations already state read-only, idempotent, and open-world behavior. The description adds valuable context: the tool routes to many sources, fills arguments, and returns structured answers with stable citation URIs. It does not fully disclose failure or fallback behavior, but annotations cover the main safety profile.

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

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

The most useful guidance is front-loaded with PREFER OVER WEB SEARCH and the trigger list. However, the description is verbose, includes a long overlapping category list, and ends with an awkward, partially repetitive news-routing sentence. Tighter phrasing would improve it.

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

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

For a tool that only requires one natural-language question, the description explains what happens, when to use it, what domains it covers, and what kind of result to expect via citations. It does not describe failure modes or how to route to sibling variants, but the input complexity is low and the behavioral context is rich.

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

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

Schema coverage is 100%, so all six parameters are already described as aliases of the question argument. The description provides example queries that imply the intended value, but it does not add meaningful parameter-level semantics beyond what the schema already provides.

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

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

The description clearly says the tool routes a question to one of thousands of verified tools and returns a structured, cited answer. It explicitly differentiates from web search and lists many data categories, but it does not explicitly differentiate from sibling tools like ask_pipeworx_beta or ask_pipeworx_grounded.

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

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

The description gives strong usage guidance: prefer this tool over web search for factual and current data, use it when users ask for listed phrases, and start here for most questions. It lacks explicit when-not-to-use guidance and does not describe when a sibling variant would be better.

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 it read-only, open-world, idempotent, and non-destructive. The description adds valuable behavioral detail beyond that: candidate routing toggles live only while under test, no candidate is active now, and results are compared against the stable router to decide merges. It also clarifies it does not fall back to nothing but is a full working router.

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 each sentence earns its place: it defines what beta means, states the current no-candidate state, gives usage guidance, and clarifies fallback behavior. The specific details like 5,621 tools and the example date provide useful context without bloat.

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 conveys everything an agent needs to decide whether to use the beta router and reassures that it is a real working router. It delegates exact response shape and parameters to ask_pipeworx, which is acceptable since the tool's entire contract is defined as identical to that sibling.

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

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

All parameters have schema descriptions and are clearly aliases for the question field, so the schema already provides the necessary semantics. The description says 'same arguments' as ask_pipeworx but adds no new parameter-level detail; 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 identifies the tool as a beta universal router with the same 5,621 tools, arguments, and response shape as ask_pipeworx. It distinguishes itself from the stable sibling by its experimental routing behavior, 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 the tool exactly like ask_pipeworx when the newest routing is wanted and notes the current state matches stable behavior. It does not explicitly spell out when not to use it, but the beta/experimental framing gives enough steering.

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, open-world, idempotent), the description discloses significant behavior: it only uses the tool result content, can refuse with a specific refusal_reason, returns evidence as a verbatim quote and confidence, and confirms an extra cost of one LLM call. There is no contradiction with the annotations.

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

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

The description is compact for the amount of information it carries. It leads with the core purpose, then the workflow, then the return/refusal contract, then when to use and when not to. Every phrase earns its place and there is no padding.

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 alone conveys the expected return shape, possible refusal reasons, the extra-cost trade-off, and the complementary sibling tool, among an otherwise complex trade. With a fully-documented schema and clear high-stakes context, an agent has everything needed to invoke it correctly.

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

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

The input schema covers all 6 parameters at 100%, so the description does not need to restate them. The description only mentions that arguments are 'filled' via routing, which establishes a mental model but adds no detail beyond what the schema already provides. This matches the baseline for a fully-covered 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 defines a distinct mode: grounded, hallucination-resistant answer generation, explicitly contrasted with the sibling ask_pipeworx. It names the specific behavior (routing, tool selection, argument filling, strict extraction from tool results) and the structured return/refusal format, so an agent can tell exactly what this tool is for.

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

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

It explicitly states when to use: 'whenever an answer will be quoted, cited, or acted on' and lists high-stakes domains (financial verdicts, legal claims, medical lookups, public statements). It also gives a direct exclusion: 'prefer ask_pipeworx for casual lookups', naming the alternative and the trade-off (extra LLM call).

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 extensively discloses behavioral traits beyond annotations: resolver contract, fan-out examples, response shapes, safety short-circuits, tradeability notes, resolution-rule risk. No contradiction with annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint).

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

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

Description is very long but well-structured with sections like CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES. Each sentence adds value, but length may hinder quick parsing. Could be slightly more concise while maintaining completeness.

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 covers input, output fields, edge cases, safety, resolution rules, and examples exhaustively. Very complete for a complex research 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%, baseline 3. Description adds meaning by clarifying market accepts slug, URL, or question text; depth enum explained; include_raw recommendation given. Adds value beyond schema descriptions.

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

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

The description clearly states it researches a Polymarket bet by pulling Pipeworx data, with specific verb 'Research' and resource 'bet'. It distinguishes from sibling tools like ask_pipeworx by focusing on a single bet and providing an evidence packet, and lists explicit use cases.

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

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

The description explicitly says when to use: 'should I bet on X', 'what does the data say about Y', 'is there edge in Z'. It also explains resolver contract inspection and mentions blocking routes like low_confidence_match and market_closed_or_inactive, providing comprehensive guidance on when to trust results.

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 read-only, open-world, idempotent, non-destructive. The description adds details about data sources (SEC EDGAR/XBRL, FAERS), handling of off-calendar fiscal years, and citation URIs, enriching 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?

The description is concise at 5-6 sentences, front-loaded with common trigger phrases, and each sentence adds meaningful information. Slightly long but efficient.

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

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

Given no output schema, the description explains returned data types, sorting by primary metric, and citation URIs. It adequately covers what the agent needs to understand the tool's behavior and output.

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

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

Schema coverage is 100% with both parameters described. The description adds meaning by explaining what each type returns (financials vs. adverse events) and how to specify values (tickers vs. drug names), going beyond the schema.

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

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

The description explicitly states it performs side-by-side comparison of 2–5 companies or drugs, and provides numerous trigger phrases. It clearly distinguishes from sibling tools like entity_profile by stating it replaces sequential lookups.

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 includes explicit guidance to prefer this tool over sequential single-pack lookups when comparing entities. It does not list exclusions but the directive is strong and 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 annotations (readOnly, idempotent, openWorld), the description reveals behavior such as deferred returns through gaps[], never inventing evidence, stable pipeworx:// citations, hop fields, contradiction scanning, semantic rather than head-truncated extraction, and 15-90s latency. No statement contradicts the annotations.

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

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

The description is front-loaded with the most important operational facts: required login, alternative tool, and broader structured-data research purpose. It is quite long and contains at least one repeated 'use ask_pipeworx for a single lookup' statement, which costs it a 5, but nearly every other sentence carries operational 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 two-parameter tool with no output schema, the description covers all essential invocation context: prerequisites, pricing, exact behavior, return contents, citation reliability, gap handling, depth variations, and expected latency. An agent given this description can select and invoke the tool without major unanswered questions.

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 supplies 100% coverage of the question and depth parameters, so the description does not need to carry that weight. It does add practical color about question shape and depth behavior, but most of that repeats or extends the schema's existing parameter descriptions rather than introducing wholly new parameter semantics.

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

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

The description states a specific operation: grounded multi-source research over Pipeworx's structured data sources, decomposing a question into facets and routing them to return a findings packet. It explicitly distinguishes itself from open-web search and from ask_pipeworx, and it is clearly positioned for broad/multi-part questions over structured data. Sibling confusion is unlikely.

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

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

The description gives explicit when-to-use guidance: use it for broad/multi-part structured-data questions, use ask_pipeworx for a single lookup, and use ask_pipeworx if not signed in. It also explains which depth modes fit different follow-up needs, making the alternative-selection decision concrete.

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 idempotentHint=true. Description adds context: returns top-N relevant tools with full schemas, ready to call directly. 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?

Description is detailed but efficient, with front-loaded purpose and use case. Every sentence adds value. Could be slightly more concise but still good.

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

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

Given 6 parameters (1 required), no output schema, description explains return value well (top-N tools with schemas, ready to call). Could mention default limit or pagination, but not critical.

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 3. Description doesn't add meaning beyond listing aliases, which schema already documents. The examples in schema are helpful but not in description.

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

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

The description clearly states it finds tools by describing data or task, listing many domains. It distinguishes itself from sibling tools as the discovery tool.

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 'Call this FIRST when you have many tools available and want to see the option set (not just one answer),' providing clear when-to-use and implying when not to.

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 destructiveHint false. The description adds substantial behavioral context: it fans out across multiple sources, returns specific fields (cik, filings, fundamentals, etc.), notes that patent data soft-fails, and explains that only ticker/CIK are supported. No contradictions with annotations.

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

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

The description is front-loaded with examples and is well-organized, but it is somewhat verbose, spanning many lines. Every sentence adds value, so it earns a 4 rather than 5 for 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?

Despite no output schema, the description fully explains the return structure (cik, company_name, recent_filings with URIs, fundamentals sorted, patents, news, LEI) and limitations (patent sunset, name unsupported). It leaves no critical gaps for an agent invoking this 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% (both parameters described), but the description adds valuable context: examples of valid values ('AAPL' or '0000320193'), clarification that names are not supported, and that CIK must be zero-padded. This exceeds baseline expectations.

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 concrete user queries and explicitly states 'full cross-source profile of a US public company in ONE parallel call,' clearly distinguishing it from sibling tools like resolve_entity and compare_entities. The verb 'profile' and resource 'entity' are specific, and the scope 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 advises 'ALWAYS PREFER over chaining single-pack queries when the user asks for a holistic view,' and explicitly states that names are not supported—directing to use resolve_entity first. This provides clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare destructiveHint=true, and the description confirms the delete action. No additional behavioral traits beyond what annotations provide are disclosed, but consistency is maintained.

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 two sentences, delivering all necessary information without redundancy.

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

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

Given the simple interface (one parameter, no output schema) and adequate annotations, the description fully covers the tool's usage and context, leaving no gaps.

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

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

The input schema covers 100% of the parameter (key) with its description. The tool description adds no further semantic information beyond what is already in the schema, so baseline score of 3 applies.

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

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

The description clearly states the tool deletes a previously stored memory by key. It distinguishes from sibling tools like remember and recall, making the purpose unambiguous.

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

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

The description explicitly advises when to use the tool: when context is stale, the task is done, or to clear sensitive data. It also suggests pairing with remember and recall, providing clear guidance.

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

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

Annotations (readOnlyHint, idempotentHint, etc.) already indicate safe, non-destructive behavior. The description adds valuable behavioral details: fetches the page, extracts title/description/key links, and emits standard llms.txt markdown as a text blob. 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 paragraph of four sentences, front-loaded with the main purpose. It is concise and avoids unnecessary details, though it could be slightly more structured. Still effective.

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

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

For a simple tool with 2 parameters and no output schema, the description covers output format ('single text blob', 'standard llms.txt markdown'), use cases, and expected behavior. It lacks error handling discussion but is adequate for the 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?

Input schema covers both parameters with descriptions (100% coverage). The description does not add extra meaning beyond the schema; it mentions the output format but does not elaborate on parameter behavior. Baseline of 3 is appropriate.

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

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

The description clearly states the tool generates a production-ready llms.txt file for any URL, specifying the verb 'generate', the resource 'llms.txt file', and the context for AI crawlers. It distinguishes from sibling tools like ai_visibility_check by focusing on file generation.

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 explicit use cases (getting a client's site indexed, drafting your own, auditing competitors), providing clear context. However, it does not explicitly state when not to use this tool or mention alternative siblings, so it misses full guidance.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and destructiveHint. The description adds value by specifying the exact return fields (id, type, params, etc.) and implies that only active subscriptions are listed unless include_inactive is true. No contradiction with annotations.

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

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

The description is two sentences, front-loading the main action and return fields, then providing usage guidance. No unnecessary words; every sentence earns its place.

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

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

For a simple list tool with one optional boolean parameter and no output schema, the description covers purpose, return fields, and usage context completely. It tells the agent what the tool returns and when to use it.

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

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

Schema coverage is 100% (the single parameter include_inactive is fully described in the schema). The description does not add significant meaning beyond the schema; it only implies that active subscriptions are listed by default. 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 'List the caller's active subscriptions,' specifying the verb and resource. It lists returned fields and, given siblings include subscribe and unsubscribe, it effectively distinguishes itself as the listing tool.

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

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

The description provides explicit usage context: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' This is clear on when to use, though it does not explicitly state when not to use or mention 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 are all false, providing no safety profile. The description compensates richly by disclosing rate limits ('Rate-limited to 5 per identifier per day'), cost ('Free; doesn't count against your tool-call quota'), and the claim_token mechanism for tracking resolutions. It also explains the team's daily digest and roadmap impact, giving the agent a full picture of consequences.

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

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

Although the description is longer than average, every sentence earns its place. It proceeds logically: purpose, usage triggers, exclusions, claim_token workflow, team behavior, rate limits, and cost. The structure makes the tool easy to understand despite the complexity, with no wasted or redundant wording.

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

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

The description covers all necessary context for a feedback tool with no output schema. It explains the return token, how to read prior feedback, usage restrictions, and the tool's free nature. It also addresses edge cases (unauthenticated filing, different MCP servers) without relying on an output schema to convey return behavior.

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

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

Schema coverage is 100%, but the description adds meaningful parameter guidance beyond the schema. It explains the claim_token round-trip: 'pass it back later as pipeworx_feedback({claim_token:"pwfb_…"}) to read whether it was fixed and what changed.' It also instructs to 'describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt,' which directly informs the context and message fields.

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

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

The description opens with a clear, specific declaration: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' This establishes the tool as a feedback channel for Pipeworx tools, clearly distinguishing it from sibling research and subscription tools. It also incorporates the claim_token read-back behavior, further cementing what the tool does.

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

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

The description provides explicit usage guidance: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also excludes other MCP servers: 'if the tool came from a different MCP server in your client... file it with that server instead.' This is model-typical when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable context: data source (CF analytics-engine), no PII, and caching intervals (5min-1h depending on window). This enhances transparency beyond the annotations.

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

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

The description is concise and well-structured. The first sentence clearly states the output, followed by a bulleted list of use cases, then implementation details. Every sentence adds value, and there is no redundancy or fluff.

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

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

Given the tool's simplicity (1 optional parameter, no output schema), the description is complete: it covers purpose, use cases, data source, privacy (no PII), and caching behavior. Annotations further enrich context. No gaps remain for an agent to understand what the tool does and when to use it.

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

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

Schema description coverage is 100% with the 'window' parameter fully documented (enum, description). The description adds a practical explanation: 'Shorter windows surface what's hot right now; longer windows show steady-state demand.' This adds value beyond the schema, justifying a score above baseline 3.

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

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

The description clearly states what the tool does: 'Returns the top tools, top packs, and total call volume over a recent window.' It specifies the verb (returns) and the resource (usage trends on Pipeworx), and distinguishes from siblings like ask_pipeworx and discover_tools by focusing on trending/call volume.

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 three explicit use cases: discovering hot data sources, confirming popular tool is canonical, and seeing if use case aligns with most agents. It also mentions caching behavior. It lacks an explicit 'when not to use' or alternative tool mention, but the use cases are clear and helpful.

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=true, openWorldHint=true, and idempotentHint=true, which are consistent. The description goes beyond these, detailing internal checks (Jaccard similarity, placeholder filter, fill check against CLOB depth) and response structure. 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 dense but well-structured: first sentence summarizes, then details modes, internal logic, and edge cases. While slightly long, every sentence adds essential context for correct tool use.

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

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

Given the tool's complexity (multiple modes, monotonicity checks, partition checks, fill risk), the description thoroughly covers inputs, behavior, output structure, and caveats. Without an output schema, it compensates effectively.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds value by explaining that 'event' accepts slugs or URLs, 'topic' is a seed question, and no args triggers trending scan. This enriches the schema without redundancy.

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, distinguishes three modes (no args, event, topic), and provides specific examples. It effectively differentiates from sibling tools like polymarket_edges and polymarket_fill_risk.

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

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

The description explicitly advises when to use each mode: 'no args for trending_scan', 'event for a specific market', and 'topic for cross-event scanning'. It also warns about cross-event patterns missed by single-event mode and provides fill check criteria to avoid trading unrealizable edges. This is comprehensive guidance.

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

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

Annotations already indicate read-only and idempotent behavior, but the description adds extensive behavioral context: caching (1h at KV level), how edge is calculated (net of slippage), Kelly fraction caps, 24h-move warnings, and details on each model family. This far exceeds the annotation baseline.

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

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

The description is verbose, containing extensive details about model formulas and internal logic that may not be necessary for tool selection or invocation. While well-organized front-to-back, it does not earn its length; many sentences could be omitted without harming usability.

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

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

The description covers all relevant aspects: purpose, usage scenarios, response structure (by_segment, fed_candidates, diagnostics), explanation of empty segments, tradeable-edge knobs, and note on excluded Fed bets. Given the tool's complexity and the lack of an output schema, this is very complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond schema by explaining parameter interactions (e.g., min_kelly vs min_partition_leg_kelly, how slippage_pp affects Kelly sizing). This helps the agent understand nuanced behavior, justifying a score above baseline.

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

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

The description clearly states the tool's purpose: scanning top Polymarket markets to return opportunities where Pipeworx data disagrees with market price. It specifies the use case 'what should I bet on today' and names the verb 'scan top markets and return opportunities'. This differentiates it from siblings like 'polymarket_arbitrage' which likely focuses on pure arbitrage.

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

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

The description provides context on when to use this tool: for discovering opportunities without paging hundreds of markets. It explains the three response segments and the tradeable-edge knobs, giving guidance on how to configure filters. However, it does not explicitly contrast with sibling tools, relying on the distinct purpose to differentiate.

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 idempotentHint=true, but the description adds valuable behavioral context: snapshot-based, time-series fields (first_seen, trend, decay_pp_per_day), expired opportunities with lifespan, and snapshot_gaps. This exceeds annotation coverage.

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

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

The description is detailed and well-structured with clear sections (RESPONSE, LIMITS). It could be slightly more concise, but every sentence adds value and the front-loading of purpose is effective.

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

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

Given the tool's complexity (multiple arrays, time-series, decay computation) and lack of output schema, the description is remarkably complete. It explains all response fields, limitations (60-day TTL), and computation basis (daily closes). No gaps 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 coverage is 100%, but the description adds meaning beyond schema by explaining defaults (14 days, '1wk'), clamping (2-30), and the purpose of each parameter (lookback, snapshot family). 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 it provides edge persistence and decay telemetry from daily polymarket_edges snapshots, answering how long an edge has existed and its trend. It distinguishes itself from siblings like polymarket_edges (raw edges) and polymarket_arbitrage by focusing on time-series behavior.

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

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

The description gives clear context on when to use this tool (when edge age and decay matter) and contrasts fresh vs. old wide edges. However, it does not explicitly list alternatives or when not to use, so it lacks explicit exclusion guidance.

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

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

Description aligns with annotations (readOnlyHint, idempotentHint, etc.) and adds valuable context about return values, the risk of partial basket fills, and forced directional risk beyond what annotations 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 lengthy but well-structured with bolding for key sections and clear separation of single-market vs basket mode. It is front-loaded with the core purpose.

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

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

Given no output schema, the description fully explains return values (top_of_book, vwap_fill_price, verdict, etc.), risks, and usage conditions. It is exceptionally complete for a complex tool.

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

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

Schema coverage is 100%, but the description still adds significant meaning by explaining default behaviors (e.g., default side auto-detection for baskets) and the interpretation of size_usd for both modes.

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 performs a realizable-vs-theoretical edge check against live CLOB order-book depth, and distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edges by specifying when to use it.

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

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

Explicitly says 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500', and warns about the danger of partial fills converting an arb into an unhedged directional position.

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 significant behavioral context: explains output format (leg-by-leg prices, matched spreads), safety fields (compatibility_warning, temporal_alignment, skipped counters), and the limitation that most macro shortcuts trigger warnings. 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 relatively long but well-structured with clear sections for modes, response, and safety fields. Every sentence adds necessary information; no redundancy. Could be slightly more compact, but it earns its 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?

Given the tool's complexity (dual modes, safety checks, cross-venue comparison) and absence of an output schema, the description thoroughly covers all aspects: parameters, return values, edge cases, and limitations. It provides comprehensive guidance for correct invocation and interpretation.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description adds valuable context: explains how the 'topic' parameter maps to specific shortcuts and clarifies that explicit tickers override topic-mapped values. This enhances understanding 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 computes cross-venue spreads between Kalshi and Polymarket for identical resolving questions. It specifies two distinct modes (pre-mapped topic shortcuts and explicit event tickers) and what the output includes, making it easily distinguishable from sibling tools like polymarket_arbitrage.

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 guidance on when to use the tool, including explicit mode selection and caution that most pre-mapped topics may return warnings. It lacks explicit when-not-to-use instructions compared to siblings, but the safety fields effectively communicate scenarios where spreads are not meaningful.

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 value by explaining the scoping behavior ('Scoped to your identifier') and the listing behavior when the key is omitted. 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 three sentences, front-loaded with the primary action, and contains no extraneous information. Every sentence contributes meaning.

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

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

Without an output schema, the description explains what is returned ('retrieve a value' or 'list all saved keys'). It covers the essential behavior for a simple key-value retrieval tool, though it omits details like return format or limits. This is sufficient for the tool's complexity.

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

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

Schema coverage is 100% with one parameter fully described. The description adds the nuance that omitting the key lists all saved keys, which is a behavioral detail not in the schema. While helpful, this is a minor addition, so a score of 3 is appropriate (baseline for full schema coverage).

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

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

The description clearly identifies the tool's purpose: 'Retrieve a value previously saved via remember, or list all saved keys'. It uses a specific verb ('retrieve', 'list') and resource ('saved keys/values'), and distinguishes itself from sibling tools 'remember' and 'forget' by mentioning 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 on when to use the tool: 'Use to look up context the agent stored earlier... without re-deriving it from scratch'. It explains scoping and suggests pairing with 'remember' and 'forget', though it does not explicitly state when not to use it or list alternatives beyond those mentioned.

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

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

The description discloses that mark_read:true flag returned events as read, modifying state. This contradicts the annotation readOnlyHint=true, but the description is transparent about the side effect. It also confirms idempotent behavior ('Polls work fine') and non-destructiveness, aligning with other 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 four sentences long, with the purpose stated in the first sentence. It efficiently covers return data, filters, side effect, and alternative access without unnecessary repetition. 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 the absence of an output schema, the description explains the return fields (source, citation_uri, payload). It covers filtering, mark_read behavior, and polling. Missing details like error handling or authentication are not critical for this simple read tool, but the alternative access note adds 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 descriptions cover all parameters (100% coverage). The tool description adds minimal extra meaning: an example for 'type' ('sec_8k') and clarifying 'since' as ISO timestamp. Most parameter semantics are already in the schema.

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

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

The description starts with 'Pull fired events from your subscription feed', which is a specific verb-resource pair. It further details the data returned (source, citation_uri, raw payload) and filter options. The purpose is distinct from sibling tools like list_subscriptions or search_within, though no explicit comparison is made.

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 guidance on parameter usage (filter by type/since, mark_read) and notes that polls work fine. It mentions an alternative access method (direct API) but does not specify when to use this tool versus sibling tools. No explicit when-not-to-use advice.

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 as true, and destructiveHint as false. The description adds details about the fan-out to multiple sources (SEC EDGAR, GDELT/GNews, USPTO), fallback logic, soft-fail for patents, and the return structure including citations. 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 informative but somewhat lengthy. However, it is well-structured, starting with user-facing queries, then describing the fan-out, parameter details, and ending with the alternative tool. Each sentence serves a purpose, but there is room for slight trimming without losing value.

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

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

Given the tool's complexity (three required parameters, no output schema), the description thoroughly covers the sources, fallback behavior, date format, return structure (changes grouped by source, total_changes, citation URIs), and provides an alternative. It is complete for an agent to understand and invoke correctly.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds value by providing concrete examples for the 'since' parameter (ISO date and relative shorthand like '7d', '30d') and suggesting '30d' or '1m' for typical monitoring. It also clarifies that 'value' can be a ticker or CIK. This goes 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 specified time window, with specific verbs like 'what's new' and 'latest on Y.' It distinguishes the tool from the sibling 'entity_profile' by noting that entity_profile is for static profiles regardless of time window.

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

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

Explicit usage patterns are provided (e.g., 'What's new with X'), along with when to use the alternative 'entity_profile' instead. Parameter guidance, such as recommending '30d' or '1m' for typical monitoring, and explanation of fallback behavior (GDELT→GNews) are included.

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 adds behavioral context beyond annotations: scoping by identifier, 24-hour retention for anonymous, and persistent storage for authenticated users. 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?

Three clear sentences: purpose, usage, and details. Front-loaded with core function, no wasted words.

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

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

Complete for a memory store tool: explains what it stores, how it persists, and how to retrieve (recall) or delete (forget). No output schema needed.

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

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

Schema coverage is 100%, but description adds valuable context: key naming patterns (e.g., 'subject_property') and value types (findings, addresses). Exceeds baseline of 3.

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

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

The description clearly states the tool saves data for later reuse, provides concrete examples (e.g., resolved ticker, target address), and distinguishes it from sibling tools recall and forget.

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

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

Explicitly says use when discovering something worth carrying forward, and notes pairing with recall/forget. Also explains persistence differences for authenticated vs anonymous sessions.

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/destructive=false, so safety is covered. The description adds valuable context: graceful degradation when GLEIF/OpenFIGI unavailable, explicit unresolved identifier reporting, source-labeled identifiers, and internal cascading lookups. 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 lengthy but well-structured with 'SUPPORTED TYPES' and examples. It packs a lot of necessary detail, though some redundancy (e.g., repeating 'accepts ticker, CIK...') could be trimmed. It remains readable and front-loaded with usage intent.

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 explain return values and behavior. It does this thoroughly: for company, lists CIK, ticker, company_name, LEI, FIGI, ownership info, and 'unresolved'; for drug, lists RxCUI, ingredient, brand, and citation. It also covers edge cases like degradation and non-US issuers, making it highly complete.

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

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

Schema covers 100% of parameters, so baseline is 3. The description adds an extra accepted input type (ISIN) not mentioned in the schema, along with nuanced behavior for the value parameter (e.g., ISIN-to-LEI mapping). This goes beyond schema, meriting a 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 clearly states the tool resolves user-spoken names to official identifiers, giving specific verb+resource+outcome. It includes example queries and distinguishes it from siblings by positioning it as the first-step lookup tool ('Use FIRST whenever you have a name but need an ID').

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?

Strong usage guidance is provided via 'Use FIRST whenever you have a name but need an ID,' plus supported entity types with detailed input formats. It lacks explicit 'when not to use' or alternatives, but the examples and scope make 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 discloses that it probes each entity with 'ai_visibility_check', ranks by score, and returns a ranked list with score, confidence, and signal density. This adds significant context beyond the annotations (readOnly, openWorld, idempotent) and does not contradict them.

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

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

The description is three sentences, each earning its place: first sentence states core action, second explains mechanism and output, third gives use case. No fluff, front-loaded with purpose.

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

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

The tool has 4 parameters, no output schema, but the description covers the return format (ranked list with score/confidence/signal density). It lacks mention of error handling or limits (e.g., entity count bounds) but is complete enough for most use cases.

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

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

Schema coverage is 100% so baseline is 3. The description adds value by explaining the 'entities' array semantics (first is subject, rest competitors), 'context' for disambiguation, and the 'models' parameter requirement for Anthropic API keys. This goes beyond the schema's native descriptions.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, using 'scan' and 'compare' as verbs. It distinguishes itself from sibling tools like 'ai_visibility_check' (single entity) and 'compare_entities' (not AI-specific) by specifying the domain and the multi-entity ranking.

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

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

The description explicitly says it's useful for competitive AI-marketing audits and gives an example question. It implies when to use (multi-entity comparison) vs alternatives, though it does not explicitly state when not to use it.

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

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

Annotations already provide readOnlyHint, idempotentHint, destructiveHint. Description adds critical behavioral context: partial failures degrade gracefully, bundlephobia first measurement can take 5-30s, sources_failed listed on timeout. No auth or rate limit info, but adequate 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?

Four sentences, front-loaded with purpose, then usage, ecosystem scope, and failure behavior. Every sentence adds distinct value; no wasted words.

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

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

Despite no output schema, description lists all return fields. Covers composite nature, ecosystem scope, partial failure behavior, and timing. Complete for a tool without 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 description coverage is 100% (both parameters described). Description adds limited additional meaning beyond schema, mainly context about default version behavior, which is already in schema. Baseline 3 is appropriate.

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

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

Description clearly states the tool is a composite check for npm packages, specifying the verb 'scan', resource 'dependency', and scope 'npm ecosystem'. It differentiates from siblings by being a one-call composite across deps.dev and bundlephobia.

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

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

Explicitly states when to use ('is X safe / popular / small') and when not to use ('PyPI / Maven / Cargo / Go fall under deps.dev:version directly'), providing clear context against 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 readOnly, idempotent, and non-destructive. Description adds technical details: BGE-base-en embeddings, cosine similarity, 500-char windows, 200K char cap with truncation and flagging, and return of offsets for verification. No contradictions; description enriches 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?

Four concise sentences, front-loaded with core purpose and usage, followed by technical details, examples, and pairing suggestion. Every sentence adds value 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?

Despite no output schema, description adequately hints at return structure (passages, offsets, scores). Combined with full parameter docs, strong annotations, and usage guidance, the description is complete for an agent to correctly invoke the tool.

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

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

Schema coverage is 100% with descriptions for all three parameters. Description adds helpful natural-language query examples but does not significantly expand on schema for text or limit. The example queries provide extra semantic clarity, raising baseline from 3 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?

Clearly states the verb ('search inside'), resource ('a fetched record'), and what it returns ('top-N passages with character offsets and similarity scores'). Distinguishes from siblings by mentioning pairing with ask_pipeworx_grounded and use case of large documents.

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

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

Explicitly says 'Use when the record is too big to cram into the prompt' and suggests an alternative workflow with ask_pipeworx_grounded, providing clear when-to-use and how-to-pair guidance.

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

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

The description adds significant behavioral details beyond the annotations, such as the requirement for an OAuth account, rate limits on SMS (10/day), webhook HMAC signing, and auto-disable after 10 failures. It also explains the persistent feed behavior. 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 packed with information but well-structured, starting with the main purpose and then detailing types and delivery options. It is slightly dense but every sentence adds value. A more structured format with bullets or sections could improve readability.

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

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

Given the tool's complexity (3 params, nested objects, no output schema), the description is comprehensive. It covers all subscription types, delivery channels, behavioral notes, prerequisites, and even hints at output (subscription ID). No gaps remain for an agent to misinterpret 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?

With 100% schema coverage, the baseline is 3, but the description greatly enriches parameter understanding. It provides concrete examples for each subscription type (e.g., 'items:["5.02"] = officer change'), explains the delivery object options in detail, and clarifies required fields like 'sponsor or condition' in clinical_trial. This goes well beyond the schema.

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

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

The description clearly states the tool creates a proactive monitoring subscription to a live-data event stream and returns the new subscription ID. It uses specific verbs and resources, and distinguishes itself from sibling tools like 'unsubscribe' and 'list_subscriptions' by focusing on creation.

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

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

The description provides clear context on when to use the tool, including prerequisites (Pipeworx OAuth account), supported types, and delivery channels. However, it does not explicitly contrast with alternatives or state when not to use it, so it misses the highest score.

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

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

Annotations already provide readOnly, openWorld, idempotent, and non-destructive hints. The description adds value by detailing the return format (category-bucketed examples with tool+argument shapes) and the optional topic parameter behavior, without contradicting annotations.

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

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

The description is somewhat lengthy but well-structured, starting with alternative phrasings, then core purpose, output details, usage instructions, and when to use. Every sentence adds value, though minor trimming could improve 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?

Given the tool's simplicity (one optional parameter, no required fields, no output schema), the description thoroughly covers its purpose, usage, output, and context. It provides all necessary information for an agent to decide when and how to invoke it.

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 covers the single 'topic' parameter with 100% coverage. The description enriches this by listing specific topic values (finance, pharma, real-estate, etc.) and explaining that omitting the parameter returns a cross-category spread, which is not in the schema description.

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

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

The description clearly states the tool is an onboarding entry point that suggests example questions about what Pipeworx can do. It uses specific verbs and resources, and distinguishes from sibling tools like ask_pipeworx and discover_tools by focusing on exploration rather than direct querying.

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

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

The description explicitly instructs to 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools'. It also implies alternative use cases by highlighting that the tool is for discovering capabilities, contrasting with direct question-asking tools among siblings.

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

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

Disclosures beyond annotations: row is deactivated not deleted, historical events stay available. Annotations already indicate non-destructive and not read-only. Adds useful context on side effects.

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 states core action, second adds ownership and deactivation detail. No wasted words, front-loaded with purpose.

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

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

For a simple cancel operation with no output schema, description covers purpose, ownership constraint, and outcome (deactivation). Complete enough for agent to understand behavior.

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

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

Schema description coverage is 100%, so baseline 3. The description adds no new info about the id parameter 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?

Clearly states 'Cancel a subscription by id.' Specific verb and resource. Distinguishes from siblings like subscribe and list_subscriptions by emphasizing ownership enforcement and deactivation behavior.

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

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

Explicitly says 'Ownership is enforced — you can only cancel your own subscriptions.' Provides clear condition for use. Does not explicitly mention when not to use or alternatives, but the condition is 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?

Annotations already indicate read-only, idempotent, open-world safety, but the description adds substantial behavioral detail: the fast-path vs grounded pipeline, verdict enum, the critical semantics of 'could_not_verify' (not evidence) and 'unsupported' (no source found), plus citation/reasoning. This goes well beyond the annotation baseline.

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

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

The description is long but information-dense and front-loaded with examples and purpose. Each clause adds value (routing, verdicts, error semantics, call consolidation), though it could be slightly tightened without losing substance.

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

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

With no output schema, the description carries full burden for return values and does so comprehensively: verdict types, actual value with citation, reasoning, and explicit disambiguation of error vs. no-evidence. It covers edge cases such as 'could_not_verify' and 'unsupported', making the tool fully usable.

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

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

Schema coverage is 100% for both parameters, so baseline is 3. The description's mention of 'exact percent-delta math' and the schema's own example of tolerance_pct already communicate the semantics; the description adds marginal extra meaning but doesn't materially improve on the schema.

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

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

The description opens with natural-language query examples and a clear verb+resource ('claim verification against authoritative sources'). It unambiguously distinguishes this tool from siblings by stating it is for factual claim checking and explains its consolidated nature (replaces 4–6 sequential calls).

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

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

Explicitly states when to use ('Use whenever the agent needs to check whether something a user said is factually correct') and describes the two routing paths (SEC EDGAR for company-financial claims, grounded fallback for others). It does not explicitly name alternatives or state when not to use, but the context is clear enough.

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