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 mentions 'authenticated' (a useful hint about auth requirements), but does not disclose side effects (e.g., whether it overwrites existing alerts, deactivates after first fire, requires specific permissions, or what the response format is). For a mutation tool with zero annotation coverage, this is a significant gap.

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?

A single, front-loaded sentence that efficiently states the purpose. No filler or redundancy; every word contributes to the core meaning.

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

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

Given 7 parameters, no output schema, and no annotations, the description is too sparse. It does not explain what a successful creation returns (e.g., alert ID), error possibilities, or how the alert interacts with the chart state. For a moderately complex tool, this is inadequate for an agent to fully understand the operation.

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

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

Schema description coverage is 100%, so all parameters already have detailed descriptions (notably frequency and resolution). The description itself adds no extra parameter context, so it stays at the baseline 3. It does not need to compensate for schema 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 action ('Create a price alert') and the target ('on the current chart'), distinguishing it from sibling tools like alert_create_bulk (bulk creation) and alert_list/delete (management). Even without explicit differentiation, the verb and resource are specific and 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 implies single-alert creation by its name and contrasts with the obvious bulk sibling, but it never explicitly says when to use this tool over alternatives or provides exclusion conditions. The usage context is inferred rather than stated, so it earns a 3 (implied) rather than 2 (no guidance) because the sibling names make the distinction reasonably clear.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It discloses that webhook URLs redirect alert posts, that quotes are fetched in one request for the whole set, and that the tool avoids chart interactions. However, it doesn't mention error handling, rate limits, or what happens if some symbols fail, leaving some uncertainty for a bulk operation.

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

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

The description is concise, front-loading the core action and scope in the first sentence. Subsequent sentences efficiently address key behavioral aspects (webhook, percent_from_last) without redundancy. It avoids unnecessary detail and remains focused on what an agent needs to know before invoking the 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?

For a bulk-alert tool with 10 parameters and no output schema, the description covers primary use cases and parameter selection guidance. However, it omits potential pitfalls like partial failures, idempotency, or how results are returned (e.g., whether created alerts are listed). Given the complexity, a bit more context would improve completeness, though the schema fills many gaps.

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

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

Schema description coverage is 90%, so the baseline is 3, but the description adds meaningful context beyond the schema. It explains the price vs. percent_from_last trade-off, describes webhook functionality, and clarifies that percent_from_last is per-symbol based on live prices. This supplemental information helps agents choose parameters correctly.

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: creating price alerts across many symbols or the whole watchlist in one call. It distinguishes itself from the singular alert_create sibling by emphasizing 'MANY symbols' and explicitly notes it does not touch the chart, making the function's scope 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 gives practical guidance on parameter selection, notably advising percent_from_last as the only sensible approach for a mixed watchlist. It also clarifies the tool is for bulk operations, implicitly steering single-alert needs to alert_create, though it doesn't explicitly name the alternative. The 'Does NOT touch the chart' note further contextualizes use cases.

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

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

No annotations are provided, so the description carries the full burden. It discloses the destructive action ('delete') but does not explain the context menu behavior, what happens to specific alerts, or any required confirmation/permissions. The dual nature ('delete all' or 'open context menu') is under-specified.

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

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

The description is a single concise sentence with the primary action front-loaded. It contains no fluff, but the second clause is vague and could be seen as under-specification rather than true conciseness.

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

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

For a deletion tool with no annotations and no output schema, the description is incomplete. It does not clarify the difference between 'delete all' and 'open context menu', nor how the parameters map to these behaviors. Sibling tools like 'alert_delete_by_id' exist, making the lack of usage context a significant 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% with clear descriptions for each parameter, so the description does not need to add parameter details. However, the description's 'or open context menu for deletion' does not align with the parameter-based deletion paths, adding slight confusion rather than 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?

The description identifies the action ('Delete all alerts') and resource ('alerts'), but the 'or open context menu for deletion' clause is ambiguous and does not cover the schema's support for deleting specific alert IDs via 'alert_id' and 'alert_ids'. It also fails to distinguish this tool from the sibling 'alert_delete_by_id'.

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

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

No guidance is given on when to use 'delete_all' versus individual IDs, nor when to prefer 'alert_delete' over 'alert_delete_by_id'. The phrase 'open context menu for deletion' hints at a UI interaction but does not explain conditions.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states the action without mentioning side effects, error handling, or return value. For a destructive delete operation, the lack of such context is a notable gap.

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

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

The description is a single, focused sentence that immediately conveys the action and scope. There is no redundant wording or unnecessary detail, making it highly concise and well-structured.

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

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

Given the low complexity (one parameter, no output schema, no annotations), the description is adequate but incomplete. It does not explain the response/error behavior or differentiate from 'alert_delete', which would be valuable context for an agent.

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

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

Schema coverage is 100%: the single parameter alert_id is already documented as 'Alert ID from alert_list'. The description adds no extra meaning beyond this, so the baseline score of 3 is appropriate.

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

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

The description 'Delete a single alert by ID' uses a specific verb (Delete) and resource (alert), and explicitly notes both 'single' and 'by ID'. This clearly distinguishes it from the sibling tool 'alert_delete', which likely handles batch or filter-based deletion.

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?

Usage context is implied: the parameter description 'Alert ID from alert_list' suggests a workflow of listing alerts first. However, the description does not explicitly state when to use this tool versus the sibling 'alert_delete', nor does it provide when-not-to-use conditions.

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 states the action and the 'active' filter, which implies a read-only operation, but it does not explicitly mention that it is non-destructive, nor does it describe the output format or any limitations. This is minimal but not misleading.

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 exceptionally concise—just three words—with every word contributing meaning. It is front-loaded and free of any wasted text, embodying ideal 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 low complexity (zero parameters, no output schema), the description is adequate for basic understanding. However, it does not clarify what constitutes an 'active' alert, what fields are returned, or whether there are any pagination or sorting defaults. It is sufficient for a simple list but leaves minor gaps.

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

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

The tool has zero parameters, so per the rubric the baseline is 4. The description adds contextual meaning by specifying 'active alerts', which scopes the listing operation. There are no parameter details needed since the schema is already empty and complete.

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 'List active alerts' clearly states the operation (list) and the resource (active alerts), distinguishing it from sibling tools like alert_create and alert_delete that handle alert mutations. The specific scope 'active alerts' adds precision.

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 retrieving current alerts, but it does not explicitly state when to use this tool versus alternatives such as alert_create or alert_delete. No when-not-to-use or alternative guidance is provided, leaving the usage context implied by the verb and resource.

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 only states the basic function without revealing side effects (e.g., that it likely changes the chart symbol/timeframe during iteration, as hinted by the restore_start_state parameter) or the sequential execution with delay. These are only visible in parameter descriptions, not in the main tool description.

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, unambiguous sentence that is front-loaded with the core action. It is appropriately concise and contains no fluff, though it omits details that would improve other dimensions.

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

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

For a tool with 7 parameters, 2 required, no output schema, and no annotations, a one-sentence description is insufficient. It does not explain what the tool returns, how iterations behave (delays, state restoration), or any prerequisites. An agent would need to rely heavily on the schema and context 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 100%, so a baseline of 3 is appropriate. The description itself adds no parameter detail; however, the schema already provides rich semantics, including the action enum with a note about get_study_values for universe scans. The description adds no extra value 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 uses a clear verb ('Run') and resource ('an action across multiple symbols and/or timeframes'), which distinguishes it from the single-symbol/timeframe sibling tools like data_get_ohlcv and data_get_study_values. It does not enumerate the specific actions, but the schema names them, so the purpose is reasonably clear.

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

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

The description gives no guidance on when to prefer batch_run over calling the underlying single-action tools repeatedly, nor does it mention any trade-offs, such as rate limiting or the sequential delay. The intended context is only inferred from the name and schema.

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. 'Take a screenshot' implies a non-destructive read operation, but it does not explain what happens to the image (e.g., saved to disk, returned as base64), whether it blocks until complete, or how the wait_for_render parameter affects the outcome. This is a significant gap for an agent invoking the tool.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It conveys the core action efficiently and is 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 and no annotations, the description leaves out critical details such as return format, file saving behavior, and potential side effects. For a tool with four parameters and a rendering wait option, more context is needed for an agent to fully understand the tool's impact and output.

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

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

The schema describes all four parameters (method, region, filename, wait_for_render) with clear descriptions, giving 100% coverage. The tool description adds no additional meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb 'take' with a clear resource 'screenshot of the TradingView chart'. It clearly distinguishes from sibling tools like chart_get_state (state reading) and chart_vision_read (visual analysis), which are not capture tools.

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

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

The description makes the intended usage obvious: use this tool to capture a chart screenshot. No exclusions or alternatives are mentioned, but since no other sibling tool serves this exact purpose, the context is clear enough for 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?

With no annotations, the description carries full burden. It clearly implies a read-only operation via the verb 'Get', which is a behavioral disclosure, but it does not mention potential errors (e.g., no chart open), performance characteristics, or side effects. For a zero-parameter getter, this is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no filler. Every element (resource and fields) earns its place, making it highly efficient and scannable.

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

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

Given the low complexity (no parameters, no output schema), the description covers the key return values at a high level. However, it does not state whether the chart must be open or whether indicator details include settings/how they are returned, leaving minor ambiguity for invocation 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 zero parameters, so no parameter syntax is needed. The description adds value by conceptually defining what the returned state includes (symbol, timeframe, chart type, indicators), which helps the agent interpret results even without an output schema.

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

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

