emojihub

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 describes key behavioral traits: the tool picks the right data source, fills arguments, and returns results. However, it doesn't disclose limitations like rate limits, authentication needs, error conditions, or what happens with ambiguous questions. For a tool with no annotations, this leaves significant gaps in understanding its operational 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 efficiently structured: the first sentence states the core functionality, the second explains the automation benefit, and the third provides concrete examples. Every sentence adds value without redundancy. It's appropriately sized for a single-parameter tool with a clear high-level purpose.

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

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

Given the tool's complexity (natural language processing with backend automation) and lack of both annotations and output schema, the description is moderately complete. It explains what the tool does and when to use it, but doesn't address what the output looks like, error handling, or limitations. For a tool that could return varied results from different data sources, more context about response format would be helpful.

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

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

Schema description coverage is 100%, so the schema already documents the single 'question' parameter. The description adds meaningful context by emphasizing 'plain English' and 'natural language,' and provides examples that illustrate the expected input format. This goes beyond the schema's basic documentation, though it doesn't add detailed syntax rules.

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: 'Ask a question in plain English and get an answer from the best available data source.' It specifies the verb ('ask'), resource ('answer from data source'), and distinguishes from siblings by emphasizing natural language processing instead of browsing tools or learning schemas. The examples further clarify the scope.

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 this tool: 'No need to browse tools or learn schemas — just describe what you need.' It contrasts with sibling tools like 'discover_tools' or 'get_by_category' by positioning this as a high-level query interface. The examples provide concrete use cases, making it clear this is for natural language questions rather than structured queries.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, indicating safety. The description adds behavioral details: classification, fan-out to packs, and return of evidence packet and comparison. No contradictions. Minor gap: no mention of error handling or rate limits, but overall 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 front-loaded with action and input spec. It is somewhat verbose but every sentence adds value. Could be slightly trimmed, but structure is logical and informative.

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

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

Given no output schema, the description adequately describes the return (evidence packet and comparison). It covers input, process, output, and use cases. With high schema coverage and good annotations, the description is sufficiently 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% (both parameters described). The description adds value by explaining that 'market' can be slug, URL, or question text, and that 'depth' has quick/thorough with default thorough. This enriches the schema definitions.

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

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

The description clearly states the tool researches Polymarket bets using Pipeworx data. It specifies the verb 'research' and the resource 'bet', and distinguishes itself as the core demo product, implying specialization. The purpose is unambiguous.

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

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

The description explicitly provides usage examples: 'should I bet on X?', 'what does the data say?', 'is there edge?'. It also suggests this tool is preferred over having agents discover packs themselves, offering clear when-to-use guidance.

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

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

No annotations are provided, so the description carries full burden. It discloses that it returns paired data and pipeworx:// URIs, but does not mention read-only/destructive nature, authentication, rate limits, or error states. The disclosure is partial.

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 the main purpose, then type-specific details. No redundant 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?

The description is fairly complete given the lack of output schema: it explains the return format (paired data + URIs) and the entities handled. However, it lacks details on error handling or what happens with invalid input.

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 value by enumerating the specific data fields for each type (e.g., revenue, net income for companies) and providing example formats, which goes 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 compares 2-5 entities, specifies the two allowed types (company, drug), and lists the data fields for each. It distinguishes from sibling tools by its comparison function.

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

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

The description mentions it 'replaces 8-15 sequential agent calls', implying efficiency gains, but does not explicitly state when not to use it or provide alternative tool references. The usage context is clear but lacks 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 the full burden of behavioral disclosure. It effectively describes the tool's search behavior and return format (tools with names and descriptions), but lacks details on performance aspects like rate limits, error handling, or authentication requirements. The guidance to 'Call this FIRST' hints at efficiency but doesn't specify why.

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 perfectly concise and well-structured in two sentences. The first sentence states the purpose and mechanism, while the second provides crucial usage guidance. Every word earns its place with no redundancy or fluff, making it highly efficient for an AI agent.

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 (search functionality with 2 parameters) and the absence of both annotations and an output schema, the description does a good job covering essential context. It explains what the tool does, when to use it, and the return format, though it could benefit from mentioning potential limitations or the structure of returned data more explicitly.

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

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

The schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., it mentions 'describing what you need' which aligns with the query parameter but provides no additional syntax or format details). Baseline 3 is appropriate when the schema does the heavy lifting.

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 with specific verbs ('Search the Pipeworx tool catalog') and resource ('tool catalog'), and explicitly distinguishes it from siblings by emphasizing it's for natural language search rather than categorical or random retrieval. The phrase 'Returns the most relevant tools with names and descriptions' further clarifies the output.

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 this tool ('Call this FIRST when you have 500+ tools available and need to find the right ones for your task'), including a specific threshold (500+ tools) and context (finding tools for a task). It implicitly suggests alternatives by contrasting with sibling tools like get_by_category and get_by_group through its natural language search approach.

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 that the tool aggregates multiple sources, returns pipeworx:// citation URIs, and notes performance (too slow to bundle federal contracts). Missing details on error handling or data freshness, but sufficient given the profile nature.

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?

Concise single paragraph with front-loaded purpose. Three sentences cover definition, data types, and usage caveat. No wasted words.

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

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

Given no output schema, description adequately explains what the tool returns (URIs, specific data categories). Addresses limitations (only company, ticker/CIK vs name) and provides alternative for federal contracts. Complete for a profile aggregation 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?

Adds meaning beyond schema: explains that 'value' accepts ticker or zero-padded CIK, and importantly warns that names are not supported, directing to resolve_entity. Schema coverage is 100%, but description provides actionable guidance.

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

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

Clearly states it returns a full profile of an entity from multiple Pipeworx packs in one call. Lists specific data types (SEC filings, revenue, patents, news, LEI) and mentions replacing 10–15 agent calls. Distinguishes from sibling by hinting at alternative usa_recipient_profile for federal contracts.

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

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

