Zoho_crm

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

Annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint false) are consistent with description. Description adds behavioral details: default model, need for _apiKey with Anthropic, payment responsibility, output structure (score, confidence, signals, raw_response). 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 compact: 3 sentences covering purpose, default behavior, optional key, output shape, and use cases. Front-loaded with core action. No unnecessary words.

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

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

For a tool with 4 parameters and no output schema, description sufficiently explains return structure and behavior. Includes cost implication for Anthropic calls. Use cases are relevant. No missing critical info.

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

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

Input schema has 100% coverage for all 4 parameters. Description adds value by explaining the interplay: _apiKey required only if anthropic in models list, models default to workers-ai alone, context helps disambiguate. Slightly exceeds baseline of 3 for high coverage.

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

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

Description clearly states it probes LLMs for knowledge about an entity and returns visibility scores (0-100) per model with a combined view. Specific verb ('probe', 'score') and resource ('LLMs', 'visibility') are present. Distinguishes from siblings like 'ask_pipeworx', 'compare_entities' by focusing on AI awareness 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?

Description explicitly lists use cases: AI-marketing audits, pre-launch brand checks, competitive monitoring. Implies when to use but does not explicitly state when not to use or contrast with alternatives like 'entity_profile' or 'scan_competitor_ai_presence'. Still provides clear context.

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

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

Describes the internal behavior: picks the right tool and fills arguments. With no annotations provided, this is helpful context. However, it doesn't disclose potential latency, error handling, or limitations (e.g., if it cannot find a suitable tool).

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

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

Three short sentences efficiently convey the tool's role, operation, and examples. Every sentence adds value, with examples front-loaded after the core description.

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

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

For a single-parameter tool with full schema coverage and no output schema, the description is complete. It explains the query mechanism, the AI routing behavior, and provides illustrative examples.

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

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

Schema already covers the single parameter (question) with 100% description coverage. Description adds value by explaining how the parameter is used ('describe what you need') and providing example values, which aids understanding beyond the schema's generic 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?

Description clearly states the tool's purpose: answering plain English questions by selecting the best data source automatically. It distinguishes itself from sibling tools by acting as an intelligent router, unlike the specific Zoho or memory tools.

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

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

Explicitly advises when to use: when you have a natural language request and don't want to browse tools or learn schemas. Provides three concrete examples covering different domains (trade, adverse events, SEC filing).

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

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

Annotations already provide readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description goes beyond by detailing the resolution, classification, fan-out, and return of an evidence packet plus comparison. No contradiction with annotations.

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

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

Description is a single paragraph with several informative sentences. It is front-loaded with purpose. Though slightly dense, it earns its sentences. Could be more structured with bullets, but 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?

Given the complexity and lack of output schema, the description covers main functionality and usage contexts. However, it does not describe the output structure in detail (evidence packet format, comparison specifics). This leaves some gaps for a tool that returns complex data.

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

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

Both parameters have schema descriptions (100% coverage). The description reinforces the market parameter (slug, URL, question text) and adds detail for depth: 'quick = 2-3 evidence sources, thorough = full fan-out. Default thorough.' This adds value beyond the schema's enum.

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 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the verb (research), resource (Polymarket bet), and differentiates from siblings by being a specialized bet-research tool. The internal mechanics (resolve, classify, fan-out) are also explained.

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

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

Description provides explicit use cases: 'should I bet on X?', 'what does the data say about this Polymarket market?', 'is there edge in this bet?'. It also positions itself as the core demo product, implying better conversion than alternative approaches. However, it doesn't explicitly list when not to use it or name sibling 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?

With no annotations, the description carries full burden. It discloses the data sources (SEC EDGAR for companies, FDA for drugs) and return format (paired data + resource URIs). It does not mention read-only nature or rate limits, but the core behavior is well described.

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 concise sentences with no fluff. It front-loads the core purpose and efficiently conveys 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 simplicity of the tool (2 parameters, full schema coverage, no output schema), the description is complete. It explains the inputs, outputs, data sources, and efficiency benefit, leaving no major gaps for an agent to misunderstand.

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

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

Schema coverage is 100%, but the description adds significant value: for type, it details the return fields; for values, it provides examples and specifies input formats (tickers/CIKs vs drug names). This enriches the schema beyond the basic descriptions.

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

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

The description clearly states the tool's purpose: comparing 2-5 entities side by side. It specifies two entity types (company and drug) and the data points returned for each. It also distinguishes itself from sequential calls by noting it replaces 8-15 agent 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?