Description uses a specific verb ('Get') and resource ('current chart state') and enumerates the returned fields (symbol, timeframe, chart type, indicators). This clearly distinguishes it from sibling setter tools like chart_set_symbol and chart_set_timeframe, and from the more specific chart_get_visible_range.

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 explicit guidance on when to use this tool versus alternatives. It implies a read operation, but does not differentiate from other getter tools such as tv_ui_state or chart_get_visible_range, nor does it give context like 'use when you need current chart settings before modifying them'.

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. It discloses the core behavior (retrieving date and bars ranges) and implies a read-only operation through the verb 'Get.' However, it omits specifics such as whether unix timestamps are in seconds or milliseconds, whether the bars range is inclusive, and whether the returned values are in a particular format. These gaps limit the agent's ability to anticipate the exact output.

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

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

The description is a single, concise sentence that directly states the tool's purpose without any redundant phrasing. Every word contributes to the meaning, making it highly 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?

The tool has no output schema and no annotations, so the description must fully explain what the agent can expect. It states the two key pieces of data (date range and bars range) but does not describe the return structure, such as whether it is an object with specific field names. This ambiguity could lead to incorrect assumptions about the response format, making it only minimally 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?

The tool has zero parameters, and the schema coverage is 100% by default. The description does not need to explain parameter meanings since none exist. The baseline of 4 is appropriate here because there is no parameter information to add 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 uses a clear verb 'Get' and specifies the resource as 'visible date range (unix timestamps) and bars range on the chart.' This clearly conveys the tool's function as a getter for chart visible range data. It implicitly differentiates from sibling tools like chart_set_visible_range (which sets) and chart_scroll_to_date (which scrolls), though it does not explicitly name them.

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

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

The description provides no guidance on when to use this tool versus alternatives. It only states what it does, with no context about typical use cases, prerequisites, or exclusions. For example, it does not mention that this tool is useful for capturing the current view before making changes or that it should be used instead of chart_get_state for range-specific 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?

With no annotations, the description carries the full burden of behavioral disclosure, yet it only states the action without mentioning side effects, prerequisites, or failure modes. It does not disclose that removal requires an entity_id from chart_get_state or that indicator names must be full names, leaving critical behavioral details to the schema descriptions.

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

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

The description is a single, concise sentence that immediately conveys the tool's purpose. It is front-loaded and contains no unnecessary words or repetition.

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

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

The description is sufficient for a basic understanding but lacks context about prerequisites and the source of entity_id. Since there is no output schema, a brief note about expected behavior or return values would improve completeness, but the schema partially compensates.

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 baseline is 3. The description itself adds no parameter semantics, but the schema effectively explains the parameters including enums, required fields, and naming constraints. The tool description adds no additional meaning beyond that.

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 (add or remove) and the resource (indicator/study on the chart). It is specific enough to convey the tool's core function, though it does not explicitly distinguish it from sibling tools like indicator_add_from_search or indicator_toggle_visibility.

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 offers no guidance on when to use this tool versus alternatives such as indicator_add_from_search or indicator_set_inputs. The schema hints at usage (e.g., entity_id for remove, indicator for add), but the description itself provides no context or exclusions.

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

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

No annotations are provided, so the description must fully disclose behavior. It states that the chart view is centered on a date, implying a view mutation, but does not detail edge cases, prerequisites, or whether the visible range is adjusted. For a simple navigation action, this provides some transparency but lacks depth.

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

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

The description is a single, front-loaded sentence with no unnecessary words, perfectly concise.

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

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

Given the low complexity (1 parameter, no output schema), the description sufficiently explains the tool's function. It could benefit from noting prerequisites or behavior relative to sibling tools but is adequate for this scope.

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 single parameter 'date' is fully documented in the schema with formats (ISO string or unix timestamp). The description does not add additional information about parameter semantics, so it meets the baseline for 100% 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 uses a specific verb 'jump' and 'center' with the resource 'chart view', clearly indicating the action of navigating to a date. This distinguishes it from other chart_* tools like chart_set_symbol or chart_set_timeframe.

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 when the user wants to navigate the chart to a specific date but does not explicitly mention alternatives or exclusions. Context from sibling tools (e.g., chart_set_visible_range) might help but is not referenced in the description.

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 responsibility for behavioral disclosure. It offers none—no mention of side effects, chart state changes, symbol validation, or whether the chart must be open. This is a complete lack of behavioral information.

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

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

The description is a single sentence with no wasted words, front-loading the action clearly. It is appropriately concise for a simple tool with a single parameter.

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

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

Despite the tool's simplicity, the description lacks essential context: it does not mention that a chart must be active, what happens to the current symbol, or how the change affects other chart state. With no output schema or annotations, the description leaves notable gaps.

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

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

The input schema fully documents the 'symbol' parameter with examples, so schema description coverage is 100%. The description text adds no additional parameter semantics beyond the schema, which is acceptable given the baseline for high coverage.

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

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

The description clearly states the tool's action: changing the chart symbol. It uses a specific verb and resource, and is distinguishable from sibling tools like chart_set_timeframe and chart_set_type, though it closely mirrors the tool name itself.

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 such as symbol_search or pane_set_symbol. There are no prerequisites, exclusions, or context about when a symbol change is appropriate.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It indicates a mutating action ('Change') but does not mention potential side effects, idempotency, or whether the chart must be loaded or active. This is a significant gap for a tool with no annotation support.

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

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

The description is a single, concise sentence with no redundancy. It is front-loaded with the core action, efficient, and easily parsed. However, it could be slightly more informative without sacrificing brevity, so it does not earn a 5.

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

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

The tool is simple with one well-documented parameter, so the minimal description is somewhat adequate. However, there are no annotations and no output schema, and the description does not mention any prerequisites (e.g., chart must be open) or confirm the absence of return values. For a mutating tool in a large sibling set, this is a moderate 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?

The input schema already covers the single parameter 'timeframe' with examples (1, 5, 15, 60, D, W, M), and schema coverage is 100%. The description adds no extra meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's action: 'Change the chart timeframe/resolution'. It uses a specific verb ('Change') and resource ('chart'), and the object (timeframe/resolution) distinguishes it from sibling tools like chart_set_symbol or chart_set_type. 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 implies usage (when you want to alter the chart's timeframe), but it provides no explicit guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. It is minimally adequate but lacks clear context for when to invoke it among related chart tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Change chart type' without detailing side effects, validation behavior, or persistence of changes, which is insufficient for a tool that modifies chart state.

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 extremely concise, but this borders on under-specification rather than effective brevity. While it is front-loaded and to the point, it omits useful context that could be conveyed in a single additional sentence without sacrificing clarity.

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 with rich schema) and absence of an output schema, the description is minimally sufficient but not complete. It lacks details on expected outcomes or interaction with chart state, though the parameter schema mitigates some ambiguity.

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

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

The input schema already provides comprehensive documentation for the single parameter, including accepted names and numbers with 100% coverage. The description itself does not add any additional meaning beyond what the schema conveys, so a baseline score of 3 is appropriate.

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

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

The description 'Change chart type' clearly states the action (change) and the resource (chart type), distinguishing it from sibling tools like chart_set_symbol and chart_set_timeframe. It is specific enough to understand the tool's primary function, though it lacks elaboration on what 'chart type' entails.

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 does not mention prerequisites, conditions, or references to other tools, leaving the user to infer usage from the tool name and sibling context.

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

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

No annotations are provided, so the description must carry the full burden. It only restates the basic action without disclosing side effects, reversibility, return values, or whether any prior conditions are needed. 'Zoom' implies a view change, but it adds little beyond the name and schema.

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, front-loaded sentence that conveys the core action efficiently. Every word is necessary and no redundant information is present.

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

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

The tool has only two simple parameters and no output schema, so the description is mostly sufficient. However, it lacks any mention of behavioral context (e.g., side effects) and does not differentiate itself from chart_scroll_to_date, making it slightly incomplete for an agent choosing among sibling tools.

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

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

Schema description coverage is 100%, with each parameter documented as 'Start of range' and 'End of range' in unix timestamps. The tool description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

The description clearly states the tool's function: 'Zoom the chart to a specific date range (unix timestamps)'. It uses a specific verb ('Zoom') and resource ('chart'), and the scope ('specific date range') distinguishes it from related tools like chart_scroll_to_date and chart_get_visible_range.

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 the tool is used to set the visible range, but it does not explicitly state when to use it versus alternatives like chart_scroll_to_date or chart_get_visible_range. No when-not or alternative tools are mentioned, leaving some ambiguity.

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 burden. It discloses the return mode behavior (inline image vs file_path based on max_image_bytes) and implicitly signals a read-only operation via 'read'. It does not discuss permissions or error cases, but the core behavioral trait is covered.

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, front-loaded with the primary purpose, then a concise note on return behavior. No filler or 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?

With no output schema, the description should explain return values more thoroughly. It explains the image mode but does not describe the structure or format of the other returned data (quote, indicator, OHLCV). For a tool that aggregates many data types, this is a notable gap, though the core behavior is clear.

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 extra parameter meaning: the parenthetical list of content types aligns with the 'include' parameter, and the max_image_bytes threshold is already described in the schema ('Exceeded → file_only mode'). No new parameter context is provided.

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

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

