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

Annotations already indicate read-only, non-destructive, and idempotent behavior, but the description adds valuable context by specifying what information is returned (signature, parameters with types, return type, docstring) and that it's for strategy callbacks. This enhances transparency beyond annotations, though it doesn't mention rate limits or authentication needs.

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

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

The description is front-loaded with the core purpose, followed by clear sections for 'Args' and 'Returns'. Every sentence adds value: the first defines the tool, the second details the output, and the parameter/return sections provide essential usage info 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 low complexity (1 parameter), rich annotations (covering safety and idempotency), and the presence of an output schema (which handles return values), the description is complete enough. It explains the purpose, parameter semantics, and output content, leaving no significant gaps for the agent to operate effectively.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining that 'callback_name' refers to a strategy callback method (e.g., 'bot_start', 'custom_stoploss'), which clarifies the parameter's purpose beyond the schema's generic 'string' type. However, it doesn't provide a full list of valid callbacks or formatting details.

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 specific action ('Get detailed info') and resource ('about a strategy callback method'), distinguishing it from siblings like 'freqtrade_get_method_signature' (general methods) and 'freqtrade_list_strategy_methods' (listing only). It explicitly names example callbacks (e.g., 'bot_start', 'custom_stake_amount'), making the purpose concrete and differentiated.

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

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

The description implies usage context by specifying it's for strategy callbacks and listing examples, but it doesn't explicitly state when to use this tool versus alternatives like 'freqtrade_get_method_signature' (which might handle non-callback methods) or 'freqtrade_get_doc' (which might provide broader documentation). It provides clear context but lacks explicit exclusions or named alternatives.

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

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

Annotations provide read-only, non-destructive, and idempotent hints, which the description does not contradict. The description adds valuable context by specifying the scope ('any freqtrade class') and the types of information returned (docstring, MRO, methods, attributes), which goes beyond the annotations to clarify the tool's behavior and output 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 front-loaded with the purpose, followed by returns and parameter details in a structured format. Every sentence adds value without redundancy, making it efficient and easy to parse 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 low complexity (1 parameter), rich annotations (read-only, idempotent), and the presence of an output schema, the description is complete. It adequately explains what the tool does, the parameter meaning, and the return content, without needing to detail output values 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?

Schema description coverage is 0%, so the description must compensate. It clearly explains the 'class_path' parameter as a 'fully-qualified class path' with an example ('freqtrade.strategy.interface.IStrategy'), adding essential semantics that the schema lacks. This effectively documents the single parameter, though it could provide more on format constraints.

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 specific action ('Inspect any freqtrade class') and details what information is returned (docstring, MRO, public methods, class-level attributes). It distinguishes itself from siblings like 'freqtrade_get_doc' or 'freqtrade_get_method_signature' by focusing on comprehensive class introspection rather than documentation or specific method details.

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 by specifying it inspects 'any freqtrade class' with a fully-qualified path, but it does not explicitly state when to use this tool versus alternatives like 'freqtrade_get_doc' for documentation or 'freqtrade_list_strategy_methods' for method listings. The context is clear but lacks explicit guidance on exclusions or comparisons.

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 this as a read-only, non-destructive, idempotent operation. The description adds valuable context beyond annotations by specifying the organizational structure ('organized by section') and the filtering capability. It doesn't contradict annotations and provides useful behavioral information about the output format.

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 with a clear purpose statement, usage guidance, and parameter documentation in just a few sentences. Every sentence adds value with no redundant information, and it's appropriately 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?

Given the tool has comprehensive annotations, an output schema, and only one optional parameter, the description provides complete context. It explains what the tool returns, how to use the parameter, and the organizational approach, making it fully adequate for this configuration schema 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?

With 0% schema description coverage, the description fully compensates by explaining the single parameter's purpose ('to filter by a specific config area'), providing examples ('exchange', 'pairlist', 'stoploss'), and clarifying it's optional. This adds significant meaning beyond the bare schema.

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

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