Explicitly tells when to use this tool (company profile) and when not (federal contracts → use usa_recipient_profile). Also advises to use resolve_entity for names instead of ticker/CIK. Provides clear context on 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool performs a deletion, implying it's destructive, but doesn't clarify if the deletion is permanent, reversible, or requires specific permissions. It also omits details like error handling (e.g., what happens if the key doesn't exist) or side effects. For a destructive operation with zero annotation coverage, this leaves significant gaps in understanding 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 a single, clear sentence with zero wasted words. It's front-loaded with the core action ('Delete') and resource, making it immediately understandable. Every word earns its place, and there's no unnecessary elaboration or redundancy, achieving optimal conciseness for a simple tool.

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 destructive nature, lack of annotations, and absence of an output schema, the description is incomplete. It doesn't address critical context such as what 'stored memory' entails in this system, whether deletion has confirmation steps, what the return value or success/failure indicators are, or how it interacts with sibling tools. For a mutation tool with no structured safety or output information, the description should provide more behavioral and contextual details.

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

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

The input schema has 100% description coverage, with the 'key' parameter fully documented in the schema itself ('Memory key to delete'). The description adds no additional meaning beyond this, as it only restates that the tool deletes 'by key'. Given the high schema coverage, the baseline score of 3 is appropriate, as the schema already provides adequate parameter semantics without needing extra description.

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

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

The description clearly states the action ('Delete') and resource ('a stored memory by key'), making the purpose immediately understandable. It distinguishes from siblings like 'recall' (retrieve) and 'remember' (store), though it doesn't explicitly name these alternatives. The description is specific but could be slightly more precise about what constitutes a 'stored memory' in this 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing memory key), exclusions, or compare it to sibling tools like 'recall' (for retrieval) or 'remember' (for storage). The agent must infer usage from the name and purpose alone, which is insufficient for optimal tool selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states what the tool does without mentioning behavioral traits like whether it's read-only, if there are rate limits, error handling, or output format. For a tool with no annotations, this is insufficient 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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by relevant examples. Every sentence earns its place by clarifying the tool's function without unnecessary details, making it efficient for agent comprehension.

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 low complexity (1 parameter, no output schema, no annotations), the description is minimally complete. It explains what the tool does and provides examples, but lacks details on output format, error cases, or sibling tool differentiation. This is adequate but has clear gaps in 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?

The input schema has 100% description coverage, so the schema already documents the 'category' parameter fully. The description adds example categories (e.g., 'smileys-and-people'), which provides some semantic context beyond the schema, but doesn't elaborate on format or constraints. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Get all emojis in a given category.' It specifies the verb ('Get') and resource ('emojis'), and provides example categories to clarify scope. However, it doesn't explicitly differentiate from sibling tools like 'get_by_group' or 'random_emoji', which would require a 5.

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 no guidance on when to use this tool versus alternatives. It lists example categories but doesn't mention sibling tools or contexts where this tool is preferred over 'get_by_group' or 'random_emoji'. This leaves usage decisions ambiguous for the agent.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It describes what the tool does but doesn't address important behavioral aspects like whether this is a read-only operation, what format the output takes, error handling, or rate limits. The description is functional but lacks operational 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 perfectly concise - a single sentence stating the purpose followed by helpful examples. Every word earns its place with zero waste or redundancy. The structure is front-loaded with the core functionality.

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 read operation with one parameter and no output schema, the description is adequate but minimal. It explains what the tool does but doesn't address return format, error cases, or how results are structured. Given the simplicity of the tool, it meets minimum requirements but could provide more operational 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 the schema already fully documents the single 'group' parameter. The description adds value by providing concrete examples of valid group slugs ('face-positive', 'face-negative', etc.), but doesn't add semantic meaning beyond what the schema provides. Baseline 3 is appropriate when schema does the heavy lifting.

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') and resource ('all emojis in a given group'), making the purpose unambiguous. It distinguishes from 'get_by_category' by specifying groups rather than categories, but doesn't explicitly contrast with 'random_emoji'.

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 through the example groups provided, suggesting this tool is for retrieving emojis by specific group types. However, it doesn't explicitly state when to use this versus 'get_by_category' or 'random_emoji', nor does it provide exclusion criteria.

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

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

With no annotations, the description provides some behavioral context: rate-limiting (5 per day per identifier) and a content restriction (no end-user prompt). However, it does not disclose what happens after submission (e.g., confirmation, storage, or response) or any side effects.

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

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

The description is three sentences long, front-loaded with the main purpose, and every sentence provides essential information (purpose, content guidance, rate limit). No extraneous words.

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

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

Given no output schema, the description does not explain what happens after feedback is sent (e.g., confirmation, acknowledgment). It adequately covers input and constraints but lacks output behavior. For a feedback tool, this might be acceptable but still a 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 description coverage is 100%, so baseline is 3. The description adds minimal value beyond the schema: it reiterates the need to describe in terms of Pipeworx tools, but the schema already asks for specificity. The enum values are well-documented in the schema.

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

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

The description clearly states the tool sends feedback to the Pipeworx team and enumerates specific use cases (bug reports, feature requests, missing data, praise). It distinguishes itself from sibling tools like ask_pipeworx or compare_entities by focusing on feedback rather than queries or comparisons.

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 (for feedback types) and provides content guidance (describe in terms of Pipeworx tools/data, avoid end-user prompt). It also notes the rate limit. However, it does not explicitly exclude alternative tools like ask_pipeworx for questions, but the purpose is clear enough.

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

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

Adds behavioral details beyond annotations: walks child markets, extracts dates/thresholds, reports arbitrage pairs. No contradiction with annotations (readOnlyHint, openWorldHint, destructiveHint).

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

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

Descriptive but slightly lengthy; front-loads purpose. Every sentence adds value, but could be tightened slightly.

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 one parameter, no output schema, and annotations, the description comprehensively explains input, logic, and 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?

Only one parameter 'event' with 100% schema coverage. Description adds context on how the parameter is used (to walk child markets). Baseline is 3 for high coverage, but description adds value.

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

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

Description clearly states tool finds arbitrage opportunities by checking monotonicity violations in Polymarket event child markets. It explains the logic and distinguishes from siblings like polymarket_edges.

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?

Explains when to use: when an event has multiple date/threshold markets. Does not explicitly state when not to use, but context is clear. No alternatives mentioned, but sibling tools are distinct.

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

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

The description adds significant context beyond annotations: it explains the underlying model (lognormal from FRED + coinpaprika), the process (grouping by asset, fetching price history once), and the ranking mechanism. Annotations already declare readOnlyHint=true and destructiveHint=false, which align with the description. No contradiction is present.

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, starting with the core purpose and then detailing the model and process. It is somewhat lengthy but every sentence adds value. Could be slightly more concise, but it effectively communicates the tool's workings without superfluous 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 (multiple markets, model, grouping), the description provides a complete overview: it covers the data sources, the algorithm for computing edge, the ranking, and the output format. No output schema exists, but the description compensates by stating it returns top N with trade direction.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds value by explaining how parameters affect results: limit returns top N after ranking, window filters volume, min_edge_pp sets minimum edge. It also mentions defaults and max for limit, which are not in schema descriptions. This clarifies the ranking 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 purpose: scan high-volume Polymarket markets and return those where Pipeworx data disagrees most with market price. It specifies the scope (crypto-price bets), model (lognormal from FRED + coinpaprika), and output (top N ranked by |edge|). This distinguishes it from siblings like polymarket_arbitrage, which likely focuses on arbitrage opportunities.

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 frames the tool for the 'what should I bet on today' question, guiding agents to discover opportunities without manual browsing. It mentions the model scope (crypto-price bets) and default settings, providing clear context for when to use it. However, it does not explicitly mention when not to use it or compare to alternatives like bet_research.

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 but only states what the tool does without behavioral details. It doesn't disclose whether this is a read-only operation, if it has rate limits, authentication requirements, or what the return format looks like (e.g., single emoji vs. data structure).

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, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized for a simple tool and front-loads the essential information without any structural issues.

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 zero-parameter tool with no output schema, the description is minimally adequate but lacks completeness. It doesn't explain the return value (e.g., what 'get a random emoji' actually returns—just the emoji character, or a JSON object with metadata?), and with no annotations, more behavioral context would be helpful for proper agent 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 tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, earning a baseline score of 4 for not adding unnecessary information beyond what the schema already covers perfectly.

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') and resource ('a random emoji from the EmojiHub API'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'get_by_category' or 'get_by_group', which would require mentioning it returns completely random emojis without filtering criteria.

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 is provided on when to use this tool versus alternatives. The description doesn't mention its siblings ('get_by_category' and 'get_by_group') or explain that this tool should be used when no specific category or group filtering is needed, leaving usage context unclear.

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 describes the core behavior (retrieve/list) and persistence across sessions, but lacks details on error handling (e.g., what happens if key doesn't exist), return format, or any limitations like memory size or access controls. It adds some context but is 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?

Two sentences with zero waste: first states the tool's dual functionality, second provides usage context. Front-loaded with core purpose, and every sentence adds value (e.g., linking to session persistence). Efficient 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 no annotations, no output schema, and a simple input schema, the description is mostly complete for a retrieval tool. It covers purpose, usage, and parameter semantics adequately. However, it lacks details on return values or error cases, which would be helpful since there's no output schema.

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

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

Schema description coverage is 100%, so the schema already documents the optional 'key' parameter. The description adds meaningful semantics by explaining the dual functionality: with key for specific retrieval, without key for listing all. This clarifies the parameter's role beyond the schema's technical description.

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

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

The description clearly states the tool's purpose with specific verbs ('retrieve', 'list') and resources ('previously stored memory by key', 'all stored memories'). It distinguishes from siblings by mentioning retrieval of saved context, unlike 'remember' (store) or '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?

Explicitly states when to use ('retrieve context you saved earlier') and provides clear alternatives: use with key to retrieve specific memory, omit key to list all. This directly addresses the parameter behavior and distinguishes from other retrieval siblings like 'get_by_category' or 'get_by_group'.

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 discloses fan-out behavior (SEC, GDELT, USPTO in parallel for type='company'), return structure (structured changes, count, URIs), and input formats. Missing details on rate limits or authentication, but the key behaviors 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 approximately 100 words, efficiently front-loading the core purpose, then detailing fan-out, parameter constraints, and return format. Every sentence adds value, and the structure is logical and easy to parse.

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 adequately explains return values (structured changes, count, URIs). It covers all three parameters with usage examples, addresses multiple possible use cases ('brief me', monitoring), and handles edge cases (relative dates). No gaps are evident.

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%, yet the description adds meaning beyond the schema: it explains that 'since' accepts ISO or relative strings with examples ('7d', '30d'), that 'type' is restricted to 'company', and that 'value' can be a ticker or CIK. This significantly aids correct parameter selection.

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

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

The description explicitly states 'What's new about an entity since a given point in time' with a specific verb ('get changes') and resource ('entity timeline'), and differentiates from sibling tools like entity_profile by focusing on temporal changes.

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

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

The description provides clear usage context: 'Use for "brief me on what happened with X" or change-monitoring workflows' and explains when to use ISO dates vs relative ones. No explicit exclusion or alternative tools are mentioned, but the guidance is specific enough.

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 effectively describes key traits: the storage behavior, persistence differences for authenticated vs. anonymous users (authenticated get persistent memory, anonymous sessions last 24 hours), and the cross-tool context utility. It does not cover potential limitations like storage limits or error conditions, but the disclosed traits are valuable for agent decision-making.

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 appropriately sized and front-loaded, with the first sentence stating the core purpose. The second sentence adds usage context, and the third provides important behavioral details (authentication effects). Every sentence earns its place by contributing essential information without redundancy or fluff.

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

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

Given the tool's moderate complexity (storage with authentication nuances), no annotations, and no output schema, the description is largely complete. It covers purpose, usage, and key behavioral traits. However, it does not specify what happens on success (e.g., confirmation message) or failure (e.g., error cases like duplicate keys), leaving minor gaps. For a tool with 2 parameters and no output schema, it does well but could be more comprehensive.

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 description coverage is 100%, so the schema already documents both parameters ('key' and 'value') with descriptions and examples. The description does not add any additional meaning or syntax details beyond what the schema provides (e.g., it mentions 'key-value pair' but doesn't elaborate further). According to the rules, with high schema coverage, the baseline is 3 even with no param info in the description.

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

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

The description explicitly states the action ('Store a key-value pair') and resource ('in your session memory'), making the purpose clear. It distinguishes from sibling tools like 'recall' (likely for retrieval) and 'forget' (likely for deletion) by focusing on storage. The examples ('save intermediate findings, user preferences, or context across tool calls') further clarify the specific use case.

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

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

The description provides clear context on when to use this tool ('to save intermediate findings, user preferences, or context across tool calls'), which helps guide its application. However, it does not explicitly mention when not to use it or name alternatives (e.g., how it differs from 'recall' or 'forget'), though the purpose implies differentiation. This is sufficient for effective usage but lacks explicit exclusions.

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

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

No annotations provided, so description carries the burden. It discloses return fields and benefit, but does not mention idempotency, side effects, or authentication 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?

Three sentences, each adding essential information: purpose, details, benefit. No redundant or extraneous content.

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

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

Given simplicity (2 params, no output schema, no annotations), description adequately covers purpose, parameter interpretations, and return values. No missing critical elements.

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

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

Schema coverage is 100%, baseline 3. Description adds value by explaining the value parameter accepts ticker, CIK, or name with examples, and clarifies the type enum meaning.

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 verb (resolve) and resource (entity to canonical IDs), provides specific example for company type, and distinguishes from alternatives 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?

Gives context that 'v1 supports company' and explains input formats, but does not explicitly mention when not to use or name alternatives among sibling tools.

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

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

No annotations provided, so description carries full burden. Discloses return elements (verdict, structured form, actual value with citation, percent delta) and scope (v1 supports only company-financial claims). Could mention limitations more explicitly.

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 well-structured sentences: first sentence states purpose and scope, second lists returns and value. Front-loaded and dense with information.

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

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

For a single-parameter tool with no output schema, the description adequately covers purpose, scope, inputs, and outputs. No additional context is needed.

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

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

Schema coverage is 100% with a description for the claim parameter. Description adds examples but adds minimal meaning 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 fact-checks natural-language claims against authoritative sources, focusing on company-financial claims via SEC EDGAR + XBRL. It distinguishes itself by noting it replaces 4-6 sequential agent calls, differentiating from siblings.

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

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

Explicitly states when to use (fact-checking claims, especially financial) and what it replaces, but does not explicitly mention when not to use or compare to siblings like compare_entities or resolve_entity.

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