The description clearly states the tool's function: 'Take a screenshot and read all chart data in one call' and enumerates the content types (quote, indicator, Pine graphics, OHLCV). This distinguishes it from sibling tools like capture_screenshot or individual data_get_* tools.

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

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

The phrase 'in one call' implies a convenience aggregator, suggesting when to use it, but there is no explicit guidance on when not to use it or how it compares to alternatives like capture_screenshot plus data_get_* tools. Usage context is inferred, not stated.

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

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

No annotations are provided, so the description must carry transparency. It does disclose one behavioral requirement (entity_id needed when multiple strategies loaded), but omits details like return format, error behavior, or any side effects. This is a minimal disclosure, hence a middle score.

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 short sentences, front-loaded with the primary purpose. The second sentence adds a necessary usage condition. No redundant or filler 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?

For a simple getter with one optional parameter and full schema coverage, the description is largely sufficient. It lacks an explicit statement about output structure, but the tool name and first sentence strongly imply the return value is the equity curve. Slight gap due to 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?

The schema already thoroughly describes entity_id with exact instructions and recommendation. The description's mention of entity_id adds no new information beyond the schema. With 100% schema coverage, baseline is 3.

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

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

The description clearly states the tool's function: 'Get equity curve data from Strategy Tester' – a specific verb, resource, and source. This distinguishes it from sibling data tools like data_get_trades and data_get_strategy_results.

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

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

Provides context for the entity_id parameter: 'Pass entity_id when more than one strategy is loaded.' This clarifies when to supply the parameter, though it does not explicitly name alternatives or state when NOT to use this tool. Still, the guidance is useful and situational.

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 responsibility for behavioral disclosure. 'Get' implies a read-only operation, but the description does not mention potential edge cases (e.g., what happens if entity_id is invalid), return format, permissions, or any side effects. It adds no behavioral context beyond the verb itself.

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, front-loaded sentence with no wasted words. It efficiently communicates the core operation without extraneous content. This is well-structured for a simple getter.

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, the description is still incomplete. It does not explain what 'info' includes, how this relates to chart state, or how it differs from similar tools like data_get_study_values. With no output schema and no annotations, the agent lacks enough context to invoke this tool confidently in all scenarios.

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% since the single parameter entity_id has a description ('Study entity ID (from chart_get_state)'). The tool description itself does not elaborate on the parameter, but because the schema already provides sufficient meaning, a baseline score of 3 is appropriate. No additional value is added by the description 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 uses a specific verb 'Get' and clearly identifies the resource: 'indicator/study info and input values'. This distinguishes it from tools like data_get_study_values (which likely returns computed values) but does not explicitly mention that distinction. It is clear and non-tautological, though it could be more explicit in naming the tool's purpose.

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 such as data_get_study_values or chart_get_state. The description simply states what it does without context for selection. The only contextual clue comes from the parameter description in the schema, but the tool description itself fails to offer usage direction.

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 responsibility for behavioral disclosure. It does reveal that summary=true returns 'compact stats instead of all bars' and that using it 'saves context,' which is a significant behavioral trait. However, it does not describe other behaviors such as return format, potential errors, or the fact that it might be a read-only operation. This is a moderate level of 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 exceptionally concise—one sentence plus a targeted tip. It front-loads the core purpose and immediately follows with actionable guidance. No wasted words or irrelevant details.

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

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

For a simple tool with two well-documented parameters and no output schema, the description is mostly complete. It covers what the tool does and offers advice on a key parameter. However, it could be more complete by mentioning what the output looks like (e.g., a list of OHLCV bars) or clarifying that it reads from the currently active chart, but these are somewhat implied. Good overall.

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

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

Both parameters are already fully described in the schema (count with range and default, summary with details about what it returns). The description adds practical value by emphasizing the context-saving benefit of summary=true, which goes beyond the schema's 'much smaller output' wording. This enhances the agent's ability to choose the right parameter mode.

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 a specific verb and resource: 'Get OHLCV bar data from the chart.' This distinguishes it from sibling data tools like data_get_indicator or data_get_trades, as it specifically targets OHLCV bars. No ambiguity.

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 useful context on how to use the tool, specifically recommending summary=true for compact stats to save context. However, it does not explicitly mention when to use this tool versus alternative data retrieval tools, though the purpose makes the primary use case clear. It lacks exclusions or alternative tool references.

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 behavioral disclosure burden. It states the read-only nature ('Read'), the deduplication behavior, and the return format ({high, low} price zones). It does not cover edge cases like empty results or error conditions, but it provides solid transparency for a simple read tool.

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

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

The description is two concise sentences, front-loaded with the primary verb 'Read'. It avoids redundancy and every sentence contributes meaningful information: what it reads, what it returns, and how to filter.

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 2-parameter read tool with no output schema or annotations, the description is sufficiently complete. It covers purpose, return type, deduplication, and filtering. It does not mention sorting or empty-result behavior, but these are not critical for task selection. The sibling context confirms this is part of a family of data_get tools, and the description clearly differentiates the box focus.

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

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

The input schema covers both parameters fully (verbose and study_filter). The description adds a brief note to use study_filter for targeting an indicator, which slightly reinforces the schema's existing description. Since schema coverage is 100%, the description does not need to compensate, and it adds only marginal semantic value 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 uses the explicit verb 'Read' and identifies the resource as 'box/zone boundaries drawn by Pine Script indicators (box.new)', making it clear this tool is for reading box objects. It also clarifies the output as deduplicated {high, low} price zones, which distinguishes it from sibling tools like data_get_pine_lines (lines) and data_get_pine_labels (labels).

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

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

The description gives concrete usage context: it is for reading box zones and mentions the study_filter parameter to target a specific indicator. However, it does not explicitly name alternatives or say when not to use this tool, which would push it to a 5.

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

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

No annotations are provided, so the description carries the full burden. It clearly identifies the operation as reading (non-mutating) and describes the output as 'text and price pairs'. However, it does not disclose edge cases like empty results, behavior when study_filter matches nothing, or whether it requires a chart with loaded indicators. The behavior is adequately but not richly described.

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

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

The description is two concise sentences, front-loaded with the action and resource, and includes a practical usage hint. 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?

For a read-only tool with three simple optional parameters and no output schema, the description provides enough context: it states purpose, return format, and how to target specific indicators. It could mention what happens when no labels are found or clarify multi-study behavior, but overall it is reasonably complete for the tool's complexity.

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

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

The input schema already covers all three parameters with clear descriptions (verbose, max_labels, study_filter), and the schema description coverage is 100%. The description mentions study_filter but adds no new meaning beyond the schema. Baseline of 3 is appropriate since 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?

Description uses specific verb 'Read' and names the exact resource: 'text labels drawn by Pine Script indicators (label.new)'. It also states the return format ('text and price pairs'), which distinguishes it from sibling tools like data_get_pine_lines and data_get_pine_boxes.

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 a usage hint: 'Use study_filter to target a specific indicator.' This implies the tool can read from all indicators when no filter is applied. However, it does not explicitly contrast with alternatives such as data_get_pine_lines or data_get_indicator, so while context is present, exclusions or alternative selection guidance are missing.

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 burden of behavioral disclosure. It explicitly states the read-only nature ('Read') and discloses the deduplication behavior and per-study grouping. It stops short of detailing edge cases (e.g., empty results, filtering of only horizontal lines), but the core non-obvious behavior is transparent.

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

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

The description is three short sentences, each earning its place: purpose, key output behavior, and a parameter usage tip. It is front-loaded with the verb and resource, with no fluff or repetition.

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

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

Given the tool's simplicity (2 optional params, no output schema), the description covers the essential behavior and filtering. It does not detail the exact return format (e.g., array of objects with study names), but the schema and description together provide enough for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds a brief usage hint for study_filter ('Use study_filter to target a specific indicator') but does not explain verbose or add semantic depth beyond what the schema provides. This is adequate but not extra informative.

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

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

The description states a specific verb ('Read') and resource ('horizontal price levels drawn by Pine Script indicators (line.new)'), clearly distinguishing it from sibling tools like data_get_pine_labels, data_get_pine_tables, and data_get_pine_boxes. The mention of 'deduplicated price levels per study' further refines the purpose.

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 what the tool does and how to target a specific indicator via study_filter. However, it does not explicitly name alternatives or exclusions, e.g., 'use data_get_study_values for time-series data', so the guidance is clear but not exclusionary.

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

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

No annotations are provided, so the description must disclose behavior. It explicitly states 'Read' (non-destructive), mentions the return format ('formatted text rows per table'), and indicates this is data from Pine Script tables. While it doesn't detail error cases or multi-table behavior, it adequately covers the core behavior for a simple read operation.

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

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

The description is two sentences, front-loaded with the primary action, and every clause adds value—purpose, output format, and filter guidance. No redundant or filler 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?

For a simple read-only tool with one optional parameter and no output schema, the description covers the essential aspects: what it does, return type, and filtering. It is complete enough for an agent to invoke correctly without additional clarification.

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%, and the description's 'Use study_filter to target a specific indicator' largely repeats the schema's 'Substring to match study name.' It adds minimal semantic value beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool reads table data drawn by Pine Script indicators (table.new) and returns formatted text rows per table. This distinguishes it from sibling tools like data_get_pine_lines, data_get_pine_labels, and data_get_pine_boxes, which target other drawing types.

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 by specifying that study_filter targets a specific indicator, and the schema notes 'Omit for all.' It does not explicitly name alternative tools for other data types, but the purpose is self-evident given the tool name and 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?