The description provides clear context for when to use the tool (comparing 2-5 entities) with examples. It does not explicitly state when not to use it or list alternatives, but the efficiency gain over sequential calls implies its primary use case.

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

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

No annotations provided, so description carries full burden. Description states it searches and returns relevant tools, but does not disclose behavior like whether it modifies state, has rate limits, or requires authentication. However, for a search tool, this is typical and the description is adequate.

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

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

Three sentences, each adding distinct value: first states action and result, second states return format, third states when to use. 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?

Tool is a search/discovery tool with simple input and no output schema. Description is sufficient for agent to understand purpose and when to use. Could mention that it doesn't modify state, but given the nature, it's fine.

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 have descriptions). The description adds context that query is a natural language description, but this is already in the schema's parameter description. The description does not add new meaning 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?

Description uses specific verb 'Search' and resource 'tool catalog' with clear intent: 'by describing what you need'. Explicitly states return value 'most relevant tools with names and descriptions' and distinguishes from siblings by being 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 500+ tools available and need to find the right ones for your task.' Provides clear when-to-use context and implies it's the entry point before using other tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses that it returns 'pipeworx://' URIs for all data and replaces many sequential calls, but it does not mention data freshness, rate limits, error handling, or whether the operation is read-only. The behavior is mostly transparent but missing some details that would be expected for a data-fetching tool.

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

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

The description is a single paragraph that efficiently packs a lot of information. It front-loads the purpose and then lists data sources and output format. While concise, it could be slightly more structured (e.g., bullet points for parameters or data sources) to improve readability without adding 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 has 2 required parameters, no output schema, and no annotations, the description covers the primary functionality well. It lists all data sources, output format (URIs), and input constraints. However, it does not mention possible errors, pagination, or response size, which would be helpful for an agent to handle the tool correctly.

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

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

The input schema already provides descriptions for both parameters, but the description adds practical guidance: it explains valid formats (ticker vs. CIK for 'value') and advises to use resolve_entity for names. This goes beyond the schema's enum and string description, significantly aiding correct invocation.

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

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

The description clearly states that the tool returns a full profile of an entity across multiple Pipeworx packs (SEC, XBRL, USPTO, GDELT, LEI) for type 'company'. It distinguishes itself from sibling tools like 'resolve_entity' (which handles name resolution) and 'compare_entities' (which compares entities). The verb 'returns' is implicit but clear.

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

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

The description explicitly tells when to use this tool: for getting a broad profile. It also tells when not to use it: for federal contracts, use usa_recipient_profile directly. It advises that names are not supported and to use resolve_entity first. This provides clear guidance on alternatives and prerequisites.

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 accurately states 'Delete', which implies destructive behavior. However, no annotations are provided, and the description does not add further behavioral context such as confirmation, reversibility, or side effects. It is adequate but minimal.

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, concise sentence that fully conveys the purpose. Every word is necessary, and there is no extraneous information.

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

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

Given the tool's simplicity (1 required parameter, no output schema, no nested objects), the description is sufficient. However, it could be improved by noting that the deletion is permanent or by referencing the 'recall' tool for verification.

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%: the parameter 'key' is described as 'Memory key to delete' in the schema. The tool description adds no further meaning beyond what the schema already provides, so a baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Delete') and resource ('stored memory by key'), clearly stating the action and scope. It distinguishes itself from sibling tools like 'recall' (retrieve) and 'remember' (store), which handle different operations.

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 is clear about what it does (delete by key) but does not explicitly state when to use it versus alternatives. The sibling tools imply context (e.g., 'remember' for storing, 'recall' for retrieving), but no direct guidance is provided.

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

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

Annotations already indicate readOnly, openWorld, idempotent, non-destructive. Description adds behavioral details: fetches page, extracts title/description/key links, outputs single text blob. Does not mention error handling or rate limits, but adequate for scope.

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

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

Two concise sentences with use cases, no redundancy. Front-loaded with purpose and output format. 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 tool's simplicity (2 params, no output schema, good annotations), the description covers what it does, how it works, and use cases. Mentions output format. Complete for an AI agent to invoke correctly.

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

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

Schema description coverage is 100%, so parameters are well-documented. Description does not add new semantics beyond what the schema provides for 'url' and 'max_links' (default/max already in schema). 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?

