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 burden of explaining behavior. It discloses that only active alerts are returned, but does not mention response format, pagination, or lack of side effects. The read-only nature is inferable from 'List' but not explicitly stated.

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, front-loaded sentence. There is no wasted wording 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?

Given the zero-parameter schema and no output schema, the description is minimally sufficient for an agent to invoke the tool. However, it does not describe what is returned, how active status is determined, or any limits, leaving some ambiguity for a tool that could return a structured list.

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 no parameters, so the description does not need to explain parameter details. The baseline of 4 applies because there is nothing missing in parameter semantics.

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

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

The description uses a specific verb and resource: 'List active alerts'. It clearly distinguishes this from its alert siblings (alert_create, alert_delete) by indicating a read-only listing operation rather than creation or 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?

There is no explicit guidance about when to use this tool versus alternatives, but the intended usage is strongly implied by the verb and resource. No sibling tool performs a similar list operation, so the risk of confusion is low.

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 behavioral disclosure burden, and it is a single 9-word sentence that reveals nothing. Key traits are undisclosed: the tool mutates chart state (implied only by the restore_start_state parameter's mention of a 'guaranteed cleanup path'), loops with pacing delays, and has unspecified partial-failure semantics. The schema clues help, but the description itself adds no behavioral 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?

One front-loaded sentence with zero filler. The verb 'Run' leads, the resource follows, and the multi-symbol/multi-timeframe scope is delivered immediately. For a tool whose detailed parameter semantics live in the schema, this is ideal sizing.

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 an 8-parameter orchestration tool with no output schema and no annotations, the description is too thin. It doesn't explain what the aggregated return looks like, how to choose between batch_run and similar siblings (strategy_sweep, quote_batch, the singular data_get_* tools), that the tool navigates the chart and restores state, or how failures in individual iterations are handled. The schema covers parameter meaning well but not these tool-level operational details.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter meaning, but every parameter is well-documented in the schema with enums, ranges, defaults, examples, and usage hints (e.g., study_filter's substring matching, action's per-action guidance). The schema does the heavy lifting and the description doesn't need to compensate.

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 ('Run'), a resource ('an action'), and a clear scope ('across multiple symbols and/or timeframes'). This conveys the batch/fan-out nature that differentiates it from the singular data_get_* siblings (data_get_ohlcv, data_get_study_values, etc.), though it doesn't name an alternative explicitly.

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 never states when to use this tool vs. singular alternatives or other batch tools like strategy_sweep or quote_batch. Some usage guidance exists inside the schema — the action parameter notes get_study_values 'is the one to use for universe scans' and entity_id gives strategy-specific advice — but tool-level when-to-use/when-not-to-use context is only implied by the phrase 'across multiple symbols and/or timeframes'.

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 does well by revealing the hidden-tab refusal, explaining why the returned image could be stale, and noting that region:'chart' reports the selector used. It does not describe the output format, but the key safety and correctness caveats are transparent.

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

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

The description is compact and front-loaded with the primary action. The hidden-tab warning and region clarification are high-value additions, and every sentence earns its place without 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 five optional parameters and no output schema, the description covers the most critical behavioral caveats and parameter nuances. It could go further by explaining what the tool returns or how method choices (cdp vs api) affect results, but the combination of schema and description is largely sufficient for an agent to 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 adds value beyond the schema by clarifying that region:'chart' captures the active pane and reports which selector found it, and by explaining the hidden-tab behavior relevant to allow_hidden. This exceeds what the parameter list alone communicates.

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 and resource: 'Take a screenshot of the TradingView chart.' It also adds meaningful scope details like region:'chart' capturing the active pane. It does not explicitly differentiate from sibling tools by name, but the core 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 provides important usage context: it refuses on hidden tabs and warns about stale frames, and it explains that region:'chart' targets the active pane. However, it does not explicitly state when to prefer this tool over alternatives or when not to use it beyond the hidden-tab caveat.

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 correctly signals a read operation and names what is returned, but does not disclose prerequisites (e.g., whether a chart/tab must be open) or whether the indicators list is full details or just names. Adequate for a zero-parameter read, but not riich behavioral context.

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

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

A single front-loaded sentence with zero waste: the verb and resource come first, and the parenthetical enumerates the return contents economically. Every word carries 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?

For a zero-parameter getter with no output schema, the description gives a usable summary of what comes back. The main gaps are the lack of an explicit return shape (a booleans? strings? a structure?) and any prerequisite about an active chart, but the complexity is low enough that this is nearly 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, which is the baseline-4 case per the rubric. There is nothing for the description to explain, and it correctly avoids inventing param 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?

States a specific verb ('Get') and resource ('current chart state') and enumerates the exact contents: symbol, timeframe, chart type, indicators. This clearly distinguishes it from the chart_set_* siblings (mutators) and chart_get_visible_range (a narrower getter for a different aspect of 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?

Usage is implied by the 'Get' verb and the listed state components, but the description never explicitly says when to choose this over related getters like symbol_info, tv_ui_state, or chart_get_visible_range. There are no exclusions or alternative routing, so it sts at implied usage rather than explicit 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 disclosure burden. It makes the read-only nature explicit with 'Get' and specifies what is returned (unix timestamps and bars range). It does not mention prerequisites like whether a chart must be open, but for a simple getter the core 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?

One sentence that leads with the action and resource, gives the timestamp format parenthetically, and names the second returned component. Zero filler 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?

For a zero-parameter getter, this is mostly adequate, but no output schema exists and 'bars range' is left underspecified (e.g., indexes vs count vs offsets). The description names the return categories but does not fully define their structure or units.

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 takes zero parameters, which is baseline 4. The input schema is empty, so there is no parameter information for the description to clarify or supplement.

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 ('Get'), a specific resource ('visible date range'), an explicit format ('unix timestamps'), and a second resource ('bars range'). This clearly separates it from the setter sibling chart_set_visible_range and from the more general chart_get_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?

There is no explicit guidance about when to use this tool versus alternatives such as chart_get_state or chart_set_visible_range. The usage is only implied by the tool name and the simple 'Get' 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?

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 carries the full burden. It does disclose the core behavior—changing the viewport to center on a date—but says nothing about side effects, failure behavior for out-of-range dates, or whether the chart must already be launched. This is adequate but has 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?

A single, front-loaded sentence with no filler. The verb and object are immediately clear, and the rest of the sentence adds the only needed detail.

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 one-parameter navigation command with no output schema, the description is functionally complete: an agent knows what action to take and what input is relevant. It omits edge-case behavior on invalid or out-of-range dates, but that is less critical for a simple viewport jump.

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 fully describes the single 'date' parameter as an ISO date or Unix timestamp string (100% coverage), so the baseline applies. The description adds only the context that this date is the centering target, without extra format, syntax, or edge-case semantics.

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

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

The description uses a specific action ('jump ... to center') on a well-defined resource ('chart view') with a precise target ('a specific date'). This clearly separates it from siblings like chart_set_symbol, chart_set_timeframe, or chart_set_visible_range, which change other aspects of 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?

No guidance is given on when to use this tool vs alternatives such as chart_set_visible_range or replay controls. The purpose statement implicitly suggests the use case, but there is no explicit context, prerequisite, or exclusion to help an agent choose among navigation-related 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?

There are no annotations and the description only says 'Change the chart symbol.' It implies mutation but discloses no side effects, prerequisites, permissions, reversibility, or what happens to the current 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 and front-loaded with the action and target. It contains no filler, though it is so minimal that it omits useful 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?

For a simple one-parameter setter, the description plus schema is minimally sufficient to invoke the tool. However, it lacks guidance on the active chart context, relationship to pane_set_symbol, and any behavioral expectations, leaving clear 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 single 'symbol' parameter with an example. The description adds no additional meaning beyond what the schema already provides, 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 verb and resource: change the chart symbol. It is clear and distinguishable from chart_set_timeframe and chart_set_type, though it does not explicitly differentiate from close siblings like pane_set_symbol.

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 symbol_search, symbol_info, or pane_set_symbol. The description provides no context for choosing this tool over its 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 of behavioral disclosure. It does reveal the core mutation—changing the chart's timeframe—but says nothing about side effects, whether the chart must already exist, how the change affects indicators or overlays, or what happens on failure. This is minimal behavioral 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 a single short sentence with no filler, front-loading the verb and resource. It is appropriately sized for a tool with one parameter and low overall complexity.

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 setter, the core invocation is clear and the schema covers the input details. However, with no annotations and no output schema, the description omits useful contextual information such as prerequisites, expected outcome, and how this differs from related chart operations. It is adequate 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 schema already provides a complete description of the single 'timeframe' parameter with examples, giving 100% schema coverage. The description adds only the synonym 'resolution' and no additional format, constraints, or domain guidance, 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 states a specific action ('Change') and a specific resource ('the chart timeframe/resolution'), making the tool's purpose clear. It largely restates the tool name but adds 'resolution' as a synonym for timeframe. It does not explicitly differentiate it from sibling tools like chart_set_symbol or tv_launch, so it does not earn 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?

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites such as an active chart, and no indication of when a timeframe change is appropriate. The correct usage context is entirely left to the agent to infer.

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 only states that a chart type is changed, without disclosing that this modifies the active chart's state, whether it is reversible, any persistence or side effects, or what happens on failure. Minimal behavioral insight beyond the name 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 three words with no wasted content and is front-loaded. It is efficient, though arguably too terse to carry the behavioral disclosure burden for a mutation 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 setter the tool is mostly invokable with the well-documented parameter, but the description lacks explicit scope (active chart), return/confirmation behavior, or potential failure modes. Without annotations or an output schema, an agent gets only the bare minimum.

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 sole parameter chart_type is thoroughly documented with all valid values and the instruction to pass name or number. The description adds nothing 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 'Change chart type' uses a clear verb and specific resource. It distinguishes itself from sibling tools like chart_set_symbol and chart_set_timeframe by naming the chart type as the target. It could be slightly more specific about which chart is affected, but the core 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 offers no guidance on when to use this tool versus alternatives, no prerequisites, and no information about the target context (e.g., active chart). Usage must be inferred entirely from the tool name and sibling naming pattern.

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 mentions zooming but does not explain whether the existing visible range is replaced, whether a chart must already be loaded, how invalid ranges (from > to) are handled, or whether the change is reversible.

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. It conveys the action, the target, and the relevant unit context efficiently.

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, the description plus schema is sufficient to understand the basic call. However, the absence of annotations and the lack of behavioral or usage context leave gaps around prerequisites and side effects, so it is 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?

Schema coverage is 100%, with both 'from' and 'to' already described as unix timestamps in seconds and start/end of range. The description adds the phrase 'specific date range' but no additional semantic detail beyond what the schema provides, 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 states a specific verb ('Zoom') and resource ('the chart') and clearly indicates the action is setting the visible date range. This distinguishes it from sibling tools like chart_get_visible_range (read) and chart_scroll_to_date (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?

No guidance is given about when to use this tool versus alternatives such as chart_scroll_to_date or chart_get_visible_range. There are no prerequisites, exclusions, or context clues beyond the implicit meaning of 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?

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Get' implies a read-only operation, but the description does not explain what is actually returned, whether there are side effects, or how the response is structured. This is minimal but not wholly 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, efficient sentence with no filler. It front-loads the key action and object, though it could have used the space to disambiguate from sibling tools without becoming verbose.

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

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

For a simple one-parameter getter, the description is marginally adequate, but it misses an explicit link to chart_get_state for obtaining the entity_id and does not clarify the distinction between indicator input values and computed study values. Given no output schema, the return format is also left unspecified.

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 the entity_id parameter already documented as 'Study entity ID (from chart_get_state)'. The tool description adds no parameter-specific meaning beyond what the schema provides, so the 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 clearly states the verb 'Get' and the resource 'indicator/study info and input values', making it easy to see this is a retrieval operation. However, it does not explicitly distinguish itself from the sibling data_get_study_values, which could overlap with 'study info' in an agent's mind.

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 like data_get_study_values or data_get_ohlcv. The parameter description 'from chart_get_state' implies a prerequisite but the tool description itself lacks any 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 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 full burden of behavioral disclosure. It states the operation is a read ('Read'), describes deduplication behavior, and specifies the returned data shape ('{high, low} price zones'). It could additionally mention edge cases like no matching boxes or sorting, but the essential safety and output traits are 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 with no filler. The main action and output are stated first, followed by a concise parameter hint in the second sentence. Every phrase carries informational weight.

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: two optional parameters, no annotations, no output schema. The description gives the return type, the data source, and a filtering tip, which is sufficient for a basic read operation. It stops short of covering no-match behavior or the format of verbose output, but those are minor given the low complexity.

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

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

Schema description coverage is 100%, so the schema already fully documents both 'verbose' and 'study_filter'. The description adds only a slight rephrasing of study_filter's purpose ('target a specific indicator') without introducing any meaning beyond what the schema provides, earning the baseline 3.

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

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

The description uses a specific verb ('Read'), a precise resource ('box/zone boundaries drawn by Pine Script indicators (box.new)'), and clearly states the output ('deduplicated {high, low} price zones'). It is instantly distinguishable from sibling tools like data_get_pine_lines, data_get_pine_labels, and data_get_pine_tables.

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

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

The description implies when to use this tool by naming the box/zone data source, which differentiates it from line/label/table readers. However, it does not explicitly mention alternatives or provide exclusion criteria, and the only guidance ('Use study_filter to target a specific indicator') is parameter-level rather than tool-selection-level.

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 communicates a read-only operation and the return format, but does not discuss output limits, error cases, or whether a chart must contain the indicator. It's acceptable but minimal.

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

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

Three terse, front-loaded sentences with no filler. The purpose, return shape, and filter hint are each in their own sentence.

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 tool with no output schema and three optional, fully documented params, the description covers what it returns and how to filter. It could add a note about alternatives or prerequisites, but nothing essential 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?

Schema description coverage is 100%, so the baseline is 3. The description adds a small hint for study_filter but doesn't enrich verbose or max_labels 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?

States a specific verb ('Read') and resource ('text labels drawn by Pine Script indicators (label.new)'), and distinguishes from sibling tools like data_get_pine_lines and data_get_pine_boxes by focusing on labels. Also specifies return format ('text and price pairs').

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 (read text labels) and gives a filter hint ('Use study_filter to target a specific indicator'), but doesn't explicitly contrast against sibling tools or state when not to use it. No alternatives or exclusions are mentioned.

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 disclosure burden. It explicitly states the operation is a read ('Read'), and adds a useful behavioral trait: 'Returns deduplicated price levels per study.' It does not mention what happens when no matching study or lines exist, and it omits output-shape details, but the core behavior is clearly disclosed.

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, each earning its place: the first establishes the tool's purpose and input, the second explains the return behavior and filtering. 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 two-parameter read-only tool with no output schema, the description is nearly complete: it states what is read, the deduplication behavior, and how to target a study. It just stops short of describing the returned shape or empty-result behavior, but the schema covers parameter details and the operation is simple enough not to require more.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters. The description reinforces study_filter with 'Use study_filter to target a specific indicator,' but adds no new parameter semantics beyond what the schema provides; hence 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 names a specific verb, resource, and scope: 'Read horizontal price levels drawn by Pine Script indicators (line.new).' It clearly distinguishes this from sibling data_get_pine_labels/boxes/tables by focusing on horizontal price levels and line.new, and additionally states the deduplicated per-study output.

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

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

The description gives clear context for when to use it: to read horizontal Pine line levels, with 'Use study_filter to target a specific indicator' as explicit parameter guidance. It does not explicitly contrast it with alternatives like data_get_pine_labels or data_get_study_values, so it misses the full 'avoid when...' 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 states that the tool reads data and returns formatted text rows per table, which covers the core behavior. However, it does not describe edge cases like absent tables, multiple matching studies, or whether the data reflects the current 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?

Three short sentences deliver the essential information with no filler. The primary action and target resource are front-loaded, and the parameter guidance is compact. 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?

The tool is simple: one optional parameter and no output schema. The description adequately covers the return format and the filtering mechanism. Combined with the fully self-documenting schema, the main missing context is minor—such as how multiple tables are represented or whether an empty result is possible—so it remains sufficiently complete 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?

Schema description coverage is 100%, so the baseline is 3. The description repeats the study_filter parameter and says it targets a specific indicator, which echoes the schema's 'Substring to match study name. Omit for all.' It adds no material new meaning beyond the schema.

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

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

The description opens with a specific verb and resource: 'Read table data drawn by Pine Script indicators (table.new).' It clearly distinguishes this tool from siblings like data_get_pine_lines, data_get_pine_labels, and data_get_pine_boxes by focusing on tables. The added return detail, 'formatted text rows per table,' further disambiguates its 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 gives clear context for when to use the tool: whenever table data from Pine Script indicators is needed, and it mentions using study_filter to target a specific indicator. It does not explicitly name alternatives or exclusion cases, but the 'table data' scope makes the appropriate use case evident.

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 full burden. It discloses that the tool reads current values and only for visible studies, which is useful. But it does not describe the output format, whether values are last-bar snapshots or series, or how multiple studies like Bollinger Bands are represented.

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, focused sentence with a helpful parenthetical list of study types. Every word contributes meaning, with no redundancy 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?

The tool is simple with no parameters, but it also has no output schema. The description names the data source and scope but remains vague about the returned structure, which matters for an agent consuming the result programmatically. It is adequate but leaves room for 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?

The tool has 0 parameters and the schema is fully empty, so there is no parameter information that the description needs to add. 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 clearly states a specific verb ('Get'), a specific resource ('current indicator values from the data window'), and a precise scope ('all visible studies'). It also gives concrete examples (RSI, MACD, Bollinger Bands, EMAs, custom indicators), which makes the tool's function unmistakable and distinguishes it from sibling 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 'all visible studies' gives clear context for when this tool is appropriate. However, it does not explicitly state when to prefer a sibling tool like data_get_indicator for a single indicator, nor does it mention exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It 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 of behavioral disclosure. It conveys that the operation is a read ('Get') and that data comes from the chart, but it does not disclose whether a chart must be open, whether the data is real-time or snapshot-based, or whether the tool is unsupported for certain market types. This is minimal behavioral information for a no-annotation 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, direct sentence with the action and object front-loaded. It contains no filler and every word contributes to the 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?

For a zero-parameter getter, naming the resource and source covers basic selection and invocation. However, with no output schema and no annotations, the description does not clarify the return shape, whether the active chart symbol is used implicitly, or if order book data is available for all symbol types. It is adequate but leaves meaningful operational details to inference.

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 zero parameters, so there is no parameter documentation gap for the description to fill. The baseline for a no-parameter tool applies, and no further parameter-level detail is needed.

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 names a specific verb and resource: getting order book/DOM data, and it notes the data source is the chart. This clearly distinguishes it from sibling retrieval tools like quote_get or data_get_ohlcv, whose resources are explicitly different. The parenthetical '(Depth of Market)' also removes ambiguity about the acronym DOM.

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

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

There is no guidance on when to use this tool versus alternatives such as quote_get, data_get_trades, or data_get_ohlcv, and no exclusion conditions are stated. The phrase 'from the chart' implies a dependency on the active chart but does not say it explicitly or mention prerequisites.

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

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

No annotations 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?

With no annotations, the description must carry behavioral disclosure itself. It indicates a read-only operation by saying 'Get' and specifies the returned content (properties and points), but it does not disclose error behavior, return structure, or any side effects—though for a simple getter the lack of side effects is reasonably clear.

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

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

The description is a single concise sentence that front-loads the verb and resource with no filler or redundant detail. It earns high marks for efficiency.

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 a clear noun phrase about what is retrieved. However, with no output schema, the description could be more explicit about the shape of the returned properties and points; as written, an agent knows what to expect semantically but not structurally.

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 entity_id parameter is already documented with context that it comes from draw_list. The tool description adds no additional parameter semantics, which is acceptable given the schema already covers the only parameter.

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

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

The description clearly states the operation (get) and resource (properties and points of a specific drawing), making it distinct from broad listing tools like draw_list. It does not explicitly name sibling alternatives, but 'specific drawing' helps signal single-entity retrieval.

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

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

The schema description adds 'from draw_list', implying the correct prerequisite workflow of listing drawings first. However, the tool description itself gives no explicit guidance on when to choose this tool over alternatives like draw_list or draw_remove_one.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the destructive action and does not explain whether removal is permanent, what happens if the entity_id is invalid, or what the tool returns.

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. It efficiently communicates action, resource, and selection key.

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 and the schema covers the single parameter, but there is no output schema and no annotations to fill in behavioral gaps such as error handling, idempotence, or confirmation of removal. The description is adequate for invoking the tool 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?

Schema description coverage is 100%, so the entity_id parameter is already fully documented. The description adds only 'by entity ID,' which confirms the selection mechanism but provides no additional meaning beyond the schema.

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

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

The description uses a specific verb ('Remove'), a clear resource ('drawing'), and a precise selection mechanism ('by entity ID'). This clearly distinguishes it from draw_clear, which removes all drawings, and from read-only siblings like draw_list and draw_get_properties.

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 this tool is for removing a single drawing by ID, and the schema's reference to draw_list hints at the required workflow. However, it never explicitly names draw_clear as the alternative for removing all drawings or states when not to use this tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals an important non-obvious trait: the created shape name is read back and unrecognized names are refused instead of silently becoming a flag. This goes beyond the schema by clarifying failure behavior. It doesn't discuss persistence or side effects, but for a drawing tool the core mutation is evident.

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, zero filler. The primary purpose is front-loaded, and the second sentence adds a high-value behavioral warning in compact form.

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 5-parameter tool with nested objects and no output schema, the description plus a fully covered schema is mostly complete. The read-back/refusal note supplies important edge-case behavior. Minor gaps remain around return value structure and where drawn shapes appear, but these don't block 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 top-level description carries no parameter details; the input schema already documents all five parameters with 100% coverage. Per the baseline, that is adequate but not enhanced. The refusal behavior is relevant to the shape parameter but duplicates what the schema's shape description already states.

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 a specific verb and resource — 'Draw a shape/line on the chart' — which clearly identifies the action. It also distinguishes the tool from sibling tools by focusing on creation, while siblings like draw_list, draw_clear, and draw_remove_one cover listing, clearing, and removing shapes. No ambiguity about what this 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 opening sentence gives clear context: use this tool when you want to draw a shape or line on the chart. It does not explicitly name alternatives or state when not to use it, but among the draw_* siblings the creation-versus-management distinction is apparent enough for an agent to select correctly.

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?

With no annotations, the description carries the behavioral burden. It clearly frames the operation as a read with no side effects, and adds context about checking applied settings and capturing configuration context. It stops short of describing error cases or exact return shape.

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

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

Two sentences, no filler. The core action is front-loaded, and the use cases each add distinct value without redundancy.

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

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

For a single-parameter read tool, the necessary invocation details are present: what it reads and why to use it. The main gap is the absence of any output schema or explicit statement about the return format, though 'values back' implies the returned content.

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 sole parameter entity_id is already fully described in the schema as coming from chart_get_state. The description adds no param-level meaning, so the baseline of 3 applies because the schema does the heavy lifting.

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

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

The description opens with a specific verb and resource: 'Read a study's current input values back.' It clearly distinguishes the tool from its sibling indicator_set_inputs by describing the read direction rather than the write direction.

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 concrete usage scenarios: confirm indicator_set_inputs landed, detect manual changes, and record configuration. It references the related setter tool, but it does not explicitly name alternatives or state when not to use the tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals a non-obvious behavior: a control query is run first, and an empty result is only trustworthy when verified_empty is present; otherwise zero results should be treated as unknown. This is valuable beyond what the schema or annotations could convey, though it does not detail the full result structure.

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

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

The first sentence is compact and front-loaded with the purpose. The second sentence is longer but earns its place by explaining a critical failure mode. It is slightly verbose but contains 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?

The description is strong on the empty-result caveat and the schema covers both parameters, but there is no output schema and no mention of what the successful result structure looks like. An agent would need to infer how to consume results for downstream actions like indicator_add_from_search. The core behavior is described, but return-shape details are 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?

The schema already documents both parameters fully (query and limit with descriptions, min, max, default). The description adds no parameter-level meaning beyond the schema, 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 names a specific verb ('Search') and a clear resource ('TradingView built-in, community, strategy, and saved-script studies'). It differentiates from sibling tools like indicator_add_from_search and symbol_search by specifying the exact domain and scope of the search.

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 searching TradingView studies and gives important guidance on interpreting empty results, but it does not explicitly state when to use this tool versus alternatives like indicator_add_from_search or when not to use it. The empty-result caveat is behavioral guidance, not tool-selection 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 of behavioral disclosure. It states the basic mutation ('Change ... input values') but does not explain how overrides are applied, whether they replace or merge with existing values, what happens on invalid input IDs, or what the response/return value is.

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 compact sentence that clearly fronts the core action and includes relevant examples. There is no filler or redundancy; every part contributes to understanding the tool's purpose.

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

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

The tool is relatively simple and the schema already documents the required parameters, but with no annotations or output schema, the description does not fully cover behavioral results or error conditions. An agent could invoke it correctly, but might not understand side effects or how to interpret 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?

Schema description coverage is 100%, and the schema already explains both parameters, including that 'inputs' is a JSON string of overrides. The description's examples add minor illustrative value but do not provide additional semantic meaning beyond the schema.

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

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

The description uses a specific verb ('Change') and a clear resource ('indicator/study input values'), with illustrative examples ('length, source, period'). It distinguishes the tool from siblings like indicator_add or indicator_toggle_visibility, 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 implies it should be used when modifying existing indicator/study input values, but it gives no explicit guidance on when not to use it or which alternative tools to prefer. There is no mention of prerequisites such as a loaded study or where to obtain the entity_id, which the schema partially covers.

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 provided, the description carries the full burden of behavioral disclosure. It reveals that the new chart starts empty, that subsequent saves are required to persist added content, and that verification should be done by re-reading the account rather than trusting the return value.

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

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

Three sentences, each earning its place: purpose and differentiation, required workflow, and verification caveat. Information is front-loaded and there is 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 simple single-parameter creation tool with no output schema and no annotations, the description provides enough context to invoke it correctly, including the initial state, required follow-up actions, and how to verify success.

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 the single required parameter 'name' with a clear example. The description adds minimal semantic value 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?

States a specific action: create a NEW chart and save it under a given name. It distinguishes itself from layout_list and layout_switch, which can only operate on already-existing layouts, making its 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?

Explicitly says when to use this tool: when building a chart from scratch. It names the alternatives (layout_list and layout_switch) and explains their limitation, then outlines the follow-up steps: add studies, set timeframe, and call layout_save again.

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 burden. It clearly implies a read-only operation by saying the tool reports what the chart is 'currently showing' and by framing it as a confirmation/detection mechanism. It also adds useful context that the result reflects live user state, not just stored metadata.

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 compact and front-loaded: it states what the tool reports first, then lists specific use cases. Every sentence adds value, and there is no redundant restatement of the tool name or schema.

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 state query, the description is largely complete: it explains the returned concept and when to use the tool. It does not specify the exact return format or edge-case behavior when no layout is active, but the core information an agent needs 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?

The tool has zero parameters and the schema coverage is 100%, so there is nothing for the description to add about parameter behavior. The baseline of 4 applies, and the description adds relevant context about what the returned value represents.

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 identifies the tool as a state query: it reports which saved layout the attached chart is currently showing. It distinguishes this from sibling tools like layout_switch and layout_list by emphasizing the current, active layout of the attached chart. Although it lacks an explicit imperative verb, the meaning 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 gives three concrete use cases: confirming a layout switch landed, detecting user movement after a setup was saved, and attributing a reading to a specific chart. It does not explicitly mention when not to use this tool or name alternatives, but the use cases make the context 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, 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?

There are no annotations, so the description must carry the behavioral burden. It discloses that the save is silent, that no Save-As dialog appears, and that the tool verifies the account actually lists the layout instead of trusting the save. This is strong transparency, though it doesn't cover potential overwrite behavior or failure handling.

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?

Four dense sentences with no fluff. The core action and naming semantics are front-loaded, followed by usage context and verification behavior. 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 single-optional-parameter tool with no output schema and no annotations, this is complete. It covers the action, the naming pathway, when to call it, and the post-save verification. An agent has enough to invoke it correctly and understand its outcome.

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 meaningful context beyond the schema: it explains that passing the name is what actually names the layout and explicitly contrasts this with layout_create. This reinforces the parameter's role without merely repeating the schema text.

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 and resource: 'Save the current chart layout'. It also explicitly distinguishes itself from layout_create: 'that is what names a layout, not layout_create'. An agent can immediately understand what this tool does and how it differs from its closest sibling.

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 when-to-use guidance: 'Call this after changing symbol, timeframe or studies so the layout keeps them'. It also clarifies where naming does and does not happen by pointing away from layout_create, giving the agent a clear decision rule.

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?

With no annotations or output schema, the description carries the full behavioral burden. It communicates a read-only listing action and specifies the output content (panes with symbols and active state), which is sufficient for a simple, side-effect-free tool. It does not detail return formatting or ordering, but these are minor for this 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?

A single, front-loaded sentence states the action, object, scope, and included output fields. Every part is informative and there is no redundancy 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?

For a zero-parameter listing tool, the description is nearly complete: it identifies the object type, scope, and returned attributes. It could marginally clarify the structure of 'active state' or how panes are ordered, but an agent can reasonably invoke the tool with the provided information.

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 there is nothing for the description to explain beyond stating the operation's scope. The baseline for zero-parameter tools is 4, and the description appropriately adds no redundant 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 ('List') with a clear resource ('all chart panes in the current layout') and states what is included ('symbols and active state'). It is easily distinguishable from sibling tools like layout_list, pane_set_symbol, or chart_get_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?

The description clearly scopes usage to the current layout, which tells an agent when this pane-specific list is relevant. It does not explicitly mention alternatives like layout_list for listing layouts, but the context is sufficiently clear for choosing this tool over pane-related mutations.

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 behavioral disclosure burden. It only states that the layout changes but does not disclose whether the existing layout is replaced, whether the change affects the active tab or all tabs, whether it is reversible, or what side effects occur on existing panes.

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 concrete examples and 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?

For a one-parameter setter with full schema coverage, the existing description is nearly adequate. However, the tool performs a mutation and has no annotations and no output schema, so the missing behavioral context—what the layout change actually does to existing panes—leaves the description slightly incomplete for confident 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 documents the layout parameter with accepted values and aliases at 100% coverage. The description's examples (single, 2x2, 2h, 3v) are repeated from the schema and add no meaningful semantic detail beyond what the schema provides, 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 clearly identifies the action ('Change') and the resource ('chart grid layout'), and the examples (single, 2x2, 2h, 3v) make the scope concrete. It is distinguishable from workspace-level layout siblings like layout_switch because it explicitly says 'chart grid layout', though it does not name alternatives.

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 is implied: use this tool when you want to change the chart grid layout. However, no explicit guidance is given about when to prefer this over related tools like pane_focus, layout_switch, or layout_new, and there are no exclusions or prerequisites.

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

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

No annotations 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 full behavioral disclosure burden. It transparently explains that the tool does not compile, works offline, and targets specific static-analysis issues. It does not mention whether the analysis is read-only or what kind of output is returned, but the described behavior is clear and non-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 a single, dense sentence with no filler. The core behavior is front-loaded, and the distinctive details ('WITHOUT compiling', 'Works offline') plus specific checks follow naturally without wasting words.

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

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

For a tool with one simple string parameter and no nested objects, the description is sufficient for an agent to select and invoke it. The main gap is the lack of stated return format or behavior for valid code, but the description's phrase 'catches ...' strongly implies diagnostic output, which may be enough for this simple tool.

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

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

The schema already documents the single parameter with high coverage ('Pine Script source code to analyze'). The description reinforces that the source is Pine Script code but adds no additional semantic detail beyond the schema, 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 clearly states a specific action ('Run static analysis on Pine Script code') and lists concrete diagnostic categories (array out-of-bounds, unguarded array.first()/last(), bad loop bounds, implicit bool casts). It distinguishes itself from compiling tools by saying 'WITHOUT compiling', though it does not explicitly differentiate itself from the similarly named sibling pine_check.

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: it is for static analysis, works offline, and does not require a TradingView connection. It implies this is a faster/safer alternative to compiling but does not explicitly state when to use it over alternatives like pine_compile or pine_check.

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 discloses that compilation happens server-side, does not require a chart, and returns errors/warnings. This gives an agent a reasonable mental model of the tool's behavior, though it does not mention rate limits, authentication, or whether any state is modified.

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, each earning its place: what the tool does, what it returns, and when to use it. The most important differentiating detail—'without needing the chart open'—is front-loaded.

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

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

For a tool with a single string parameter and no output schema, the description covers the essential purpose, behavior, and return type. It does not detail the error/warning return structure, but it provides enough context for an agent to select and invoke the tool correctly for validation.

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 fully documents the single 'source' parameter as 'Pine Script source code to compile/validate', and the description adds no additional parameter-level meaning. Since schema description coverage is 100%, 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 compiles Pine Script via TradingView's server API and returns compilation errors/warnings. The phrase 'without needing the chart open' distinguishes it from chart-dependent sibling tools like pine_compile or pine_set_source. This is a specific verb+resource description that an agent can act on immediately.

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 a clear use case: validating code before injecting it into the chart, and notes that no open chart is required. It does not explicitly name alternative sibling tools or state when not to use them, so it falls short of a full when/when-not guideline.

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 behavioral disclosure burden. The word 'Read' indicates a non-destructive operation, and the content types are listed. However, it doesn't disclose whether the tool triggers a compilation, clears the log after reading, or what it returns when the console is empty, leaving some ambiguity.

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 compact sentence that front-loads the action and resource, followed by a useful parenthetical of content examples. Every word earns its place, with no redundancy 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?

For a simple parameterless getter, the description covers the main return content. However, there is no output schema, and the description doesn't clarify how this tool relates to pine_get_errors or whether the console output reflects the most recent compilation. These are small but meaningful gaps given the lack of structured annotations.

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

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

The tool has zero parameters, so the schema is trivially 100% covered. There are no input semantics to explain, and the baseline of 4 for parameterless tools 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 ('Read') and a clear resource ('Pine Script console/log output'), with concrete examples of content types. It is clearly distinguished from a tool like pine_get_errors by covering broader console output, though it doesn't explicitly name any sibling.

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

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

There is no guidance about when to use this tool versus related tools such as pine_get_errors, pine_compile, or pine_get_source. The description implies a general console-reading purpose but provides no explicit exclusions, prerequisites, or alternatives, forcing the agent to infer relationships from names 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, the description carries the full burden of behavioral disclosure. It reveals the data source ('Monaco markers'), which implies reading editor state, but doesn't say whether the operation is read-only, whether a prior compilation is required, or what happens when no markers exist. No side effects or failure modes are disclosed.

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 sentence with no filler; the verb and resource are front-loaded and 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?

For a getter with no parameters and no output schema, the description is minimal but leaves the agent to infer when compilation errors would exist, what the return format is, and how this fits into the pine workflow among roughly two dozen pine siblings. More context is needed for confident 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?

With zero parameters and vacuous 100% schema coverage, there is nothing for the description to document. It adds a bit of meaning by naming the source ('Monaco markers'), which clarifies what the parameterless call operates on.

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-resource pairing ('Get Pine Script compilation errors') and names the data source ('Monaco markers'). It clearly indicates a read operation on editor markers rather than an action like pine_compile or pine_check, though it doesn't explicitly name or contrast any sibling.

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 call this tool versus the many related siblings (pine_compile, pine_check, pine_smart_compile, pine_analyze). There is no mention of prerequisites such as compiling first, no exclusions, and no alternatives named.

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, and it does disclose key behavioral traits: it cannot destroy unsaved work and cannot mis-bind the editor. This reassures safety for a read operation, though it does not detail error behavior or response format.

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

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

The description is compact and front-loaded, with the core action stated first and safety/behavioral context added in a second sentence. No words are wasted, and the contrast with the editor buffer 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 one-parameter read operation, the description is complete: it states what is read, what the tool avoids, and why an agent would use it. The parameter schema covers input details, and the resource itself makes the return value obvious.

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 single 'name' parameter is already well documented with case-insensitivity and ambiguity handling. The tool description adds no extra parameter meaning, 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 states a specific verb and resource: 'Read a saved Pine Script's source.' It also distinguishes itself from editor-buffer operations by explicitly saying it does so 'WITHOUT touching the editor buffer,' which separates it from siblings like pine_get_source and pine_set_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 description gives clear use cases: compare a saved script against a local file or audit what is deployed. It does not explicitly name an alternative tool for reading the editor buffer or an exact when-not-to-use condition, but the editor-buffer contrast implies the boundary.

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 carry the behavioral burden. The verb 'Get' indicates a read-only operation with no side effects, but the description does not disclose what happens if no editor is active, whether unsaved buffer changes are included, or the return format. For a simple getter this is likely sufficient, but it leaves some behavioral edges unstated.

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 contributes to identifying the verb, resource, and location, making it efficiently scannable for an agent.

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

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

Given that the tool has no parameters and no output schema, the description covers the essential call semantics: it returns the current Pine Script source from the editor. It is slightly thin around edge cases and sibling differentiation, but for a zero-input getter this is nearly 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 takes zero parameters, and the input schema is an empty object with 100% coverage by definition. Per the baseline for 0-parameter tools, the description need not explain parameter syntax; it only needs to communicate the purpose, which it does.

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 the specific verb 'Get' and names the exact resource ('current Pine Script source code') plus its location ('from the editor'). This clearly distinguishes it from sibling tools like pine_set_source (which writes) and pine_get_errors/pine_get_console (which retrieve other data). 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 gives no explicit when-to-use guidance or alternatives; usage must be inferred from the tool name and the editor scope. While 'current ... from the editor' implies a use case (retrieve the active script source), it does not contrast with pine_list_scripts or other pine_* siblings. This is adequate context but no exclusions, so it falls at the implied-usage level.

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 and delivers: it discloses the destructive behavior in caps ('THIS REPLACES THE BUFFER') and the non-obvious post-condition that the editor is not guaranteed to be bound to the script. The schema description for confirm_overwrite further reveals the safety refusal mechanism. This is exactly the behavioral context an agent needs to avoid data loss.

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, zero filler. The core purpose leads, the critical destructive warning is front-loaded in caps, and the alternative routing closes. 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 2-parameter tool with no annotations and no output schema, the description covers the critical ground: what it does, the destructive risk, the follow-up caveat, and the safer alternative. The only gap is that it never explicitly states what the tool returns (e.g., whether binding_verified is in the response), leaving that detail to inference.

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 well, including the safety semantics of confirm_overwrite. The main description adds no parameter-specific meaning beyond the schema. Baseline 3 is appropriate when the schema handles 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 uses a specific verb+resource construction: 'Load a saved Pine Script into the editor buffer.' It explicitly differentiates itself from the sibling pine_get_script_source by highlighting the buffer-replacement risk, so an agent can distinguish this from the read-only alternative without opening the schema.

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 names the alternative (pine_get_script_source) and states the exact condition for choosing it ('To READ a script with no buffer risk'). It also provides workflow guidance: check `binding_verified` before any pine_save. The routing decision is fully specified.

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.