No annotations are provided, so the description carries the full burden. It discloses the side effects: 'Auto-opens Strategy Tester and unhides the selected strategy so TradingView computes its report.' This is a meaningful behavioral disclosure beyond a simple read. It does not mention return format or potential errors, but the side effect is the most critical behavioral trait.

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 exactly two sentences, front-loaded with the main purpose. The first sentence states what the tool does; the second gives a conditional parameter hint and the all-important side effect. Every sentence earns its place with no filler.

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

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

For a tool with one optional parameter and no output schema, the description covers the essential context: what it retrieves, when to pass the parameter, and the side effect of opening the Strategy Tester. It might benefit from hinting at the nature of the returned metrics, but the tool is simple enough that this is not a critical 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?

The input schema covers the entity_id parameter with a detailed description including where to get it and when it is recommended. The tool description adds the same advice ('Pass entity_id when more than one strategy is loaded') but does not introduce new semantics. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description opens with 'Get strategy performance metrics', which clearly states the verb and resource (strategy performance report). It distinguishes from sibling tools like data_get_trades and data_get_equity by focusing on the Strategy Tester report. The context about entity_id and auto-opening the Strategy Tester further clarifies the tool's unique role.

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 concrete usage guidance: 'Pass entity_id when more than one strategy is loaded.' It also explains that the tool auto-opens the Strategy Tester and unhides the strategy, which informs the user of prerequisite behavior. However, it does not explicitly name alternatives or state when not to use this tool, so it stays at 4.

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

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

No annotations are provided, so the description carries the burden of disclosing behavior. It indicates a read-only 'get' operation, which is helpful, but it does not mention return format, potential empty results, or side effects. It adds some context ('current', 'visible', 'data window') but not deep behavioral detail.

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, front-loaded sentence that clearly states the action and scope. It includes useful examples in parentheses without being verbose. Every word adds value, making it highly concise 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?

For a simple, zero-parameter getter, the description covers the main purpose but lacks return value details. Since there is no output schema, the description should ideally explain the shape or type of 'indicator values' returned. It is adequate but not fully complete for an agent that needs to know how to consume the result.

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 zero parameters, and the baseline for 0 params is 4. There is no parameter documentation needed, and the description correctly focuses on the output behavior rather than input 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 uses a specific verb 'Get' and clearly identifies the resource ('current indicator values from the data window') and scope ('all visible studies'). It also lists examples (RSI, MACD, Bollinger Bands, EMAs) and distinguishes from sibling tools by emphasizing 'all visible studies' versus single-indicator tools.

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

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

The description implies usage: use this when you need values for all visible studies. However, it does not explicitly state when to prefer this over alternatives like data_get_indicator, nor does it provide exclusions. The context is clear but not reinforced with alternative guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly mentions the side effect: 'Auto-opens Strategy Tester and unhides the selected strategy.' This is valuable transparency for a tool that might otherwise appear purely read-only. It does not disclose any other potential side effects or permission requirements, but it covers the most significant behavior.

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

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

The description is concise, consisting of two sentences, and front-loads the core purpose. Each sentence adds essential information: what the tool does, when to pass entity_id, and the side effect. No filler or repetition of schema details.

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

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

The tool is relatively simple with no output schema, and the description covers the main function and a key side effect. However, it does not specify prerequisites like whether at least one strategy must be loaded, or what happens if no strategy is available. This is a minor gap but not critical for understanding the tool's primary use.

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

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

Schema description coverage is 100%, meaning the schema already fully documents both parameters. The description adds no new parameter meaning beyond what the schema provides (e.g., the schema already says entity_id is 'Strongly recommended when more than one strategy is loaded'). Thus, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Get the most recent strategy orders.' The verb 'get' and resource 'strategy orders' are specific, distinguishing it from sibling tools like data_get_strategy_results. The additional detail about opening the Strategy Tester further differentiates it.

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

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

The description provides clear context for when to pass entity_id: 'Pass entity_id when more than one strategy is loaded.' This is helpful usage guidance. However, it does not explicitly state when this tool should be used over alternatives or when not to use it, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden. It states the tool retrieves order book data from the chart, indicating it is a read-only operation tied to the chart's context. It does not detail the return structure or number of levels, but for a simple getter this is adequate.

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

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

The description is a single, front-loaded sentence with no filler. Every word is 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 zero parameters and no output schema, the description provides the essential information that the tool retrieves order book/DOM data from the chart. It could be marginally richer (e.g., mentioning that it reflects the current chart symbol), but it is sufficient for a tool of this simplicity.

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

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

The input schema is empty, so the baseline is 4. The description adds no parameter semantics, but no parameters exist to document.

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

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

The description uses a specific verb 'Get' and clearly identifies the resource as 'order book / DOM (Depth of Market) data'. This distinguishes it from sibling data tools like data_get_trades and quote_get.

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 explicit when-to-use guidance or alternative tool comparisons are provided. However, the description's specificity implies it should be used when order book depth data is needed, giving an implied usage context.

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

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

No annotations are present, so the description carries the full burden. It discloses that the operation is destructive, irreversible via this API, and removes all drawings regardless of origin. It also clarifies that the scope is the active pane, not the whole chart, preventing a dangerous misinterpretation.

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, front-loaded with the primary action, immediately followed by scope clarification, then destructive warnings and the pointer to the safer alternative. Every sentence earns its place; no 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?

The description is fully self-contained for a mutation tool with no output schema: it covers what happens, the target scope, side effects, usage caveats (multi-pane), and how to achieve a more targeted outcome. Nothing an agent needs is missing.

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?

There are no parameters in the schema, so the description adds critical meaning by clarifying the implicit target (active pane) and that no other input is needed. This goes beyond the empty schema and fully explains the tool's input expectations.

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

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

The description states a specific verb-resource pair ('Remove ALL drawings') and scopes it precisely to the ACTIVE PANE, distinguishing it from the whole chart. It also contrasts with draw_remove_one, so an agent can immediately tell which tool fits the intent.

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

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

Explicitly explains when to use (clear everything on the active pane), when not to (single drawing removal via draw_remove_one), and how to set the target pane using pane_list and pane_focus. This is textbook usage guidance with 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?

No annotations are provided, so the description carries the full burden. It only says 'Get properties and points', which implies a read-only operation, but it does not disclose behavior such as whether the drawing must exist, what happens on invalid ID, or if any state changes occur. The lack of explicit safety or error context leaves transparency gaps.

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

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

The description is a single, clear sentence that efficiently conveys the tool's purpose. Every word contributes value, and it is front-loaded with the action verb.

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 one-parameter getter, this is minimally viable. However, without an output schema, the description does not specify what 'properties and points' include, nor how they are structured. It could mention return format or error behavior, but given the tool's simplicity, the current level is acceptable but not 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 input schema has 100% coverage for the single parameter entity_id, with a description that says 'Entity ID of the drawing (from draw_list)'. The tool description adds no additional parameter semantics beyond that. Since the schema fully documents the parameter, a baseline of 3 is appropriate.

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

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

The description clearly states the action ('Get') and the specific resource ('properties and points of a specific drawing'). It distinguishes itself from siblings like draw_list (which lists drawings) and draw_remove_one (which removes) by focusing on a single drawing's data.

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

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

Though the description itself doesn't explicitly mention alternatives, the parameter schema instructs that entity_id comes from draw_list, providing a clear prerequisite. The context of sibling tools makes the intended usage obvious: use draw_list to obtain an ID, then this tool to fetch its details. No exclusions are stated, but the guidance is sufficient for a simple getter.

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 responsibility for behavioral disclosure. It warns about the non-obvious active-pane-only behavior and the misleading zero-count scenario, which are the key traps an agent could fall into. It does not describe the return format, but the core behavioral risks are transparently covered.

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 dense sentences with no filler. The core scope is front-loaded in capital letters, and the caveat-plus-remedy structure delivers maximum useful information in minimal space.

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, the description covers the essential contextual warnings and directs the agent to the correct sibling tools. It lacks only a brief note on what the returned list contains or its format, but this is not critical for invoking the tool correctly.

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

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

The tool has zero parameters, and the schema already documents this with 100% coverage. There is nothing for the description to add about parameters, so the baseline of 4 applies.

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

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

The description states a specific verb ('List') and resource ('shapes/drawings') and adds a precise scope restriction: 'ACTIVE PANE ONLY'. This differentiates the tool from sibling tools like draw_get_properties and from pane-level operations by making its exact domain clear.

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

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

The description explicitly tells the agent when the tool is insufficient: in a multi-pane layout, other panes are not included, and a count of 0 does not mean the chart is empty. It names the exact alternatives, pane_list and pane_focus, for broader inspection. This is clear, actionable routing guidance.

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

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

With no annotations provided, the description carries full burden. It states the removal action but does not disclose irreversibility, possible side effects (e.g., chart redraw), error behavior for invalid IDs, or any prerequisites like an open chart. This is a significant gap for a destructive operation.

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

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

The description is a single, front-loaded sentence with no filler. Every word earns its place.

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

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