Clearly states the tool generates an llms.txt file for AI crawlers, with specific verb 'Generate' and resource 'llms.txt file'. Distinguishes from siblings by its unique purpose and output format.

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

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

Provides explicit use cases: indexing a client's site, drafting for own project, auditing competitors. Also implies when to use through 'useful for' list, though no when-not examples needed for a simple tool.

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

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

With no annotations, description must disclose behavior. It adds rate-limiting (5 per day) and 'Free' indicating no cost. However, it doesn't mention confirmation or async behavior. Acceptable for a simple input tool.

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

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

Two sentences, direct and front-loaded: purpose first, then usage constraints. Every word earns its place. No filler.

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

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

Covers purpose, usage, constraints (rate limit, content rules). No output schema, so return behavior isn't documented, but for a feedback tool this is acceptable. Minor gap: no mention of what happens after submission.

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

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

Schema coverage is 100% and descriptions are already in schema. The description reinforces message guidelines (specific, 1-2 sentences, 2000 chars) but adds little beyond what properties document.

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 'Send feedback to the Pipeworx team' and enumerates specific use cases (bug reports, feature requests, missing data, praise). This clearly distinguishes it from sibling tools like ask_pipeworx or discover_tools.

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

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

Explicitly lists when to use (bug reports, etc.) and what not to include (end-user prompt verbatim). Also mentions rate limit. No explicit exclusions for other scenarios, but siblings cover alternative actions.

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, openWorld, idempotent, non-destructive. Description adds valuable context: data derived from CF analytics-engine, no PII, caching behavior (5min-1h). No contradiction.

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

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

Slightly verbose but well-structured with bullet points and front-loaded key info. Every sentence adds value; could trim 'self-aggregating signal' but 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?

No output schema, so description must clarify returns: mentions top tools, top packs, total call volume. Also covers caching and data source. Complete for a read-only trending 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 already fully describes the single parameter with enum and description. The description adds nuance: 'shorter windows surface what's hot right now; longer windows show steady-state demand', elevating beyond schema.

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

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

Explicitly states 'Returns the top tools, top packs, and total call volume over a recent window', clearly identifying the verb and resource. Differentiates from siblings like ask_pipeworx and discover_tools by focusing on trending data.

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

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

Lists three specific use cases (discovering hot sources, confirming canonical choice, aligning with demand), providing clear context. Lacks explicit 'when not to use' but sufficiently guides agents.

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, openWorldHint, destructiveHint) are consistent and non-contradictory. The description enriches behavioral understanding by detailing internal steps (walks markets, groups, checks monotonicity) and the return format (ranked opportunities with trade direction and reasoning), going well 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 a single, well-structured paragraph that front-loads the purpose, enumerates modes clearly, and includes examples. Every sentence is informative and non-redundant, achieving maximum clarity with minimal text.

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

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

Despite having no output schema, the description fully covers return values (ranked opportunities with trade direction and reasoning) and explains the algorithm at a sufficient level. For a moderately complex tool with two modes and external API calls, the description is complete and self-contained.

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

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

Schema coverage is 100% and each parameter has a concise description. The tool description adds significant value by explaining how each parameter maps to a distinct mode (event vs topic) and provides usage examples, elevating 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 finds arbitrage opportunities via monotonicity violations, with explicit modes (event vs topic). It uses a specific verb and resource, and the dual-mode explanation effectively distinguishes intra-event and cross-event 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 provides clear guidance on when to use each mode (single-event vs cross-event) with concrete examples like the May≤June rule. It does not explicitly contrast with sibling tools (e.g., polymarket_edges), but the mode-level guidance is sufficient for correct invocation.

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 and destructiveHint=false, and the description adds significant behavioral context: it details data sources (FRED, coinpaprika), the lognormal model, grouping by asset, and ranking by edge. It also clarifies the tool does not modify data and is for discovery, going well 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 a single focused paragraph of four sentences. Each sentence serves a purpose: purpose, model explanation, output, and intended use. No redundancy or unnecessary details, making it highly concise and front-loaded.

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

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

