Freshdesk

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

Without annotations, the description transparently explains that Pipeworx selects the right tool and fills arguments, implying autonomous decision-making. It doesn't mention limitations or failure cases, but is otherwise clear.

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, well-structured with a clear purpose statement and examples, all in a few sentences.

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 and no output schema, the description provides sufficient context for an agent to use the tool. Examples enhance completeness, though it could mention potential delays or error handling.

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

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

Schema coverage is 100%, and the description adds meaning beyond the schema by explaining that the question should be in natural language and providing examples of valid inputs.

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 answers questions in plain English using the best available data source, with specific examples. It distinguishes itself from sibling tools by acting as a general question-answering interface.

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 'no need to browse tools or learn schemas — just describe what you need' and provides usage examples, effectively guiding when to use this tool over siblings like freshdesk 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?

The description reveals key behaviors: it resolves the market, classifies the bet type, fans out to appropriate data packs (e.g., crypto+fred+gdelt for BTC), and returns an evidence packet with a market-vs-model comparison. This goes beyond the annotations (readOnlyHint, openWorldHint, destructiveHint) by explaining the internal fan-out logic. No contradictions with annotations.

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

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

The description is a single paragraph that front-loads the main purpose and then provides details. Every sentence adds value—no redundancy. It is dense but not overly long. Minor improvement could be breaking into bullet points for readability, but current structure is acceptable.

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

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

Despite lacking an output schema, the description sufficiently explains the return value: 'evidence packet plus a simple market-vs-model comparison.' Given the tool's complexity (resolving, classifying, fanning out), the description covers the key aspects needed for an AI agent to understand what the tool does and what to expect.

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

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

The schema already provides descriptions for both parameters (depth and market) with 100% coverage. The description adds extra context: 'quick = 2-3 evidence sources, thorough = full fan-out. Default thorough.' and elaborates that market can be a slug, URL, or question text. This enriches the schema's meaning beyond the bare definitions.

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

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

The description clearly states the tool's function: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies input types (slug, URL, question text) and outputs (evidence packet + market-vs-model comparison). This distinguishes it from sibling tools like 'validate_claim' or 'entity_profile' which serve different purposes.

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 when to use the tool: 'Use for "should I bet on X?", "what does the data say about this Polymarket market?", or "is there edge in this bet?".' It also implies it's the recommended approach by claiming 'agents that get bet-relevant context here convert better than ones that have to discover the packs themselves.' It does not provide explicit when-not-to-use or alternatives, but the context is clear.

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

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

No annotations provided, so description carries full burden. It discloses return format (paired data + URIs) and data sources, but does not mention read-only nature, error handling, or behavior on missing entities. Adequate but with gaps.

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 earning its place: purpose, data per type, return format and efficiency. Front-loaded and 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?

Simple tool with 2 params and no output schema; description explains return format vaguely. Lacks details on error handling, output structure, or edge cases. Adequate but incomplete for a tool replacing 8–15 calls.

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), but description adds substantial context: explains meaning of each 'type' enum value with specific data fields and gives examples for 'values' (tickers/CIKs for company, drug names). Adds value beyond schema.

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

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