The tool is simple with a fully described parameter, but the absence of annotations and any behavioral detail (e.g., error handling, undo possibility) makes this minimally complete. It covers what it does but not the full context a careful agent might need.

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% because the only parameter (entity_id) has a description indicating it comes from draw_list. The description adds no extra param details, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Remove'), resource ('drawing'), and method ('by entity ID'). It clearly distinguishes from siblings like draw_clear (which likely clears all drawings) and draw_list (which lists them).

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

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

The description does not explicitly mention alternatives or when-not-to-use. However, the schema's parameter description ('from draw_list') implies you should first list drawings to obtain the entity ID, providing some usage context. No explicit exclusions are given.

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 provides no information about side effects, whether shapes are overwritten, validation rules, or the response format. This is a critical gap for a mutation tool.

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

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

The description is a single, concise sentence with no wasted words. It is front-loaded and immediately conveys the core purpose. However, it is extremely terse and lacks any supporting details, which slightly reduces the score.

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 5 parameters with nested objects, no annotations, and no output schema, the description is severely incomplete. It fails to mention return values, error conditions, prerequisites, or how to construct valid point objects. This is inadequate for an agent to invoke the tool correctly.

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

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

Schema description coverage is 100%, as every property in the input schema has a description. The description itself adds no parameter-specific meaning, but since the schema already documents parameters thoroughly, the baseline of 3 applies.

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

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

The description clearly states the action ('Draw') and the resource ('shape/line on the chart'). It distinguishes from sibling tools like draw_clear or draw_remove_one by identifying this as the drawing operation. However, it does not enumerate the specific shape types, relying on the schema for that detail.

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. There is no mention of how this relates to sibling draw tools (e.g., draw_clear, draw_remove_one) or any prerequisites such as having a chart open. The usage is only implicitly understood from the action verb.

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 describes the action but does not disclose potential side effects, failure modes (e.g., no match found), whether the indicator is added to the active chart, or any authentication requirements. The mention of types (built-in, strategy, community, saved) adds context, but important behavioral details are absent.

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, front-loaded sentence that immediately states the action and the target. Every word contributes to understanding the tool's purpose. No filler or 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?

For a relatively simple tool with three parameters and no output schema, the description provides a basic understanding. However, it lacks specifics about what happens after adding (e.g., does it open the dialog, require a chart), how the 'match' parameter interacts with 'query', or the behavior when multiple matches exist. These gaps are notable, but the description is adequate for a basic use case.

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 baseline is 3. The description mentions 'matching' and result types, but it does not add substantive meaning beyond the schema. The schema already documents query, match, and section with clear descriptions, so the description neither enhances nor compensates 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 function: 'Search the TradingView Indicators dialog and add a matching built-in, strategy, community, or saved study'. It specifies the action (search and add), the resource (TradingView Indicators dialog), and the scope (built-in, strategy, community, saved study), which distinguishes it from sibling tools like indicator_search (search only) and chart_manage_indicator (manage added indicators).

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 the use case: adding an indicator by searching. However, it does not explicitly state when to use this tool versus alternatives like indicator_search (which only searches without adding) or chart_manage_indicator (manages existing indicators). No exclusions or prerequisites are mentioned, leaving the guidance implicit rather than explicit.

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

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

No annotations are present, so the description carries the full burden. It only states the search action without disclosing return format, pagination behavior, or query matching semantics. Additional context like default limit is left to the schema, and no behavioral traits are surfaced.

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, front-loaded sentence listing the search scope with no fluff. It is appropriately concise for the simplicity of the tool, though it provides no additional structural benefits like examples or context.

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

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

Given the tool's simplicity (2 params, no output schema), the description covers the core purpose but omits return value details and usage context. It is minimal viable, adequate for selection, but leaves room for clarification about what the search returns.

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

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

Schema description coverage is 100% for both parameters (query and limit), so the schema already provides adequate parameter meaning. The tool description adds no extra semantic value beyond the schema, keeping the baseline at 3.

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

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

The description uses a specific verb 'Search' and clearly identifies the resource as TradingView studies (built-in, community, strategy, saved-script). This distinguishes it from symbol_search and other search-like tools, 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention that results could feed into indicator_add_from_search, nor does it state any exclusions or prerequisites. The context for use is only implied by the name and description.

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 must disclose side effects and requirements. It merely states the action without mentioning possible side effects (e.g., chart refresh), validation behavior, or what happens if the entity_id is invalid. The lack of any behavioral context beyond the mutation itself is a significant gap for a mutating tool.

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

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

The description is a single concise sentence, front-loading the verb and object. It includes useful examples without unnecessary verbosity. Every word contributes to understanding the tool's core function.

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 2-parameter mutation tool with no output schema, the description captures the core action but leaves out important operational context such as prerequisite indicator existence, error behavior, or reversibility. While the low complexity doesn't demand extensive detail, the absence of annotations raises the bar for completeness, which this description only partially meets.

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

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

The input schema already covers both parameters with descriptions, including the JSON format for 'inputs' and the source of 'entity_id'. The description adds modest value by giving examples of input keys, but this is largely redundant with the schema's example. Baseline 3 is appropriate given 100% 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 action ('Change') and the target ('indicator/study input values') with concrete examples ('length, source, period'). This unambiguously differentiates it from sibling tools like chart_manage_indicator or indicator_toggle_visibility, which handle indicator lifecycle and visibility rather than input parameter modifications.

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 adjusting study inputs, and the required entity_id from chart_get_state in the schema suggests a prerequisite. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any constraints like the indicator needing to exist or how to obtain the entity_id beyond the schema hint.

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 disclosure burden. It does add genuine value by revealing that the tool verifies its work by reading the study back rather than trusting setVisible(), which tells the agent the result is confirmed. But it doesn't disclose other behavioral traits such as failure modes, reversibility, or side effects for a mutation operation.

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

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

Two tight sentences, no filler. The core purpose is front-loaded, followed by the toggle nuance, then the verification note. Every sentence earns its place.

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

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

For a simple 2-parameter tool with full schema coverage, the description covers the core action, the parameter nuance, and the verification behavior. It's near-complete; only failure/return behavior is unaddressed, which is minor given the tool's simplicity and lack of 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 both parameters. The description restates the 'omit visible to toggle' behavior that is also in the schema, adding only marginal value. Baseline 3 is appropriate since the structured 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 states specific verbs (show, hide, flip) applied to a specific resource (indicator on the chart). The dual mode — explicit set versus toggle — is unambiguous and the 'flip' behavior distinguishes this from general indicator-management siblings like chart_manage_indicator.

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

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