The description clearly states the tool's purpose with specific verbs ('Return', 'Lists') and resource ('freqtrade configuration keys and their descriptions'). It distinguishes itself from siblings by focusing on configuration schema rather than callbacks, classes, dataframes, documentation, enums, methods, or version info.

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

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

The description provides clear context for when to use the tool ('to filter by a specific config area') and mentions the optional section parameter. However, it doesn't explicitly state when NOT to use it or name specific alternative tools for different needs among the siblings.

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

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

Annotations indicate read-only, non-destructive, and idempotent behavior, which the description aligns with by describing a listing operation. The description adds valuable context beyond annotations: it specifies the return format ('List of DataFrame column entries with descriptions and contexts') and mentions the optional context filter with examples ('ohlcv', 'entry', 'exit', 'indicators'), enhancing transparency about output and filtering 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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by returns and args sections that are directly relevant. Every sentence earns its place by providing essential information without redundancy, structured clearly with labeled sections for Args and Returns.

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 (one optional parameter), rich annotations (readOnlyHint, idempotentHint, etc.), and the presence of an output schema, the description is complete. It explains the tool's purpose, parameter usage, and return format adequately, without needing to detail output values since an output schema exists. It covers all necessary context for effective use.

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

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

The input schema has 0% description coverage, so the description fully compensates by explaining the single parameter 'context' in detail: it's optional, can be 'ohlcv', 'entry', 'exit', or 'indicators', and if omitted returns all known columns. This adds crucial semantics not present in the schema, making it highly valuable for parameter understanding.

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

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

The description clearly states the tool's purpose: 'List common DataFrame columns available in strategy methods' with specific verbs ('List', 'Returns') and resources ('DataFrame columns', 'column names, types, and descriptions'). It distinguishes from siblings like 'freqtrade_list_strategy_methods' by focusing on column metadata rather than method listings.

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

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

The description provides clear context for when to use this tool: for getting column information in strategy methods like 'populate_indicators', 'populate_entry_trend', etc. However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools, such as 'freqtrade_get_method_signature' for method details instead of column details.

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, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description adds useful context beyond this: it specifies that it returns 'full markdown content with title and metadata' and mentions error handling ('or error if not available'), which are not covered by annotations. No contradiction with annotations exists.

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

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

The description is front-loaded with the core purpose, followed by returns, usage guidance, and parameter details in a structured format. Every sentence earns its place with no wasted words, making it efficient 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?

Given the tool's low complexity (single parameter), rich annotations covering safety and behavior, and the presence of an output schema (which handles return values), the description is complete. It covers purpose, usage, parameters, and error cases adequately without needing to explain outputs.

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 0%, so the description must compensate. It explains the 'topic' parameter's purpose ('Topic name') and provides concrete examples (e.g., 'strategy-callbacks', 'configuration'), adding meaningful semantics beyond the bare schema. However, it doesn't detail constraints like format or length, leaving some gaps.

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 specific action ('Read a specific freqtrade documentation page') and resource ('documentation page by topic name'), distinguishing it from siblings like freqtrade_list_docs (which lists topics) and freqtrade_search_docs (which searches content). It avoids tautology by explaining functionality beyond the tool name.

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 when to use this tool ('Read a specific freqtrade documentation page') and when not to ('Use freqtrade_list_docs to discover available topic names'), offering clear alternatives and prerequisites. It guides the agent to first use the sibling tool for topic discovery.

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 provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description adds value by specifying the return format ('Enum details including all member names and values') and clarifying the scope ('Returns every member of the enum'), which isn't covered by annotations. It doesn't contradict annotations, as 'Get' aligns with read-only 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 front-loaded with the core purpose, followed by clear sections for Args and Returns. Each sentence earns its place: the first states the action, the second clarifies the return scope, and the bullet points efficiently document input and output. No wasted words, making it easy to scan and understand.

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 (one parameter), rich annotations (covering safety and idempotency), and the presence of an output schema (implied by 'Has output schema: true'), the description is complete enough. It explains what the tool does, the parameter meaning, and the return content, without needing to detail output structure or behavioral risks already covered by annotations.

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 0%, but the description compensates by explaining 'enum_path' as a 'Fully-qualified enum path' with an example ('freqtrade.enums.signaltype.SignalDirection'). This adds meaning beyond the schema's basic string type. However, with only one parameter and no schema descriptions, the baseline is 3, as the description provides adequate but not extensive parameter 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: 'Get all values of a specific freqtrade enum' with the verb 'Get' and resource 'values of a specific freqtrade enum'. It distinguishes from siblings like 'freqtrade_list_enums' (which likely lists enum names rather than their values) by specifying it returns detailed member information. However, it doesn't explicitly contrast with 'freqtrade_get_class_info' or 'freqtrade_get_method_signature', which might have overlapping 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 implies usage context by specifying 'a specific freqtrade enum' and providing an example path, suggesting it's for retrieving detailed enum metadata. However, it lacks explicit guidance on when to use this tool versus alternatives like 'freqtrade_list_enums' (for listing enum names) or other 'get_' tools. No exclusions or prerequisites are mentioned, leaving usage somewhat open to interpretation.

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

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