The description clearly states it compares 2–5 entities side by side with specific data fields for company and drug types, sourced from SEC EDGAR, and distinguishes from sibling tools which are mostly unrelated (freshdesk, 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?

The description implies when to use: for comparing multiple entities efficiently, replacing sequential calls. It provides clear context but lacks explicit when-not-to-use instructions or alternatives beyond mentioning it replaces 8–15 calls.

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 must convey behavioral traits. It states the tool returns 'the most relevant tools with names and descriptions,' indicating a search operation without side effects. However, it doesn't detail how ranking works, whether it uses embedding search or keyword matching, or if the catalog is up-to-date. A 3 is fair as it covers basic behavior but lacks depth.

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

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

The description is two sentences: first states purpose, second gives a clear when-to-use directive. Every word adds value, no fluff or repetition.

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

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

Given no output schema, the description clarifies return type: 'most relevant tools with names and descriptions.' For a search tool with simple parameters, this is sufficient. The complexity is low, and the context signals (no nested objects, no enums) align with a straightforward interface.

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 new meaning beyond the schema; the query parameter is described in schema as 'natural language description' and the tool description reinforces this. No additional usage hints for the limit parameter are provided.

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

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

The description clearly states the tool's purpose: 'Search the Pipeworx tool catalog by describing what you need.' It specifies the verb ('search'), resource ('tool catalog'), and method ('natural language query'), distinguishing it from siblings like ask_pipeworx (which likely answers questions) and the recall/forget tools (which manage context).

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 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This sets a clear precedence rule, guiding the agent to use this tool before others when many tools exist. It also implies the tool is for discovery, not execution.

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 that the tool returns pipeworx:// citation URIs for all data, and that it bundles multiple data sources into one call. It does not mention any destructive actions or specific authorization needs, but the description is sufficiently transparent about the tool's 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, consisting of two sentences. The first sentence states the purpose and lists the data sources. The second sentence provides a direct command to use an alternative tool for federal contracts and a practical tip. 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 complexity—bundling many data sources—and the absence of an output schema, the description does a good job explaining what is returned (citation URIs) and what data types are included. It also mentions the alternative for federal contracts. It might benefit from noting potential response size or timeout considerations, but overall it is complete enough.

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

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

The input schema has 100% coverage with descriptions, and the description adds significant value beyond the schema: it specifies that 'value' can be a ticker or CIK (not names), and explicitly states that type only supports 'company'. This prevents misuse and provides critical usage context.

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

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

The description clearly states the tool's function: returning a full entity profile across multiple Pipeworx packs. It lists specific data sources (SEC filings, XBRL, patents, news, LEI) and explicitly mentions it replaces 10-15 sequential calls, which distinguishes it from sibling tools like resolve_entity and usa_recipient_profile.

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

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

The description provides explicit guidance on when to use the tool (for a comprehensive profile of an entity) and when not to use it (for federal contracts, use usa_recipient_profile directly). It also advises using resolve_entity first if only a name is available, offering clear context for proper 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?

No annotations provided, so description must cover behavioral aspects. It states 'Delete' indicating mutation but does not disclose if deletion is permanent, if authorization is needed, or any side effects. Lack of output schema also leaves return value ambiguous.

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, no wasted words. Clearly conveys 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?

Given low complexity (1 param, no output schema, no annotations), the description is minimally complete: it says what it does. However, missing behavioral details (e.g., confirmation, error cases) could be improved for a deletion 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% and schema already describes 'key' as 'Memory key to delete'. Description does not add extra meaning beyond confirming the key identifies the memory to delete.

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 verb 'Delete' and the resource 'stored memory by key', distinguishing it from siblings like 'remember' (store) and 'recall' (retrieve).

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 vs alternatives like 'recall' or 'remember'. The description implies it deletes a specific memory by key but does not mention prerequisites or caution (e.g., deletion is irreversible).

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 states it returns 'full contact details', which is useful, but does not mention authentication requirements, rate limits, or error behavior. Since it's a read operation, the description is adequate but not rich.

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

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

The description is a single sentence that conveys the essential purpose and scope. Every word is necessary 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 the simple read operation with no output schema, the description is minimally complete. However, it lacks details like the structure of the returned contact details or error handling, but for a straightforward GET, it is adequate.

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

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

Schema coverage is 100%, so baseline is 3. The description adds no additional meaning beyond the schema for the parameters; it simply restates 'by ID' which matches the 'id' field.

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

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

The description uses a specific verb ('Get') and resource ('Freshdesk contact by ID'), and clearly states the scope ('single'). It distinguishes itself from siblings like freshdesk_list_contacts and freshdesk_get_ticket.

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 when you have a contact ID, but does not explicitly state when not to use it (e.g., for listing contacts, use freshdesk_list_contacts) or provide 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 provided, the description carries the full burden of behavioral disclosure. It indicates that the tool returns full ticket details including conversations, but does not disclose any side effects, authentication requirements beyond the obvious API key, rate limits, or error behaviors. The description is accurate 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 sentence that is concise and front-loaded with the essential purpose. Every word is meaningful and there is no wasted 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 low complexity (simple get by ID) and good schema coverage, the description is adequate but lacks details about error cases or what happens if the ticket doesn't exist. With no output schema, the description could be more helpful by describing the structure of the returned ticket details.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add any extra meaning beyond the parameter names and types in the schema. The schema already documents that id is a number and the required authentication 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 (Get), resource (a single Freshdesk ticket), and identifier (by its ID). It also mentions what is returned (full ticket details including conversations), which distinguishes it from sibling tools like freshdesk_list_tickets and freshdesk_search_tickets that return multiple tickets.

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 does not explicitly state when to use this tool versus alternatives. However, since the name and description clearly indicate it fetches a single ticket by ID, it is implicitly appropriate when you have a specific ticket ID. No explicit when-not or alternative tool 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 are empty, so the description must carry the behavioral burden. It mentions pagination support, which is helpful, but does not disclose any other behaviors like rate limits, idempotency, or response size. With no annotations, a score of 3 is appropriate as it provides some but not full transparency.

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

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

The description is very concise at two sentences. It is front-loaded with the main purpose. However, it could include more useful information without being verbose, so not a perfect 5.

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

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

Given there is no output schema, the description does not explain the return value or structure. The tool has 4 parameters (2 required) and the description only covers pagination. It is minimally complete for a simple list operation but lacks detail on the output format.

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%, meaning all parameters are documented in the schema. The description adds no additional meaning beyond the schema. It mentions pagination generally but does not clarify the purpose of page vs. per_page parameters. A score of 2 reflects that the description adds minimal value over the schema.

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

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

The description states 'List contacts from Freshdesk' which clearly indicates the verb (list) and resource (contacts). However, it does not distinguish itself from sibling tools like freshdesk_get_contact or freshdesk_list_tickets. The purpose is clear but lacks differentiation.

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?

There is no guidance on when to use this tool vs. alternatives. For example, it does not mention that freshdesk_get_contact is for a single contact or that freshdesk_search_tickets is for searching tickets. The description only mentions pagination but no context on when 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 provided, so description carries burden. Description is adequate but lacks disclosure of rate limits, data freshness, or error behaviors. Provides basic filtering and pagination info but not full behavioral traits.

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

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

One short sentence that clearly states purpose and key features. No unnecessary words, but could add more detail 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?

Tool has 7 parameters (moderate complexity) and no output schema. Description covers main aspects but omits details like default values and sort options that are in the schema. Lacks explanation of response structure.

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. However, description adds no value beyond schema; it only mentions filtering and pagination generically without explaining parameter specifics like order_by values or filter options. Does not compensate for low-coverage scenario.

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

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

States it lists tickets from Freshdesk and supports filtering by status, priority, and pagination. Clearly identifies the resource (tickets) and action (list). Differentiates from sibling tools like freshdesk_search_tickets by emphasizing listing with predefined filters.

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 freshdesk_search_tickets or other listing tools. Does not specify prerequisites beyond API key and domain.

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 any behavioral traits such as rate limits, authentication requirements beyond what's in schema, or whether searches are case-sensitive. The description only explains the query syntax, missing other important behavioral context.

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

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

The description is two sentences, front-loaded with purpose, and no wasted words. It efficiently conveys the core functionality and gives an example of the query syntax.

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

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

Given the tool's moderate complexity (3 parameters, no output schema), the description is adequate but not complete. It explains the query parameter well but does not mention the return format, pagination, or any limitations. The sibling list shows similar search tools exist, but no comparison is provided.

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 minimal value beyond the schema: it mentions 'query string' and 'Freshdesk filter syntax' which is already in the schema's description. It does not explain the _apiKey and _domain parameters, but those are self-explanatory from their names and 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 action (search), the resource (Freshdesk tickets), and the method (using a query string). It distinguishes itself from siblings like freshdesk_list_tickets and freshdesk_get_ticket by specifying that it supports Freshdesk filter syntax for complex queries.

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

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

The description implies when to use this tool (for searching with filter syntax) but does not explicitly state when not to use it or mention alternatives among siblings. For example, it doesn't clarify that for simple listing, freshdesk_list_tickets might be more appropriate.

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

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

Discloses rate limit of 5 messages per identifier per day. No annotations provided, so description carries burden; no contradictions. Could mention asynchronous processing but 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 concise sentences, front-loaded with purpose, each adding essential info: use cases, content rules, rate limits. 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?

Covers all schema parameters, usage context, and constraints. No output schema, but feedback tool doesn't require return value explanation. Very good completeness for the tool's simplicity.

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

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

Schema has 100% coverage with descriptions. Description adds value by specifying message format (1-2 sentences, 2000 chars max) and content guidance 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 action ('Send feedback') and the specific purposes (bug reports, feature requests, missing data, praise), distinguishing it from sibling tools like ask_pipeworx which are for queries.

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 use cases and provides content guidelines (describe in Pipeworx terms, avoid end-user prompt) and rate limit. Lacks explicit when-not-to-use, but sufficient given sibling context.

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

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

Annotations indicate read-only and non-destructive behavior. Description adds context: walks child markets, searches across events, groups them, checks monotonicity, returns ranked opportunities. 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 well-structured, front-loads purpose, explains modes concisely. A bit lengthy but 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?

Complete for a complex tool with two modes. Covers input parameters, mode selection, output (ranked opportunities with reasoning). No output schema, so description adequately describes returns.

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

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

Schema has 100% coverage but description adds critical meaning: links parameters to modes, explains that event takes slug/URL and topic takes seed question, and describes what each mode does with the parameter.

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

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

Description clearly states it finds arbitrage opportunities via monotonicity violations. Specifies two modes ('event' and 'topic') with examples. Distinguishes from sibling tools, none of which target 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?

Explicitly explains when to use each mode: event mode for a single event, topic mode for cross-event. Gives reasoning why cross-event is needed (Polymarket splits cutoffs into separate events).

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 provides rich behavioral context beyond annotations: it details data sources (FRED, coinpaprika), process steps (group by asset, fetch price history once, compute model probability, rank by edge), and scope (V1 covers crypto-price bets). This fully discloses how the tool operates.

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

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

The description is informative and well-structured, but slightly verbose. Every sentence adds value, but could be tightened slightly. It front-loads the core functionality and then explains details, which is good.

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

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

Given the tool's complexity (multiple steps, external data sources, ranking), the description is very complete. It explains the inputs, process, and output (top N ranked with direction). No output schema exists, but the description sufficiently describes what to expect.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add additional detail for individual parameters beyond what the schema provides (e.g., limit, window, min_edge_pp are already well-described). The overall context is helpful but not extra per-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 clearly states the tool's purpose: scanning high-volume Polymarket markets and ranking by disagreement between Pipeworx data and market price. It specifies the model (lognormal from FRED + coinpaprika) and the use-case (discovering betting opportunities). The purpose is distinct from siblings 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 explicitly targets the 'what should I bet on today' question, guiding agents to use this tool for opportunity discovery. It implies when to use (to avoid manual browsing), but does not explicitly contrast with siblings or state when not to use. This is still 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?

No annotations provided, so description carries full burden. It discloses the two modes (by key vs list all) and indicates persistence across sessions ('saved earlier in the session or in previous sessions'). However, it doesn't mention if retrieval is destructive, requires authentication, or has any side effects. Without annotations, a 3 is fair.

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, no fluff. First sentence states the core action, second sentence adds usage context. Efficient 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 the tool's simplicity (1 optional param, no output schema, no nested objects), the description covers the essential behavior: retrieval modes and persistence. Missing details like return format or error handling, but complexity is low enough that this is mostly complete.

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

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

Schema coverage is 100% for the single parameter 'key'. Description adds context that omitting the key lists all memories, but otherwise repeats what schema says (key is memory key). With full schema coverage, 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?

Clearly states the verb ('Retrieve'/'list'), resource ('stored memory'), and dual behavior: retrieve by key or list all when key omitted. Distinguishes from sibling 'remember' (store) and 'forget' (delete) by focusing on retrieval.

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

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

Describes when to use (retrieve context saved earlier) and includes implicit guidance: omit key to list all. No explicit when-not or alternatives to other tools, but the purpose is narrow enough that exclusion is clear.

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

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

With no annotations provided, the description fully discloses behavior: it fans out to multiple sources in parallel, accepts ISO and relative date formats, and returns structured changes with a count and URIs. No destructive behavior is implied, and all key traits are 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?

The description is three sentences with no wasted words. The first sentence states the core purpose and parallel fan-out, the second explains the date format, and the third describes the output and use cases. Information is front-loaded and well-structured.

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

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

Given the tool's moderate complexity (3 parameters, no output schema), the description covers the return format (structured changes, count, URIs) and parameter details. It could optionally mention error handling for unrecognized entities, but overall it is comprehensive enough for correct invocation.

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

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

The input schema has 100% coverage, so the baseline is 3. The description adds meaning beyond the schema by providing examples for 'since' (ISO, relative), clarifying 'type' is limited to 'company', and explaining 'value' accepts ticker or CIK. This elevates the score to 4.

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

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

The description clearly states the tool's purpose: 'What's new about an entity since a given point in time.' It specifies the behavior for type='company' (fanning out to SEC EDGAR, GDELT, USPTO) and provides example use cases ('brief me on what happened with X'), effectively distinguishing it from sibling tools like entity_profile.

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

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

The description explicitly gives usage guidance: 'Use for 'brief me on what happened with X' or change-monitoring workflows.' It provides context but does not explicitly mention when not to use or list alternatives, which is acceptable given the clear purpose.

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 authenticated users get persistent memory while anonymous sessions last 24 hours. This adds behavioral context beyond annotations (none provided). It could also mention that values are overwritten on duplicate keys, but the key field description hints at unique keys.

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

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

The description is two sentences long, front-loads the core purpose, and adds useful context about persistence. 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 the tool's simplicity (two required string parameters, no output schema), the description is complete. It explains purpose, use cases, and persistence behavior. Could mention that values are overwritten on duplicate keys, but this is minor.

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 describes both parameters (key and value) with examples, achieving 100% schema coverage. The description adds no further parameter semantics beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool stores a key-value pair in session memory. It specifies the verb 'store' and the resource 'session memory', distinguishing it from sibling tools like 'recall' (retrieve) and 'forget' (delete).

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

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

The description explains when to use it: to save intermediate findings, user preferences, or context across tool calls. It also provides context on persistence (authenticated vs anonymous). However, it does not explicitly say when not to use it or mention alternatives like 'recall' or 'forget'.

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 for behavioral disclosure. It does not mention whether the tool is read-only, idempotent, or has side effects. It also lacks details on error handling, rate limits, or authorization requirements.

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

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

The description is two sentences, front-loaded with the main purpose, and provides key details without waste. Every sentence adds value.

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

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

For a simple tool with two parameters and no output schema, the description adequately covers purpose, inputs, and outputs. However, it lacks information on error cases, prerequisites, or usage examples, which would enhance completeness.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds context on accepted formats (ticker, CIK, name) but does not significantly expand beyond the schema. Baseline 3 is appropriate.

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

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

Description clearly states the tool resolves an entity to canonical IDs, specifies the entity type (company) and accepted inputs (ticker, CIK, name), and describes the output (ticker, CIK, company name, resource URIs). It also distinguishes from siblings by noting it replaces multiple lookup 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 implies use when needing canonical IDs for an entity and highlights efficiency ('in a single call', 'Replaces 2–3 lookup calls'). However, it does not explicitly state when not to use or compare to alternatives, though sibling tools do not offer similar functionality.

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 provides a comprehensive overview of the tool's behavior: it fact-checks via SEC EDGAR+XBRL, returns specific verdicts and details. Since no annotations are provided, the description adequately conveys the tool's operation. It could be improved by noting limitations (only US public companies financial claims), but that is implicit in the 'supports company-financial claims...' statement.

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 (two sentences) and packs essential information: purpose, supported domain, data source, output, and benefit (replaces multiple calls). 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?

With no output schema, the description fully explains the return values (verdict, structured form, actual value with citation, percent delta). It also covers the input param and the tool's benefit. For such a simple tool, the description is complete and enables correct 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?

The schema already defines 'claim' with a description and example. The tool description reinforces the domain (company-financial claims) and explains that the claim is interpreted by the tool to extract structured form and compare. It adds value by explaining the process and expected input format, which helps the agent formulate good claims.

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: fact-checking natural-language claims, with explicit domain (company-financial claims for US public companies) and data source (SEC EDGAR+XBRL). It also mentions the returned verdict types, distinguishing it from other tools that may perform data retrieval or comparison without verification.

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 suggests this tool should be used instead of sequential agent calls for fact-checking, providing a clear use case. However, it does not explicitly state when not to use (e.g., for non-financial claims) or list alternative tools for different domains. Nonetheless, the guidance is adequate for an agent to decide to use it for financial fact-checking.

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