Given no output schema, the description mentions 'Returns top N ranked by edge magnitude with suggested trade direction' but lacks details on the exact output format or fields. While the complexity is moderate and the open world hint is present, the return structure is not fully specified, leaving some ambiguity.

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 clear parameter descriptions (limit, window, min_edge_pp and defaults). The tool description does not add extra meaning to the parameters beyond restating the process; it mentions 'top N' but does not elaborate on parameter usage. 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 scans high-volume Polymarket markets and returns those where Pipeworx data disagrees most with market price. It uses specific verb 'scan...return' and distinct resource, differentiating it from siblings like polymarket_arbitrage and bet_research.

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 states it is built for the 'what should I bet on today' question and explains the process (covers crypto-price bets, groups by asset, computes model probability). It provides clear usage context but does not explicitly exclude alternatives or 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 indicate read-only, idempotent, non-destructive behavior. The description adds behavioral details: explains that the spread arises from different participant pools, describes two modes, and outlines the return format. No contradictions.

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

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

The description is well-structured with a clear opening, explanatory context, mode breakdown, and output summary. It is slightly verbose but every sentence adds value. 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?

Given no output schema, the description adequately explains the return values. All three optional parameters are covered with examples and mode relationships. The tool's complexity (spread calculation across venues) is fully addressed.

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

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

Schema coverage is 100% with descriptions. The description adds value by explaining the two modes: topic as pre-mapped shortcuts and explicit parameters for custom pairings, including examples. It also clarifies the override relationship between topic and explicit parameters.

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

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

The description clearly states the tool's purpose: computing the cross-venue spread between Kalshi and Polymarket for the same resolving question. It specifies two modes (topic and explicit) and distinguishes itself from potential siblings by focusing on cross-venue 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 usage context, explaining when to use the tool (to get arb signals from cross-venue spreads) and how to use it via two modes. However, it does not explicitly compare with sibling tools like polymarket_arbitrage or 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?

No annotations are provided, so the description must convey behavioral traits. It states that memories are saved 'in the session or in previous sessions', implying persistence, but does not clarify scope (e.g., session-level vs cross-session, or any side effects). It does not disclose if retrieval is read-only or has any state changes.

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, concise and front-loaded with the core action. Every sentence adds value: first explains the action, second provides context for when to use 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?

Given the simplicity (one optional parameter, no output schema), the description adequately covers the tool's purpose and usage. However, it does not mention what is returned (e.g., the memory value or a list of keys), which might require the agent to infer from sibling tools.

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 described in the schema. The description adds value by explaining that omitting the key lists all memories, which is not explicitly stated in the schema's 'omit to list all keys' hint. However, the description could further clarify the behavior when the key does not exist.

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

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

The description clearly states the verb 'Retrieve' and the resource 'stored memory', with explicit distinction between retrieving a specific key and listing all memories. It also clarifies the tool's use for retrieving context saved earlier, differentiating it from sibling tools like 'remember' and 'forget'.

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

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

The description explicitly tells when to use the tool ('retrieve context you saved earlier') and when to omit the key ('omit key to list all stored memories'). It also implies when not to use it (e.g., for storing, use 'remember'). This provides 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?

With no annotations, the description fully discloses the parallel fan-out to SEC, GDELT, and USPTO, and the return format (structured changes, total_changes count, URIs). It does not mention rate limits or error handling, but covers the core behavioral traits well.

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

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

The description is a single three-sentence paragraph, front-loaded with the core purpose. Every sentence adds value: the first defines the tool, the second details the company fan-out, the third explains inputs and outputs. No redundant or excessive text.

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

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

Given the complexity (fan-out to multiple sources) and no output schema, the description adequately explains the return format and use cases. It is complete for an agent to understand scope and output, though it could mention pagination or max results for greater completeness.

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

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

Schema coverage is 100% (baseline 3). The description adds meaning by providing example inputs for 'since' (ISO dates and relative formats), specifying 'value' as ticker or CIK, and noting that 'type' only supports 'company'. These examples and clarifications increase understanding beyond the schema.

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

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

The description clearly states the tool retrieves recent changes for an entity since a point in time, specifying the verb 'get new' and resource 'entity'. It distinguishes from sibling tools like 'entity_profile' (static profile) and 'compare_entities' (comparison), making it unambiguous when to use this 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 explicitly states use cases: 'brief me on what happened with X' or change-monitoring workflows. It does not provide exclusions or alternatives, but the context is clear given the sibling list, so it earns a 4.

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

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

With no annotations, the description carries the full burden. It discloses persistence duration (24 hours for anonymous, persistent for authenticated), which is critical behavioral context beyond the schema. No contradictions found.

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

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

Three sentences, each serving a purpose: operation definition, use cases, and persistence behavior. No wasted words, front-loaded with the core action.

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

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