The description implies when to use it (manipulating an indicator's visibility on the chart) and the toggle-vs-set distinction is clear. However, it names no alternatives and gives no explicit when-not-to-use context, even though chart_manage_indicator could plausibly overlap with visibility control.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only states 'List' and 'bounded pagination,' which largely mirrors the schema's limit/offset fields. It does not mention side effects, return structure, or any caveats, leaving the agent without essential context for a read operation.

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

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

The description is a single concise sentence that front-loads the primary action and object. Every word earns its place, with no filler or 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 tool is simple, but with no output schema and no annotations, the description should provide more context about expected results. It does not indicate what fields will be returned, how layouts are identified, or ordering behavior, leaving the agent partially uninformed.

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 only 33%, with only include_details described. The tool description provides no parameter-level detail, failing to compensate for the gap. The phrase 'bounded pagination' hints at limit/offset but does not explain their semantics or defaults.

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

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

The description uses a specific verb ('List') and identifies the resource ('saved chart layouts'), making the tool's function immediately clear. It also adds 'with bounded pagination,' which distinguishes it from related tools like layout_switch that perform a different operation.

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

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

No explicit guidance is given on when to use this tool versus alternatives. The usage is implied by the verb 'List,' but there is no mention of exclusions or when to prefer another tool such as layout_switch or chart_get_state.

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 explicitly discloses a critical behavioral trait: it 'stops rather than discarding unsaved changes' unless discard_unsaved is set. This communicates a safety mechanism and the destructive consequence of setting the flag. Since no annotations are provided, the description carries the burden, and it does so well, though it could be more explicit about affecting the current chart.

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

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

The description is a single, well-structured sentence that front-loads the primary action and then explains the key edge case. There is no redundant or filler content; every word contributes to understanding the tool's behavior.

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

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

The description covers the core functionality and the most important safety behavior. It doesn't mention error handling or return values (though no output schema exists), and it doesn't explicitly state that the layout applies to the current chart, but this is implied by the context. Overall, it is sufficiently complete for a tool of this simplicity.

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

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

The input schema already fully describes both parameters (name and discard_unsaved) with clear descriptions. The tool description doesn't add any additional meaning beyond what the schema conveys, so the baseline of 3 applies.

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

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

The description states a specific action ('Switch to a saved chart layout'), the resource type ('chart layout'), and the selection method ('by name or ID'). This is clear and differentiates from sibling tools like layout_list (which lists layouts) and tab_switch (which switches tabs).

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 clearly conveys when to use this tool—to switch chart layouts—and provides context on the discard_unsaved parameter, indicating when to set it (when you want to discard unsaved changes). It doesn't explicitly mention alternatives or exclusions, but the intended use is obvious from the wording.

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 only states 'Focus a specific chart pane' without explaining side effects (e.g., which pane becomes active, whether the UI scrolls, or what happens if the index is invalid). The '0-based' indexing and reference to pane_list are helpful but do not disclose the underlying behavioral semantics.

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

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

The description is a single, focused sentence that immediately states the action and parameter. It is front-loaded with the verb and resource, contains no filler or redundant wording, and is appropriately concise 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?

For a tool with one parameter and no output schema, the description conveys the basic operation and references the index source via the schema. However, it lacks broader context such as when to use this tool, how it fits into the pane-management workflow, and what the expected result is (e.g., active pane selection). This makes it minimally viable but not fully 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?

The input schema provides 100% coverage with a clear description of the 'index' parameter ('Pane index (0-based, from pane_list)'). The tool description repeats this information ('by index (0-based)') without adding additional meaning. Since the schema already documents the parameter effectively, the description meets the baseline but does not go beyond it.

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 ('Focus') and the resource ('specific chart pane'), with the index parameter specifying the target. It is distinct from sibling tools like pane_set_layout or pane_set_symbol, which perform different operations on panes. However, 'focus' could be more explicit about the resulting behavior (e.g., making the pane active for subsequent commands), so it stops short of a perfect 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 doesn't mention prerequisites like calling pane_list first, or how this relates to pane_set_layout or pane_set_symbol. There is no context on whether this is needed before other pane operations. The user must infer usage from the tool name and schema 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?

No annotations are provided, so the description carries the responsibility for behavioral disclosure. It clearly states what is returned (symbols and active state) and implies a read-only, side-effect-free operation. However, it does not address edge cases such as behavior when no panes exist or whether hidden panes are included. For a simple list tool, this is adequate but not exhaustive.

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

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

The description is a single sentence, front-loaded with the action 'List', and contains no filler. Every word contributes to the meaning, making it highly concise 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?

For a zero-parameter, read-only list tool with no output schema, the description sufficiently captures the purpose and return content. It lacks explicit edge-case details, but given the tool's simplicity, it is complete enough for successful invocation.

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

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

The tool accepts zero parameters and the schema is an empty object. With no parameters to describe, the baseline score of 4 applies. The description adds no parameter-specific information because there are none.

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

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

The description uses a specific verb 'List', identifies the resource 'chart panes', and specifies the scope 'current layout' plus the included details 'symbols and active state'. This clearly distinguishes it from sibling tools like tab_list (tabs) and layout_list (layouts).

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. For example, it does not mention that this is the appropriate tool for enumerating panes as opposed to using chart_get_state. The description only states what it does, leaving usage context entirely implicit.

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

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

Annotations are absent, so the description alone must convey safety and behavior. It only says 'change the chart grid layout' without mentioning side effects, whether it resets existing panes, or if it requires any preconditions.

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, front-loaded sentence with no filler.

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

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

With one parameter and no output schema or annotations, the description is too minimal to be fully complete. It doesn't explain the behavior of layout changes on existing content, nor what the tool returns.

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

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

The input schema fully documents the layout parameter with all accepted codes. The description's examples ('single, 2x2, 2h, 3v') overlap with the schema but don't add additional meaning or clarify ambiguous codes.

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 changes the chart grid layout, with examples of layout codes. This distinguishes it from pane_focus (focusing a pane) and pane_set_symbol (setting a symbol), though it doesn't explicitly differentiate from layout_switch.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The description simply states the action; an agent must infer from sibling names that this handles specific grid codes while layout_switch may handle saved layouts.

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

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

No annotations are present, so the description must disclose behavioral traits. It mentions only the action and doesn't address side effects, prerequisites, validity of index, or post-conditions. For a mutating operation, this is minimal.

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

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

A single, front-loaded sentence that delivers the essential meaning without 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?

The simple operation is reasonably well-specified by the description and schema, but lacks information about error handling, valid pane indices, and how it relates to chart_set_symbol. No output schema means the return value is also unaddressed.

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 provides 100% description coverage for both parameters (index and symbol). The description clarifies their roles ('set symbol on pane by index') but adds no additional formatting or constraints beyond the schema, so baseline 3 applies.

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

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

The description uses a specific verb ('set'), identifies the resource ('symbol on a specific pane'), and specifies the mechanism ('by index'). It clearly distinguishes from sibling tool chart_set_symbol by targeting panes rather than the chart itself.

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

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

No guidance on when to use this tool versus alternatives like chart_set_symbol. The description only states what it does, leaving the agent to infer the appropriate context.

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

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

With no annotations provided, the description carries the responsibility of disclosing behavior. It clearly states that the tool does not compile, works offline, and catches specific error types. However, it does not describe the return value or output format, leaving some ambiguity about how results are presented to the caller.

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

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

The description is concise, with two sentences that front-load the core purpose and then add a key operational detail (offline, no connection). Every word contributes value, with no redundancy or irrelevant 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 and no annotations, the description provides a solid understanding of the tool's function, behavior, and use case. It could be more complete by specifying the return format or providing an example, but given the tool's simplicity, it covers the essentials well.

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 provides a full description for the sole parameter 'source' ('Pine Script source code to analyze'), giving 100% schema coverage. The tool description adds context about the analysis itself but does not add new parameter-specific meaning beyond the schema, matching the baseline for high coverage.

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

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

The description clearly states a specific action ('Run static analysis on Pine Script code') with concrete detection categories (e.g., array out-of-bounds, unguarded array.first()/last()). It explicitly distinguishes from compilation ('WITHOUT compiling') and indicates offline operation, setting it apart from sibling tools like pine_compile.

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

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

The description gives clear context for when to use this tool: for static analysis without compiling, with the added benefit of working offline and requiring no TradingView connection. It implies that compilation is not needed, but does not explicitly name alternatives or state when not to use it, so it falls short of a 5.

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. It discloses that compilation happens remotely via the server API and that errors/warnings are returned. It also implies a non-destructive validation action. It does not mention side effects, but the nature of compilation makes this less critical.

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

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

The description is two concise sentences. The first sentence states the core function, and the second provides the return value and a use case. No redundant words or filler.

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

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

Given the tool's simplicity (one parameter, no output schema), the description is largely complete. It explains the action, the return, and the use case. It could optionally mention what happens on successful compilation, but that is not essential for correct invocation.

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

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

The schema already describes the single parameter 'source' as the Pine Script source code. The description adds no new detail about the parameter's format or constraints. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's specific action: compiling Pine Script via TradingView's server API. It also distinguishes itself from sibling tools by noting that the chart doesn't need to be open, and it indicates the output (compilation errors/warnings). This goes beyond a vague purpose.

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 a clear use case: validating code before injecting it into the chart. This implies when to use the tool, though it does not explicitly mention alternative tools or exclusion scenarios. The guidance is sufficient for basic 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the critical side effect that it saves the editor buffer before compiling (persisting to the bound script). This is a non-obvious behavior that significantly affects outcomes. However, it does not mention what happens on compilation errors, whether chart state changes beyond adding the script, or if any return value is produced. The warning adds substantial value but leaves some behavioral gaps.

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

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

The description is two sentences with zero redundancy. The primary action is front-loaded ('Compile the current Pine Script and add it to the chart.'), and the warning follows as a clearly marked caution. Every sentence earns its place; the warning is essential and the structure makes it easy to parse. This is a model of concise, effective communication.

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 mostly complete. It specifies the action and the key side effect (saving). However, it does not mention how the agent should check for compilation errors (e.g., via pine_get_errors) or whether a script must be active in the editor. These are minor gaps given the tool's simplicity, but an agent might benefit from a hint about post-compile error checking.

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?

There are 0 parameters, so the baseline is 4 per the rubric. The schema is empty and the description does not need to explain parameter semantics. No additional meaning is required or provided, but the baseline holds because the tool takes no input and the schema coverage is effectively 100%.

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: 'Compile the current Pine Script and add it to the chart.' This is a distinct verb-resource pair that differentiates from siblings like pine_save (saves only) and pine_smart_compile (likely compile without adding). The specific wording leaves no ambiguity about what the tool does.

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

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

No explicit guidance on when to use this tool versus alternatives. The description does not mention pine_smart_compile, pine_get_errors, or other related tools, nor does it state conditions for use. The warning implies it saves, but there is no direct 'use this when...' or 'use X instead when...' guidance. The agent is left to infer usage from the action 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?

With no annotations provided, the description carries the full behavioral burden. It uses the verb 'Read', which implies a non-destructive, read-only operation, but it does not disclose whether the tool returns a single string, a list, or whether it requires a prior compilation or open console. It lacks explicit statements about side effects, auth requirements, or failure modes, leaving the agent with only partial information.

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, front-loaded sentence that states the main action and resource, followed by parenthetical examples. Every element earns its place, with no wasted words or redundant information. It is appropriately sized for a zero-parameter read 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?

For a simple, zero-parameter read-only tool, the description is mostly complete. It clearly names the output types (compile messages, log.info(), errors). However, without an output schema, it does not specify the exact return shape (e.g., raw string vs. array of messages), which would be helpful. Still, given the tool's low complexity, this is a minor 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?

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and the schema's empty properties object confirms there are none. No additional meaning is required.

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

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

The description uses a specific verb ('Read') and resource ('Pine Script console/log output') and gives concrete examples of content (compile messages, log.info(), errors). It clearly distinguishes from siblings like pine_get_errors (which likely returns only errors) and pine_get_source (which returns source code), making the tool's 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?

No guidance is given about when to use this tool versus alternatives such as pine_get_errors or pine_compile. The description implies it is for reading console output, but it does not explicitly state prerequisites, whether it should be called after compilation, or which scenarios would warrant using a different tool. This is a clear gap.

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 the source 'Monaco markers,' which provides context beyond the name. However, with no annotations, it does not disclose whether this is a read-only operation, whether it requires a prior compile, or what happens if no errors exist. The word 'Get' implies safety but is not explicit.

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, front-loaded sentence. It is concise and free of unnecessary words, perfectly sized for the tool's simplicity.

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 clear but incomplete due to the lack of an output schema. It does not mention the return format (e.g., an array of error strings or structured objects), which is significant for an agent deciding how to use the result. The overall simplicity of the tool keeps it from being a lower score.

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 zero parameters, and the schema trivially covers 100%. Per the baseline for 0-parameter tools, the description does not need to elaborate on parameters, and it adds no contradictions.

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 gets Pine Script compilation errors from Monaco markers. It distinguishes from sibling tools like pine_get_console and pine_compile by specifying the exact source and purpose.

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. There is no mention of prerequisites (e.g., after compilation) or when not to use it, leaving the agent to infer from the 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?

No annotations are provided, so the description carries the full burden. It states the primary operation ('Get...source code') and context ('from the editor'), which clearly is a read-only operation, but it does not disclose edge cases such as behavior when no editor is open or whether the tool can return errors.

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, front-loaded sentence with no wasted words. It states the action and resource precisely, making it exceptionally concise.

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, no-output-schema tool, the description is adequate. It identifies the source ('from the editor') and the action ('Get'), which is sufficient for a simple getter. It does not explicitly mention the return value, but that is strongly implied by 'Get source code'.

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 zero parameters, and the input schema has no properties, so the baseline is 4. The description does not need to explain parameters since there are none.

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

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

The description uses a specific verb ('Get') and resource ('current Pine Script source code from the editor'), clearly distinguishing it from siblings like pine_set_source (which writes) and pine_compile (which compiles). There is no ambiguity about what the tool does.

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

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

The description implies the tool is for reading the active editor's Pine Script source, but it does not explicitly state when to use this tool versus alternatives. There are no exclusions or prerequisites mentioned, so guidance is implied rather than explicit.

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 behavioral disclosure burden. It reveals the pagination behavior (returns a page) and hints at filtering, which is useful. But it does not disclose return format, ordering, or potential side effects. For a read-only listing tool, this is adequate but not rich.

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

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

Two sentences, front-loaded with the core purpose, no filler. The pagination caveat and name_filter hint are packed efficiently. This is ideal conciseness.

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

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

The tool is simple with fully documented parameters, but there is no output schema and the description does not describe the expected response structure. It also doesn't mention ordering or error behavior. For a listing tool, an agent might infer the result shape, but it's not fully specified.

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 covers all three parameters with descriptions, so the baseline is 3. The description adds the insight that the tool returns a page, which reinforces the purpose of limit and offset, and mentions name_filter for finding by name. This is a modest addition over the schema but not substantial.

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 ('saved Pine Scripts'), making the tool's purpose unambiguous. It also notes pagination behavior, but does not explicitly name or differentiate from sibling list tools like draw_list or alert_list, so it falls short of 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?

It provides context on pagination ('Returns a page') and hints at the name_filter parameter for searching by name. However, it does not explicitly state when to use this tool instead of alternatives or mention any exclusions, so it lacks explicit routing guidance.

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

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

With no annotations provided, the description carries the full burden. It discloses the overwrite behavior, the lack of a new-script creation, the persistence through subsequent saves/compiles, and the refusal when real content exists unless confirm_overwrite is set. This is strong transparency, though it doesn't mention potential side effects like clearing undo history or console state, which keeps it at a 4 rather than a 5.

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 front-load the core action and then deliver the critical warning. Every word earns its place; there's no redundancy or filler. The warning is strategically placed immediately after the purpose statement.

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 mutation tool with no output schema, the description covers the essential context: what it does, the destructive risk, the condition under which it refuses, and the downstream effect of save/compile. The only minor gap is that it doesn't explain what the template content looks like for each type, but that's a parameter-level detail not essential to correct invocation. The confirmation guidance is present.

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 baseline is 3. The schema documents both parameters well, including the confirm_overwrite condition and the 'Read it with pine_get_source first' guidance. The description adds little beyond repeating this, though it clarifies that 'type' selects a template variant. It doesn't enrich the parameter meanings beyond the schema, so a 3 is appropriate.

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

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

The description is explicit: 'Replace the Pine editor buffer with a blank template.' It uses a specific verb, names the resource (Pine editor buffer), and clarifies it does not create a new saved script, distinguishing it from pine_open or pine_save. The warning about overwriting further sharpens the intent.

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 clearly states the destructive nature and that a following pine_save or pine_compile persists the overwrite, giving context on when to use it (when you intend to wipe the buffer). It also mentions the refusal condition and the confirm_overwrite requirement, and the schema adds 'Read it with pine_get_source first.' However, it doesn't explicitly compare against siblings like pine_open for creating new scripts, so it falls just short of a 5.

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 does not explain what happens on success/failure, whether the script is loaded into the editor, or any side effects or prerequisites, leaving a significant transparency gap.

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, direct sentence of seven words that front-loads the action and object. It contains no unnecessary words or repetition, making it optimally concise.

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

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

The tool is simple with one fully documented parameter, and the description adequately states the core action. However, the lack of annotations and output schema means the description does not convey the operational outcome, potential errors, or any special behavior, leaving it only minimally 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?

The input schema already provides 100% coverage of the single parameter 'name', including the case-insensitive matching detail. The description adds no additional parameter semantics beyond what the schema documents, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Open') with a clear resource ('saved Pine Script') and the means of identification ('by name'), effectively distinguishing it from sibling tools like pine_new, pine_save, and pine_get_source.

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 intended usage is implied—opening an existing saved script by name—but there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions. The context is clear but limited.

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 available, the description carries full responsibility and does so well. It warns that the action persists to the cloud, overwrites the existing script, and honestly discloses that success is only reported after verification.

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 with no wasted words: the first states the action, the second warns of the destructive cloud persistence, and the third explains the verification guarantee. Every sentence earns its place.

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

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

For a zero-parameter, destructive operation, the description is complete: it explains what is saved, where it is saved, what risk is involved, and how success is determined. No output schema is present, but no return-value claims are required.

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 zero parameters and the schema coverage is 100%, so there are no parameter semantics to document. The description usefully contextualizes the implicit subject, the current Pine Script buffer.

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

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

States a specific action, resource, and destination: Save the current Pine Script buffer to the saved script the editor is bound to. This clearly distinguishes it from sibling tools like pine_compile or pine_set_source by emphasizing persistence to the cloud.

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 intended use is implied by the action ('Save the current Pine Script buffer'), but there is no explicit guidance about when to choose this over alternatives such as pine_compile or pine_set_source. No usage conditions or exclusions are provided.

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

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

With no annotations, the description must carry the full behavioral burden. It does disclose the overwrite protection and the confirm_overwrite condition, which is valuable. However, it does not mention return values, failure modes, or side effects beyond overwriting, leaving some behavioral gaps.

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

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

The description is two sentences with no wasted words. The primary action is front-loaded, and the critical overwrite caveat follows immediately. 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?

For a simple two-parameter setter with no output schema, the description covers the core behavior and the safety guard. It lacks explicit return/error details, but these are minor given the tool's simplicity and the schema's completeness.

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

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

Schema coverage is 100%, and the schema already describes both parameters, including the condition for confirm_overwrite. The description essentially repeats the overwrite condition without adding new meaning, so it meets the baseline for high schema coverage but adds little extra.

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

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

The description states a specific action ('Set Pine Script source code') on a clear resource ('the editor'), and the overwrite-refusal detail further specifies its scope. Among sibling tools like pine_get_source, pine_compile, and pine_new, this 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 does not explain when to use this tool versus alternatives (e.g., pine_new, pine_open). It only implies that reading with pine_get_source is needed before confirming overwrite, but does not provide explicit routing or exclusion guidance.

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

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

With no annotations, the description carries the full burden. It discloses the critical side effect of saving the current buffer before compiling, which is a key behavioral trait. However, it does not explain what 'reports study changes' means in terms of output or side effects, nor does it describe any other potential mutations or prerequisites. The disclosure of saving is significant but incomplete overall.

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 long sentence that mixes the core function with a warning. It is front-loaded with 'Intelligent compile' but the phrase 'detects button' is vague and not explained. The structure is adequate but could be clearer if broken into separate sentences for the warning.

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

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

The tool has no annotations and no output schema, so the description must convey all necessary context. It mentions saving and error-checking, but does not explain what the tool returns, what 'reports study changes' means, or under what conditions it should be invoked. For a tool that performs multiple actions, this is insufficient for an agent to call it confidently.

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 zero parameters, and the schema is empty with 100% coverage. The baseline for 0 parameters is 4, and the description correctly adds no parameter-related information since there are none to explain.

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

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

The description states the tool compiles, checks errors, and reports study changes, which clearly indicates its primary function. It distinguishes from sibling pine_compile by adding intelligence and error-checking, though 'detects button' is ambiguous. Overall, the purpose is clear enough for an agent to understand what the tool does.

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

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

The description mentions 'like pine_compile' but does not explicitly explain when to choose this tool over pine_compile or other compile-related tools. There is no guidance on prerequisites, scenarios, or when this is preferable. The warning about saving is helpful but not usage 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 the full burden of behavioral disclosure. It discloses the key side-effect boundary ('without touching the chart'), gives a concrete performance measurement (29 symbols ~270ms), and warns about the sibling's slow behavior. It does not detail output shape or error behavior, but these are partly covered by the schema's not_found note.

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 dense sentences with no filler. The core differentiators (MANY symbols, ONE request, no chart touch) are front-loaded, followed by a concrete use case, a performance benchmark, and a warning about the alternative.

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, this is complete: it explains what the tool does, when to prefer it, why it is fast, and what side effects it avoids. The schema handles invocation details, and the not_found behavior in the schema plus the description's focus on batch quoting give an agent enough to select and call 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 coverage is 100%, so the baseline is 3. The description reinforces the batch nature of the symbols parameter but adds no syntax or constraint details beyond the schema, which already documents exchange-prefixed symbols, duplicate collapsing, and not_found reporting.

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

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

The description uses a specific verb and resource: 'Get live quotes for MANY symbols in ONE request'. It immediately distinguishes itself from quote_get, which is the key sibling it could be confused with, by noting it does not touch the chart.

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

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

It explicitly says 'Use this for watchlist and universe sweeps' and warns against looping quote_get, stating that quote_get switches the chart symbol and takes ~20s each. This gives the agent a clear when-to-use and when-not-to-use rule with a named alternative.

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. It proactively discloses that a non-blank symbol causes a temporary chart switch, serializes concurrent calls, and restores the original chart. This is valuable beyond what the schema explains. It does not cover all possible side effects (e.g., errors, rate limits), but the key structural behavior is 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 two sentences: first states the purpose, second packs the critical side effects. Every word earns its place, with no filler or repetition. It is front-loaded and appropriately sized for a simple one-parameter 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?

The tool is simple with one parameter and no output schema, but the description does not explain what data is actually returned (e.g., bid, ask, volume). Since there is no output schema to fill that gap, the description should provide some indication of the response structure. The side effects are well-documented, but the return value is left ambiguous, making the description slightly incomplete.

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

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

The input schema already provides full coverage of the 'symbol' parameter, including the blank-means-current-chart behavior. The description adds one extra detail not in the schema—serialization of concurrent calls—which is useful. However, most of the description's parameter-related content is redundant with the schema, so it only marginally exceeds the baseline.

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

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

The description clearly states 'Get quote data' with a specific verb and resource, making the core purpose evident. It also adds a distinguishing behavioral note about temporary chart switching, which differentiates it from generic data tools. However, 'quote data' is somewhat broad and does not explicitly contrast with siblings like symbol_info, so it's not a perfect 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?

No explicit guidance is given on when to use this tool vs alternatives. The behavioral note about symbol changes is useful but does not address selection criteria, prerequisites, or exclusions. An agent must infer usage context solely from the phrase 'Get quote data'.

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

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

With no annotations provided, the description must disclose behavioral traits itself. It mentions the toggle behavior and the confirmation step ('Confirms the result by reading autoplay back'), which adds value. However, it does not describe potential side effects (e.g., dependencies on replay being active) or any failure modes, leaving gaps in 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 three concise sentences, front-loaded with the primary action and resource. Every sentence contributes: the action, the parameter semantics, and the confirmation behavior. No fluff or redundancy.

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

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

Given the tool's simplicity and the rich parameter descriptions in the schema, the description covers the essential aspects: action, optional parameters, and confirmation. It lacks explicit preconditions (e.g., whether replay must be active), but for a simple toggle this is a minor gap. The absence of an output schema means the confirmation statement partially compensates for return-behavior expectations.

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 meaning beyond the schema by explaining the optional 'enabled' parameter's flip behavior and that speed is optional and combined with state change. This clarifies usage semantics that the schema alone does not fully convey.

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 ('Turn autoplay on or off in replay mode'), specifies the resource (autoplay within replay mode), and mentions optional speed setting. This distinguishes it from sibling tools like replay_start/stop, which control replay playback itself rather than autoplay state.

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

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

It gives explicit instructions on parameter use: 'Pass enabled to say which state you want; omit it to flip whatever the current state is.' This tells the agent exactly how to invoke the tool for desired outcomes. However, it does not explicitly contrast with alternatives or state when not to use it, though the context of replay-autoplay vs replay-start/stop is implicit.

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

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

With no annotations, the description carries the full burden. It states the primary behavior (starting replay mode) and mentions the optional date, but does not disclose side effects, state changes, or requirements like having a chart open. This is acceptable for a simple mode-toggle tool but lacks depth.

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

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

The description is a single sentence of nine words, front-loaded with the action verb 'Start' and the resource. Every word earns its place, with no redundant filler.

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

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

For a tool with one optional parameter and no output schema, the description is mostly complete. It covers the primary function and the optional parameter. It does not place the tool within the replay workflow (e.g., suggesting replay_step for advancing), but that is not essential for executing the tool correctly.

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

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

Schema description coverage is 100% for the single optional 'date' parameter, which is fully documented. The description's mention of 'optionally at a specific date' merely reiterates the schema, adding no extra semantic value beyond the structured data.

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

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

The description uses a specific verb 'Start' with a clear resource 'bar replay mode', distinguishing it from siblings like replay_stop, replay_status, and replay_step. It unambiguously states the tool's 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 implies usage context (entering replay mode) but does not explicitly contrast with siblings such as replay_autoplay, replay_step, or replay_trade, nor does it state prerequisites or follow-up actions. It provides only implied guidance.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It implies a safe read operation via 'get', but does not describe what the returned status looks like, whether it can fail, or any side effects. It is minimally 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 entire description is a single, front-loaded sentence with no filler words. It clearly communicates the tool's function in just six 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?

This is a simple getter with no parameters and no output schema. The description is adequate for the core function but omits information about the return value format or possible statuses, which would be useful given the output schema is absent.

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 zero parameters, so the input schema is empty. The baseline score of 4 applies, as there is nothing to document and the description adds no parameter 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 uses a specific verb 'get' with a resource 'replay mode status', clearly indicating this tool queries the current replay mode state. It distinguishes from sibling tools like replay_start, replay_stop, and replay_step, which are actions rather than status queries.

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

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

The description offers no guidance on when to use this tool versus alternatives. It does not mention whether it should be called before starting replay, or how it relates to replay_autoplay or other replay tools.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It explains the step increment ('one bar') but omits important details such as whether replay must be active, what happens if called outside replay mode, or any side effects on the chart view.

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, front-loaded sentence with no redundant words. It efficiently conveys the action and resource, fitting the simple nature of the 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?

The description is minimally sufficient for a parameterless step action, but it lacks contextual details about replay state requirements and how it fits into the broader replay workflow. Given the simplicity of the tool, it is adequate but not rich.

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

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

The tool has zero parameters and the input schema is empty, so there is no parameter semantics to explain. The baseline score of 4 applies because the schema coverage is trivially complete and the description needs no compensation.

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 ('Advance') and the resource ('one bar in replay mode'), making the tool's purpose specific and unambiguous. It also distinguishes from siblings like replay_autoplay by emphasizing the manual single-bar step.

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 such as replay_autoplay or replay_stop. It does not mention any prerequisites like replay mode being active or the expected context for invocation.

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

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

No annotations are provided, so the description carries the full burden. It states the primary effect and result, but does not disclose edge cases (e.g., behavior if no replay is active) or side effects beyond the immediate action.

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 front-loaded sentence with no unnecessary words. Every word contributes to clarity.

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

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

Given the simplicity of the tool (no params, no output schema, no annotations), the description is fully sufficient to understand its purpose and effect. It covers the required information for correct invocation.

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

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

The tool has zero parameters and an empty input schema. Per the rubric, this warrants a baseline of 4 since there is no parameter meaning to add.

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

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

The description uses a specific verb ('Stop'), identifies the resource ('replay'), and states the outcome ('return to realtime'). This clearly distinguishes it from sibling tools like replay_start and replay_step.

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 clearly conveys when to use the tool: to exit replay mode and resume realtime data. While it does not explicitly mention alternatives or exclusions, the context is unambiguous for an 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, the description carries the full burden of behavioral disclosure. It only states the action and does not reveal what happens after execution, whether it requires an active replay session, what side effects occur on position state, or potential errors. This is a significant transparency gap for a mutation-like tool.

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

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

The description is a single concise sentence, front-loaded with the core verb 'Execute' and resource 'trade action in replay mode'. It contains no filler and every phrase earns its place, including the parenthetical list of actions.

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

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

For a tool with one parameter and no output schema, the description conveys the core purpose adequately. However, it omits important context such as the requirement for an active replay session and the outcome of the trade action, leaving some gaps for the agent to infer. More detail would improve completeness.

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

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

The schema already provides 100% coverage for the single 'action' parameter with a description listing buy, sell, close. The tool description repeats the same values without adding new meaning, so it meets the baseline but does not enhance parameter understanding beyond the schema.

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

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

The description clearly states the tool's function: 'Execute a trade action in replay mode' and explicitly lists the allowed actions (buy, sell, or close position). It distinguishes itself from replay control siblings like replay_start and replay_step by focusing on trade execution, not replay navigation.

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 establishes clear usage context: this is for trade actions during replay mode. It implies the tool is used when the user wants to simulate a trade in a replay session. However, it does not explicitly exclude alternatives or mention prerequisites (e.g., replay must be active), so it lacks the full when/when-not guidance.

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