Annotations already indicate this is a safe, read-only, idempotent operation (readOnlyHint: true, destructiveHint: false, idempotentHint: true). The description adds valuable context by specifying what information is returned (full signature details including docstring), which goes beyond the annotations. It does not mention rate limits or authentication needs, but the annotations cover the core safety profile adequately.

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

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

The description is front-loaded with the core purpose, followed by structured sections for Args and Returns. Every sentence adds value—none are redundant or verbose. It efficiently communicates essential information without waste.

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

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

Given the tool's low complexity (1 parameter), rich annotations (covering safety and idempotency), and the presence of an output schema (which handles return value details), the description is complete enough. It clearly states what the tool does, what it returns, and the parameter's role, leaving no critical gaps for agent understanding.

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 0% description coverage, but the description compensates by explaining that 'method_name' is the 'Name of the IStrategy method to inspect'. This adds meaning beyond the bare schema. However, it does not provide examples or constraints (e.g., valid method names), leaving some gaps.

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 specific action ('Get full signature') and resource ('a specific IStrategy method'), distinguishing it from siblings like 'freqtrade_list_strategy_methods' (which lists methods) and 'freqtrade_get_doc' (which might get general documentation). It specifies the exact scope of information returned (parameters, types, defaults, return type, docstring).

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 when detailed method signature information is needed, but does not explicitly state when to use this tool versus alternatives like 'freqtrade_get_doc' or 'freqtrade_list_strategy_methods'. It provides clear context (inspecting IStrategy methods) but lacks explicit exclusions or named alternatives.

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

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

Annotations indicate this is a read-only, non-destructive, idempotent operation with a closed world, which the description doesn't contradict. The description adds value by specifying what version information is included (freqtrade-mcp server, freqtrade, Python), which isn't covered by annotations. However, it lacks details on potential errors, response format beyond 'dictionary', or performance considerations, leaving room for improvement.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by details on what's included in the return. It avoids redundancy and wastes no words, though the 'Returns:' section slightly repeats information from the prior sentence. Overall, it's efficiently structured and appropriately sized 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 simplicity (0 parameters, annotations covering safety, and an output schema implied by 'Returns:'), the description is mostly complete. It specifies the types of version info returned, which complements the structured data. However, it could be more explicit about the output format or error cases, slightly reducing completeness for a tool that might be used in diagnostic contexts.

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 the schema fully documents the absence of inputs. The description doesn't need to add parameter semantics, but it correctly avoids mentioning any parameters, aligning with the schema. A baseline of 4 is appropriate since no parameters exist, and the description doesn't mislead about 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 the tool returns version information for freqtrade and the MCP server, with specific mention of freqtrade-mcp server version, installed freqtrade version, and Python version. It distinguishes itself from siblings by focusing on version info rather than configuration, documentation, or codebase queries. However, it doesn't explicitly contrast with specific sibling tools like freqtrade_get_callback_info or freqtrade_get_class_info, which keeps it from a perfect score.

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 scenarios like checking compatibility, troubleshooting, or verifying installations, nor does it reference sibling tools that might serve related purposes. Without any usage context or exclusions, the agent must infer based on the tool name alone.

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 read-only, non-destructive, and idempotent behavior, which the description doesn't repeat. The description adds valuable context beyond annotations: it specifies the return format ('List of doc topic summaries') and error handling ('error message if docs not available'), which are not covered by annotations. No contradiction with annotations exists.

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

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