For a simple key-value store with two required string params and no output schema, the description covers purpose, usage, and behavioral nuances (persistence). It does not detail size limits or overwrite behavior, but is adequate for this 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%, so baseline is 3. The description adds value by explaining the purpose of the key-value pair ('intermediate findings, user preferences, context') and provides examples for key values. This extra context raises the score.

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 stores a key-value pair in session memory, specifying the verb 'store' and the resource 'session memory'. It distinguishes from siblings like 'recall' (retrieve) and 'forget' (delete) by focusing on write operation.

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

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

The description provides usage context: saving intermediate findings, user preferences, or context across tool calls. It also notes persistence differences (authenticated vs anonymous), but does not explicitly state when not to use or compare to alternatives like 'discover_tools'.

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

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

With no annotations, the description fully discloses the tool's behavior: it resolves entities (read-only), accepts various identifiers, and returns specific fields including pipeworx URIs. There is no contradiction or hidden behavior.

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

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

The description is concise, with three sentences that front-load the core purpose and key details. Every sentence adds value 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 no output schema, the description fully explains inputs, outputs, and benefits (replaces multiple calls). It is complete for an agent to select and invoke the tool correctly.

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

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

Schema covers both parameters with descriptions, but the description adds examples ('AAPL', '0000320193', 'Apple') and explains return values, significantly enhancing understanding beyond schema.

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

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

The description clearly states the verb 'resolve' and resource 'entity to canonical IDs', specifies scope ('across Pipeworx data sources in a single call'), and differentiates from siblings by highlighting it replaces multiple lookup calls. The versioning (v1, type='company') adds specificity.

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 usage context: accepts ticker, CIK, or name and returns canonical IDs. It explicitly states it replaces 2-3 lookup calls, implying prioritization. However, it lacks explicit when-not-to-use or alternative tool 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?

Describes the internal process of probing each entity with ai_visibility_check, ranking, and returning a list. Annotations indicate readOnlyHint, idempotentHint, destructiveHint=false, which are consistent. Adds process details 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?

Three well-structured sentences, front-loaded with purpose, minimal waste. Clearly conveys core functionality and context.

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 annotations and full schema coverage, description explains the return format (ranked list with score, confidence, signal density) adequately. No output schema needed; description fills gap.

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

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

Schema coverage is 100%. Description adds meaning by specifying the first entity is treated as the subject for narrative purposes. Models and _apiKey are explained in schema, but description reinforces their roles.

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, probes each with ai_visibility_check, ranks by score, and surfaces most/least recognized. It distinguishes itself from sibling tools like ai_visibility_check (single entity) and compare_entities (different type).

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

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

Provides context for use in competitive AI-marketing audits with an illustrative question. Implicitly suggests when not to use (single entity) by referencing ai_visibility_check, but does not explicitly state alternatives or exclusions.

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

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

With no annotations provided, the description carries full burden. It discloses the data source (SEC EDGAR+XBRL), return verdicts (6 types), extracted structured form, actual value with citation, and percent delta. It also notes it replaces sequential calls. No mention of rate limits or auth, but for a read-only tool this is reasonable transparent.

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 purpose and scope, second lists outputs and efficiency. Every word adds value, no redundancy. Very concise and well-structured for an agent to quickly grasp.

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 a single parameter, no output schema, and no annotations, the description covers purpose, inputs, outputs, scope, and benefits. It could mention limitations (only US public companies, only certain financial metrics) but it implicitly does via 'v1 supports company-financial claims'. Still, it is complete enough for an agent to use 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?

Only one parameter 'claim' with 100% schema description coverage. The tool description adds meaning beyond the schema by explaining how the claim will be processed and what outputs to expect (verdict, delta, citation). This helps the agent understand the parameter's role and expected format, 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 the tool fact-checks natural-language claims against authoritative sources, specifically for company-financial claims (revenue/net income/cash for US public companies). It uses specific verbs and resources (SEC EDGAR+XBRL) and distinguishes from sibling tools which are unrelated (e.g., entity resolution, Zoho CRUD).

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 'v1 supports company-financial claims' and lists the supported metrics, providing clear context on when to use. It also mentions it replaces 4-6 sequential agent calls, implying efficiency. However, it does not explicitly state when not to use (e.g., for non-financial claims) or point to alternative tools, but sibling tools are dissimilar, so guidance is adequate.

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

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