The description is front-loaded with the core purpose, followed by concise usage guidance, parameter details, and return information. Every sentence adds value without redundancy, and the structure is logical and efficient for quick understanding.

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 (one optional parameter), rich annotations (covering safety and idempotency), and the presence of an output schema (which handles return value details), the description is complete. It covers purpose, usage, parameter semantics, and error cases adequately without needing to explain return values in depth.

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 0%, so the description carries full burden. It effectively explains the single optional parameter 'filter' with its purpose ('narrow results by keyword') and provides an example ('e.g., "strategy", "freqai"'), adding clear meaning beyond the schema's basic type definition. This compensates well for the low 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 specific action ('List available freqtrade documentation topics') and resource ('documentation pages with their topic identifiers and titles'). It distinguishes from siblings like 'freqtrade_get_doc' (which retrieves specific docs) and 'freqtrade_search_docs' (which searches content), making the purpose explicit and differentiated.

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

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

The description provides clear context for usage ('Use the optional filter to narrow results by keyword') and implies when to use it (to get a list of topics). However, it doesn't explicitly state when not to use it or name alternatives like 'freqtrade_search_docs' for content-based searches, which would be helpful for full differentiation.

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

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

Annotations already indicate this is a read-only, non-destructive, idempotent operation with a closed world. The description adds valuable context beyond annotations: it specifies the scope ('all trading-related enums from freqtrade'), the return format ('enum summaries' with details like module paths and docstrings), and the optional filtering capability. This enhances understanding without contradicting annotations.

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

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

The description is front-loaded with the core purpose, followed by concise details on returns, usage, arguments, and return value. Every sentence adds value: the first states what it does, the second specifies return details, the third provides usage guidance, and the last two clarify parameters and returns. 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 the tool's low complexity (1 optional parameter), rich annotations (covering safety and behavior), and the presence of an output schema (which handles return value documentation), the description is complete. It adequately explains the tool's purpose, usage, and parameter semantics without needing to detail return values or behavioral traits already covered elsewhere.

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 1 parameter with 0% description coverage. The description compensates by explaining the parameter's purpose: 'Optional keyword filter for enum names or descriptions.' It clarifies that the filter is optional and what it filters on, adding meaningful semantics beyond the schema's basic type information.

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 specific action ('List all trading-related enums from freqtrade') and resource ('trading-related enums'), distinguishing it from siblings like freqtrade_get_enum_values (which likely returns values of a specific enum) and freqtrade_list_docs (which lists documentation). It explicitly mentions what information is returned: 'enum names, their module paths, docstrings, and member counts.'

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

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

The description provides clear context for usage: 'Use the optional filter to narrow results.' However, it does not explicitly state when to use this tool versus alternatives like freqtrade_get_enum_values or freqtrade_search_codebase, nor does it specify any exclusions or prerequisites for usage.

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

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

Annotations already indicate readOnlyHint=true, destructiveHint=false, openWorldHint=false, and idempotentHint=true, covering safety and idempotency. The description adds value by specifying the return format ('List of method summaries with name, brief description, and callback flag') and the optional filter parameter's purpose, which are not covered by annotations.

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

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

The description is front-loaded with the core purpose, followed by usage guidance, parameter explanation, and return details in a structured format. Every sentence earns its place with no wasted words, making it efficient 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?

Given the tool's low complexity (1 optional parameter), rich annotations covering safety and idempotency, and the presence of an output schema (which handles return values), the description is complete. It adequately explains purpose, usage, parameters, and behavioral context without redundancy.

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 0%, so the description fully compensates by explaining the 'filter' parameter's purpose ('to narrow results by keyword') and providing examples of keywords (e.g., 'entry', 'exit', 'indicator', 'callback', 'custom'). This adds significant meaning beyond the bare schema.

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

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

The description clearly states the verb 'List' and the resource 'all overridable methods from IStrategy', specifying exactly what the tool does. It distinguishes from siblings like freqtrade_get_method_signature (which provides detailed signatures) and freqtrade_list_docs (which lists documentation) by focusing on method summaries with brief descriptions and callback flags.

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

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

The description provides clear context for when to use this tool: to list overridable methods with optional filtering. It implies usage for exploring strategy methods but does not explicitly state when not to use it or name specific alternatives among siblings, such as freqtrade_get_method_signature for detailed signatures.

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 cover read-only, non-destructive, idempotent, and closed-world behavior. The description adds valuable context: it specifies what types of symbols are searched (classes, functions, constants, enums), supports basic regex patterns, and describes the return format (list with module paths and kinds). This goes beyond annotations without contradicting them.

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

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

The description is front-loaded with the core purpose, followed by details on search scope, regex support, and structured Args/Returns sections. Every sentence adds value without redundancy, making it efficient and well-organized.

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

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

Given the tool's moderate complexity (1 parameter, regex support), rich annotations, and presence of an output schema, the description is complete. It covers purpose, parameter meaning, behavioral details, and return format, providing sufficient context for an agent to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'query' parameter as a search pattern for symbol names that supports basic regex, including allowed characters and operators. This adds meaningful semantics beyond the bare schema, though it could detail regex syntax more.

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

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

The description clearly states the tool searches for symbols in the freqtrade codebase by name pattern, specifying the resource (symbols in codebase) and verb (search). It distinguishes from siblings like freqtrade_search_docs (which searches documentation) and freqtrade_list_* tools (which list rather than pattern-match).

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

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

The description implies usage for finding code symbols by pattern, but doesn't explicitly state when to use this vs. alternatives like freqtrade_search_docs or freqtrade_list_* tools. It provides clear context (searching codebase symbols) but lacks explicit exclusions or comparison to siblings.

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

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

Annotations cover safety (readOnly, non-destructive, idempotent) and scope (closed-world), but the description adds valuable behavioral context: it specifies AND logic for multiple words, returns snippets with surrounding context, mentions error handling if docs are unavailable, and notes the default for max_results. This enhances understanding beyond the annotations without contradictions.

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

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

The description is front-loaded with the core purpose, followed by concise bullet points for arguments and returns. Every sentence adds value: the first states the action, the second details search logic, and the parameter/return sections provide necessary specifics without redundancy. It's efficiently structured and appropriately sized.

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

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

Given the tool's low complexity, rich annotations (covering safety and idempotency), and the presence of an output schema (handling return values), the description is complete. It explains the search scope, logic, parameters, and error cases, leaving no gaps for the agent to understand how and when to invoke this tool effectively.

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

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

With 0% schema description coverage, the description fully compensates by explaining both parameters: 'query' is described with examples ('custom stoploss', 'backtesting timerange'), and 'max_results' specifies the range (1-50) and default (10). This adds essential meaning not present in the schema, though it could briefly mention the required nature of 'query'.

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 specific action ('Search across all freqtrade documentation') and resource ('all documentation pages'), distinguishing it from siblings like 'freqtrade_get_doc' (which retrieves a specific page) and 'freqtrade_list_docs' (which lists pages without search). It explicitly mentions full-text search with snippet returns, making the purpose unambiguous.

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

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

The description provides clear context for when to use this tool (searching documentation with full-text queries) and implies alternatives by mentioning sibling tools like 'freqtrade_get_doc' for specific pages. However, it lacks explicit 'when-not-to-use' guidance, such as distinguishing from 'freqtrade_search_codebase' for code searches versus documentation searches.

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