No annotations are present, so the description carries full burden. It correctly indicates a mutation operation ('Create'), but lacks details on side effects (e.g., validation, required fields, or conflict handling). The description is adequate but not comprehensive.

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 concise sentence that communicates the core purpose. It is front-loaded and avoids unnecessary detail, but could be slightly more informative without losing brevity.

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

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

Given the tool's complexity (2 parameters, no output schema, nested objects), the description is minimally complete. It covers the basic function but omits useful details like typical return values or error scenarios that would aid agent decision-making.

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 does not add extra meaning beyond the schema; it only restates the module and data parameters without additional context. The schema itself provides clear descriptions for both parameters.

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

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

The description clearly states the verb 'Create' and the resource 'record in a Zoho CRM module'. It distinguishes from siblings like zoho_get_record and zoho_search_records by focusing on creation, though it does not explicitly contrast with other tools.

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

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

The description implies when to use (creating new records) but does not provide explicit guidance on when not to use it or alternatives. Given siblings like zoho_get_record and zoho_search_records exist, stating exclusions would improve clarity.

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 empty, so the description bears full burden. It does not disclose whether the tool is read-only, what happens if the ID is invalid, rate limits, or any side effects. The description only states the basic operation.

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

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

Single sentence, directly to the point. Could be considered slightly under-specified but is appropriately concise given the simplicity of the operation.

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?

Simple tool with 2 parameters and no output schema, but the description lacks context about error handling, return value structure, or authentication. Siblings like zoho_create_record might need more detail, but this one is basic enough that a slightly fuller description would help.

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 does not add any extra meaning beyond what the schema provides (id and module). The module description in schema lists examples, which is sufficient.

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

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

The description clearly states the action (Get), resource (record), and scope (single record by ID from a Zoho CRM module). It distinguishes from siblings like zoho_list_records and zoho_search_records, which handle multiple records.

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

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

No guidance on when to use this tool vs alternatives. For instance, zoho_search_records might be more appropriate when filtering criteria are needed. The description does not mention prerequisites like required permissions or module existence.

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

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

No annotations are provided, so the description carries full burden. It correctly indicates this is a read operation (listing), which is transparent. However, it does not disclose any potential side effects, permissions needed, or rate limits.

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

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

The description is a single, complete sentence with no wasted words. It is front-loaded with the action and resource.

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

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

The tool has no input schema parameters and no output schema, and the description is sufficient for a simple list operation. However, it could mention that the output lists module names or IDs to aid downstream tool selection.

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

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

The input schema has no parameters, so the description adds no param info. With schema description coverage at 100%, baseline is 3. Since no parameters exist, the description appropriately omits param details, earning 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 verb 'list', the resource 'all available modules', and the system 'Zoho CRM'. It distinguishes itself from siblings which operate on records, not modules.

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

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

The description implies that this tool is for discovering available modules before using record-related tools. However, it does not explicitly state when to use it versus other tools, nor does it mention any prerequisites.

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

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

No annotations provided, so description carries full burden. It indicates the tool lists records but does not disclose pagination behavior, rate limits, or whether it returns all records by default. Moderate transparency.

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

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

Single sentence, front-loaded with action and examples. 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?

No output schema, so description could explain return structure. However, with 4 params well-documented in schema, description is adequate but not complete for a list operation.

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 description adds little beyond schema. It mentions module examples but does not elaborate on page, fields, or per_page parameters. Baseline 3 is appropriate.

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

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

The description clearly states it lists records from a Zoho CRM module and gives examples (Leads, Contacts, Deals). It distinguishes itself from siblings like zoho_get_record (single record) and zoho_search_records (search) but could be more precise.

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

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

The description implies usage for listing records but does not explicitly state when to use this vs. alternatives like zoho_search_records. No guidance on 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?

No annotations exist, so description carries full burden. It mentions 'search' but lacks details like pagination behavior (implied via page/per_page params) or performance implications. The input schema covers parameter descriptions, so score is adequate.

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?

Single sentence, efficient and front-loaded. However, could be slightly more informative without becoming verbose.

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 and simple structure, description covers the core function. Lacks details on criteria format or return type, but schema provides some context.

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

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

Schema description coverage is 100%, so baseline is 3. Description adds no extra parameter context beyond what the schema provides, but the schema is sufficiently descriptive.

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 searches records in a Zoho CRM module using criteria, distinguishing it from siblings like zoho_get_record (single record) and zoho_list_records (all records).

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

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

The description implies use for search with criteria, but does not explicitly contrast with list_records or get_record, nor provide when-not-to-use scenarios.

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