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

The description states 'Activate a licence key' which implies a state change (mutation), but the annotations declare readOnlyHint: true, indicating the tool is read-only. This is a direct contradiction. Additionally, the description does not disclose other behavioral traits such as potential failures or network usage.

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

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

The description is three concise sentences that front-load the purpose, then add exceptions and non-effects. Every sentence adds value without redundancy, making it easy for an agent to parse quickly.

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 one parameter and no output schema, the description covers the core functionality. However, it lacks details about success/error behavior, and the annotation contradiction undermines completeness. Given the high schema coverage, it is minimally adequate but has a clear 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 schema provides 100% coverage for the single parameter 'key' with a description. The description adds a concrete example ('TV-PRO-<uuid>') and the context that Free users do not need a key, which clarifies parameter usage and 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 clearly states the verb 'activate' and the resource 'Pro/Team/Owner licence key locally,' distinguishing it from sibling tools like licence_status or edition_limits. It also clarifies that Free users do not need a key, and notes that the tool does not affect the browser or chart, differentiating it from many browser-based sibling tools.

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

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

The description provides clear context: use this tool for paid license activation, and note that Free requires no key. It implicitly suggests not to use this for browser or chart actions by stating 'Does not touch the browser or the chart.' However, it does not explicitly list alternative tools or when-not-to-use scenarios.

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

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

Annotations already indicate read-only, but description adds that it reports first broken sequence and latest entries, providing useful behavioral context beyond annotations.

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

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

Single sentence front-loads the core action with no unnecessary words, earning 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?

Description sufficiently covers the tool's purpose for a read-only verification tool without an output schema, though it could mention whether the report is returned directly.

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

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

Schema has 100% coverage for the single optional parameter 'limit', and the description does not add any additional semantic information 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?

Description clearly states the tool recomputes the hash-chained audit log from genesis, reports the first broken sequence and latest entries, and is read-only. This is specific and distinguishes it from unrelated sibling tools.

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

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

The description implies usage for audit verification but lacks explicit guidance on when to use it versus alternatives or when not to use it.

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

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

Annotations already declare readOnlyHint=true, so the description's claim of listing is consistent. However, it adds no extra behavioral details such as whether tabs from all windows are included or if there are any side effects.

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

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

The description is a single sentence with no unnecessary words, front-loaded with the action and resource.

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

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

Given the lack of parameters and output schema, the description is minimal but adequate for a simple list operation. However, it doesn't specify the format of the output (e.g., tab titles, URLs), which is a minor gap.

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

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

There are no parameters, so the description has no burden to explain them. The schema coverage is 100% and the description is sufficient.

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

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

The description clearly states the verb 'List' and the resource 'all open Chrome tabs', making the tool's purpose immediately obvious. It distinguishes from sibling tools, none of which list 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 provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or context. It simply states the action without any strategic usage hints.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is clear. Description adds specific output (connection status and tab count) but no additional behavioral traits.

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

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

Single sentence that directly states the tool's action. No filler words, front-loaded with verb 'Report'.

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 status tool with no output schema, the description adequately explains what it returns (connection status and tab count). Could specify data types but not critical.

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?

No parameters, so schema coverage is 100%. Description adds meaning by specifying what is reported, which is sufficient for a parameterless tool. Baseline 4 is appropriate.

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

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

Description clearly states the tool reports Chrome connection status and number of open tabs. This distinguishes it from sibling tools like browser_list_tabs, which lists individual 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?

No guidance on when to use this tool versus alternatives like browser_list_tabs or ping. Does not specify context or when not to use.

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 repeats the read-only nature already declared in annotations (readOnlyHint=true) without adding new behavioral context. It does not disclose any traits beyond what annotations provide, such as rate limits or data caching.

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: two short sentences, no redundant words. The key information is front-loaded and 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 zero-parameter query tool, the description is adequate but lacks details about the output structure (e.g., format of 'feature limits'). Given no output schema, agents may need more context to interpret results.

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 schema description coverage is 100%. The description naturally adds no parameter-level information, but the baseline for zero parameters is 4, and the description meets that standard.

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 lists feature limits for each edition (Free/Pro/Team/Owner), using a specific verb and resource. It is easily distinguishable from sibling tools, which are mostly TV or generic utilities.

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 provide explicit guidance on when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. The usage is implied but not elaborated.

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?

Description contradicts annotations: it describes re-enabling tools (a write operation), but annotations set readOnlyHint=true, implying no state change. This is a serious inconsistency.

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 concise sentences with front-loaded action and condition. No unnecessary 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?

Simple tool with no output schema, but the contradiction undermines completeness. The safety condition is good, but missing behavioral details like what state change occurs.

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?

No parameters, so baseline score applies. No additional parameter details needed beyond schema, which is complete.

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

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

The description clearly states it re-enables tools after an emergency stop, which is a specific action distinct from the sibling tool emergency_stop.

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 instructs to use only after user confirms safety, providing clear context for when to invoke 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?

The description claims the tool 'disables all tools,' implying a destructive action, but the annotation 'destructiveHint': false contradicts this. No additional behavioral context (e.g., reversibility, side effects) is provided.

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 no wasted words. It is front-loaded and efficient.

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

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

Given the tool's simplicity (no parameters, no output schema), the description sufficiently conveys its purpose and usage. However, the annotation contradiction reduces completeness.

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

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

The tool has no parameters, and the schema coverage is 100%. The description does not need to add parameter information, so a baseline score of 4 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: 'Immediately disable all tools. Use to halt a runaway action chain.' It uses a specific verb ('disable') and resource ('all tools'), and distinguishes it from siblings like 'emergency_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 specifies when to use: 'to halt a runaway action chain.' While it does not mention when not to use or list alternatives, the context is clear enough.

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

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

Annotations already declare readOnlyHint=true, and the description adds 'Read-only' which confirms it. No additional behavioral traits (e.g., auth needs, side effects) are disclosed, but the description does not contradict annotations and provides expected safety context.

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

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

The description is a single sentence plus 'Read-only', front-loaded with the purpose. Every word adds value; no fluff or redundancy.

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

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

Given no output schema, the description lists key return fields (edition, feature limits, activation status, device id), which is sufficient for a simple query. However, it lacks context on dependencies (e.g., device activation required) or relationship to sibling tools.

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

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

With zero parameters, the input schema is fully covered. The description does not need to add parameter details, meeting the baseline of 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 reports specific license-related fields (edition, feature limits, activation status, device id). It uses a specific verb 'Report' and lists the exact information, distinguishing it from generic status 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?

No guidance on when to use this tool versus sibling tools like edition_limits or activate_licence. The description does not provide context on prerequisites or alternatives, leaving the agent to infer usage.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds 'Read-only', reinforcing the annotation but not providing additional behavioral context like output format or exact effect.

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

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

The description is a single, clear sentence with no unnecessary words. It efficiently conveys the tool's purpose and read-only property.

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 and no output schema. The description adequately explains the purpose, though it could mention the output format (e.g., a string) for completeness.

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

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

The tool has no parameters, and schema description coverage is 100%. The description does not need to add parameter semantics, so the baseline of 4 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 detects and reports which client launched the server, with examples like Claude and ChatGPT. This differentiates it from sibling tools which focus on TV, emergency, or browser actions.

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

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

The description implies use for identifying the host client and marks the tool as read-only. No explicit when-not or alternatives are given, but the tool's unique purpose among siblings makes it clear when to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by specifying the exact return fields (server version, emergency-stop state, host client), which is useful given no output schema.

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

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

One concise sentence of 12 words, front-loaded with 'Health check' to immediately convey purpose. No redundant information.

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

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

Given the tool's simplicity (no parameters, no output schema, annotations covering safety), the description is fully sufficient. It specifies exactly what the tool returns, meeting all contextual needs.

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 schema coverage is 100%. Per rubric, 0 parameters sets a baseline of 4, and no additional param documentation 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 clearly specifies the tool as a health check returning server version, emergency-stop state, and detected MCP host client. It distinguishes itself from sibling status tools (e.g., browser_status, tv_status) by being a generic connectivity 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?

No explicit guidance on when to use this tool versus alternatives. Usage is implied as a basic connectivity/health check, but the description does not mention when-not-to-use or provide explicit 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?

The description details the conditional mutability (drain parameter) beyond the readOnlyHint annotation, which is useful. It doesn't elaborate on the exact effects of draining (e.g., number of rows, blocking), but given the simple nature of the tool and non-destructive hint, this is adequate.

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

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

The description is extremely concise at 20 words in two sentences. The first sentence focuses on the primary action, and the second adds the critical condition. No extraneous information.

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

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

For a tool with one optional parameter and no output schema, the description covers the essential behavior (report and optional drain). It implicitly describes the output scope but could benefit from a brief note on what fields the report includes. Still, it is largely complete for its 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 covers the single parameter 'drain' with 100% description coverage. The description adds value by explaining 'Optionally drain one batch now' and linking it to the overall read-only condition, providing context beyond the schema.

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

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

The description clearly states the tool reports cloud sync configuration and local sync queue depth, with an optional drain action. The verb 'report' and specific resources make the purpose unmistakable and distinct from sibling tools in different domains.

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

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

The description provides explicit guidance on when the tool is read-only versus mutable ('Read-only unless drain=true'), which helps the agent decide usage. While it does not explicitly list alternatives, the context of sibling tools (e.g., licence_status, tv_status) is sufficiently distinct that no further guidance is needed.

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

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

Annotations already declare destructiveHint=true. The description adds 'DESTRUCTIVE: creates a real alert on your account', reinforcing the mutation and explaining the real-world impact. It also notes the dependency on the current symbol, which is not in the annotations. No contradictions with annotations.

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

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

Two sentences, action-first structure, with the destructive warning prominently placed. There is no redundant information; every word contributes to understanding.

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

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

For a mutation tool with destructive annotation and no output schema, the description covers the key aspects: creation, current-symbol dependency, and supported trigger types. It doesn't explain return values, but the tool is simple and the context is sufficient for an agent to decide and invoke 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%, but the description adds meaning by explaining the two alert modes and example condition types ('Crossing Up/Down, Greater/Less Than'). This provides context for the condition enum beyond the raw schema descriptions.

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

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

Description states 'Create an alert on the current symbol' with a specific verb and resource. It clarifies the context (current symbol) and distinguishes from sibling tools like tv_alert_delete and tv_alert_list by specifying the creation action and supported alert types.

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

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

Description gives clear context on when to use: it supports simple message alerts or template-driven condition alerts, implying the two input modes. It does not explicitly name alternative tools or exclusion criteria, but the sibling names (e.g., tv_alert_delete, tv_alert_list) make the distinctions 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?

Annotations already declare destructiveHint=true, and the description reinforces this with 'DESTRUCTIVE'. However, no additional behavioral details are provided (e.g., behavior when index is out of bounds, persistence of the action). The description adds minimal value beyond annotations.

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

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

The description is extremely concise: a single meaningful sentence plus the word 'DESTRUCTIVE'. Every word serves a purpose, and critical information 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 simple delete operation, the description covers the essential purpose and destructive nature. While it doesn't specify return values or error handling, these are less critical for a mutation tool. The absence of an output schema is compensated by the simplicity of the action.

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

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

The input schema already describes the sole parameter 'index' as 'Zero-based index of the alert to delete.' The description repeats this without adding new meaning. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the action ('delete'), the resource ('alert at the given zero-based index'), and the context ('in the alerts panel'). It effectively distinguishes from sibling tools like tv_alert_create and tv_alert_list.

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

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

The description implies the tool is used when you need to delete an alert by its index, but it does not explicitly state when to use it versus alternatives, nor does it mention prerequisites or side effects like the impact on other alerts.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds 'Best-effort', suggesting the tool may not always succeed, which is a behavioral trait beyond annotations. No other behavioral details are given.

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 at two sentences. However, the first part 'Open the alerts panel' may be an implementation detail that adds little value; it could be more direct. Overall, it is brief and front-loaded.

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

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

The description lacks details on what exactly is listed (e.g., alert IDs, messages, timestamps) and the implications of 'best-effort' (e.g., possible failure). With no output schema, the agent has insufficient context about the return value.

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 add parameter semantics. Schema description coverage is 100%, so baseline is 4.

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

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

The description states 'Open the alerts panel and list existing alert messages', which clearly indicates the action (list) and resource (alerts). However, the phrase 'Open the alerts panel' is slightly misleading as the tool name suggests listing only, not opening a panel. It distinguishes from siblings like tv_alert_create and tv_alert_delete.

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

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

No usage guidelines are provided. The description does not mention when to use this tool versus alternatives such as tv_alert_create or tv_alert_delete, nor does it specify prerequisites or context.

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

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

Annotations already mark destructiveHint=true, but the description adds concrete behavioral details: it 'changes the chart, saves/loads the strategy, and opens the Strategy Tester.' This goes beyond the annotation and provides useful side-effect information. No contradiction with annotations.

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

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

The description is concise and well-structured: the first sentence states the primary purpose, and the second warns about destructiveness and Pro+ restriction. Every sentence adds value with no fluff.

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

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

Given the tool's complexity (backtesting with multiple parameter sets), the description covers the core purpose, licensing, and side effects. Although no output schema exists, the tool name and paramSets parameter make the comparison intent clear. It could mention that results are returned after waiting, but the maxWaitMs parameter already implies this behavior. Overall, the description is complete enough for a reasonably informed 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 description coverage is 100%, meaning all parameters (source, symbol, timeframe, paramSets, maxWaitMs) already have descriptions in the input schema. The tool description does not add further meaning to the parameters; it only references 'multiple parameter sets' which matches the paramSets field. Baseline 3 is appropriate.

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

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

The description clearly states the specific action ('Compare') and the resource ('a Pine strategy across multiple parameter sets using the Strategy Tester'). This distinguishes it from sibling tools like tv_read_strategy_tester (which reads results) and tv_pine_save (which saves), as it focuses on comparative backtesting.

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 on when to use this tool: when comparing multiple parameter sets of a Pine strategy via the Strategy Tester. It also notes the 'Pro+ only' license prerequisite and destructive side effects, which helps the agent decide if this tool is appropriate, but it does not explicitly mention alternatives or provide 'when not to use' guidance.

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

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

Annotations already declare destructiveHint=true; the description adds 'modifies the user's chart' which provides context but no new behavioral traits beyond what annotations convey.

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?

Extremely concise: one sentence plus a short warning. Front-loaded with the core action, no wasted words.

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

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

Given low complexity (one required param, no output schema) and annotations covering the destructive behavior, the description is fully adequate. No missing 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 coverage is 100% with a clear description for the 'symbol' parameter. The description adds no additional parameter meaning.

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

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

The description clearly states the verb 'Change' and the resource 'active chart symbol', distinguishing it from sibling tools like tv_change_timeframe that modify timeframes.

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 (e.g., tv_read_chart for reading), and no exclusions or prerequisites 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?

Annotations already include destructiveHint=true. The description adds 'DESTRUCTIVE: modifies the user's chart', which restates the annotation with slight elaboration but no new behavioral details beyond what annotations provide.

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?

Extremely concise with two sentences, no unnecessary words. Front-loaded with the core action, then the destructive 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?

For a simple modification tool with one parameter and annotations covering destructiveness, the description is adequate. It could mention that it affects the currently active chart, but its brevity is acceptable.

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 parameter list is fully documented in the schema. The tool description adds no additional meaning or context 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?

Description clearly states 'Change the active chart timeframe' with a specific verb and resource. Among the many sibling tools, no other tool changes the timeframe, so it is easily distinguished.

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. There is no mention of context, prerequisites, or conditions for usage.

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

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

Annotations already set destructiveHint=true. The description adds context: 'triggers a browser download' and 'Saves the download to ./exports', which goes beyond the annotation by detailing the side effect and target location.

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 with no wasted words. The first sentence states the core action, the second adds critical context (destructive behavior). Front-loaded and efficient.

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

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

Given the simplicity (no params, no output schema), the description covers the key aspects: what it does, where it saves, and its destructive nature. Missing details like file naming or return confirmation, but overall adequate.

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

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

The tool has zero parameters; the schema coverage is 100% (no params). The description implicitly states it uses the current state ('Export the current chart data'), which meets the baseline for no-parameter tools.

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 'export' and the resource 'current chart data to CSV', with a specific destination './exports'. It is distinct from sibling tools like tv_screenshot or tv_read_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?

The description emphasizes the destructive nature ('DESTRUCTIVE: triggers a browser download') but does not provide explicit when-to-use or when-not-to-use guidance compared to alternatives like tv_screenshot for visual output or tv_read_chart for textual 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?

Annotations already declare readOnlyHint=true, so the description's 'Read-only' reaffirms this. The description adds value by detailing the specific metadata returned (symbol, timeframe, etc.), which is beyond what annotations provide. No contradictions.

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

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

The description is a single, well-structured sentence that front-loads the action and resource, then lists output details. Every word earns its place; 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?

Given the tool has no parameters and annotations already cover safety, the description is largely complete. However, the lack of an output schema means the agent might need more detail on the exact format of the returned metadata (e.g., data types). The description partially compensates by listing fields.

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 schema coverage is 100%, so the description's main contribution is explaining what the tool returns. The list of metadata fields (symbol, timeframe, etc.) adds meaning beyond the empty schema, making it helpful for an agent.

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

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

The description explicitly states 'Read visible chart metadata' and enumerates the specific metadata fields (symbol, timeframe, indicators, strategies, overlays, pane count). This provides a clear, specific verb-resource mapping that distinguishes it from sibling tools like tv_read_chart which likely reads price data.

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

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

The description mentions 'Read-only' but offers no explicit guidance on when to use this tool versus alternatives such as tv_read_chart, tv_status, or tv_screenshot. The usage context is implied but lacks exclusions or comparative advice.

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 declares 'Read-only' and 'Best-effort runtime verification', which adds behavioral context beyond the annotations (readOnlyHint=true). The 'best-effort' qualifier is informative, though the description does not detail what happens on failure or success.

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: one sentence plus 'Read-only.' It front-loads the core purpose with no extraneous words.

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

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

The description covers the main purpose but does not explain return type or behavior when verification fails. With no output schema, the agent lacks information about what result to expect, which is a gap for a verification 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?

Schema coverage is 100%, so the baseline is 3. The description mentions 'plots/labels/tables' which aligns with parameter names (expectedPlots, expectedLabels, expectedTables) but does not add 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 specifies a clear action (verify) and resource (indicator and expected plots/labels/tables on a chart). It distinguishes from siblings like tv_ensure_chart (which ensures chart existence) and tv_indicator_add (which adds indicators) by focusing on runtime verification of indicator presence.

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 provide guidance on when to use this tool versus alternatives. No explicit when-to-use or when-not-to-use context is given, leaving the agent to infer from the name and purpose 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?

The description adds value beyond annotations by specifying the exact button type (close/X only) and limiting to 'known' dialogs, implying a limited set. This complements the readOnlyHint and destructiveHint annotations, providing actionable behavioral context.

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

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

The description is a single, well-structured sentence that front-loads the primary action ('Close known TradingView upsell/notice dialogs') and adds clarifying details without unnecessary words.

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

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

For a simple, parameterless tool, the description covers the essential purpose and behavior. However, it could be slightly more complete by defining 'known' dialogs or describing the tool's response when no dialogs are 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?

With zero parameters, the description correctly implies no inputs are needed. The baseline score of 4 applies because there are no parameters to describe.

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

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

The description clearly states the tool's specific action: 'Close known TradingView upsell/notice dialogs' and emphasizes it only clicks close/X buttons, never primary CTAs. This distinguishes it from other tools that might interact with dialogs differently.

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

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

The description provides clear context for when to use this tool (to dismiss unwanted dialogs) and explicitly states what it does not do (never clicks primary CTAs) and that it is non-destructive. However, it does not explicitly describe when not to use it or mention alternative tools, but the uniqueness is implied by the sibling list.

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 annotation already declares destructiveHint=true and idempotentHint=false. The description adds 'Experimental' and 'Best-effort', which are honest behavioral traits about reliability, though it does not elaborate on specific destructive effects.

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

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

The description is only two short sentences and is front-loaded with the action. Every word adds value; there is no fluff.

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

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

The description provides the basic purpose and a caution about reliability, but given the annotations and schema, it is mostly adequate. However, it does not explain the coordinate system or any side effects beyond the annotations, and for an experimental tool more context might be expected.

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 detailed descriptions for each parameter (x1Pct, x2Pct, y1Pct, y2Pct). The description adds no additional parameter information, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's action: 'add a Fibonacci retracement drawing on the chart pane.' It uses a specific verb and resource, distinguishing it from sibling drawing tools like trendline or horizontal line.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention any exclusions or alternatives, and the 'experimental' label is not framed as a usage condition.

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

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

Annotations already mark the tool as destructive. The description adds 'Experimental' and 'Best-effort' as additional behavioral caveats, which provides some value beyond annotations. However, it doesn't detail failure modes, side effects, or what 'best-effort' means in practice.

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 with the action front-loaded, followed by a two-word caveat. Every word serves a purpose, and the 'Experimental' and 'Best-effort' tags are essential context. No wasted 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 low-complexity tool with one optional parameter and annotations, the description is largely sufficient. It states the core action and adds a reliability caveat. It doesn't explain return values or error behavior, but given the simplicity and that no output schema exists, this is acceptable.

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 fully covers the only parameter (yPct) with a clear description of its semantics (fraction of chart pane, default 0.5). The tool description's phrase 'chosen Y-position' mirrors this but adds no new information, so the baseline of 3 applies.

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

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

The description clearly states 'add a horizontal line at a chosen Y-position on the chart pane.' This uses a specific verb (add), identifies the resource (horizontal line on chart pane), and differentiates from sibling drawing tools like trendlines and rectangles.

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

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

The description gives no guidance on when to use this tool versus alternatives. It mentions 'Experimental' and 'Best-effort' but these are reliability warnings, not usage context. There's no mention of when a horizontal line is preferred over other drawing tools, and no 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?

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds 'Experimental' and 'Best-effort', which hint at instability but don't specify side effects (e.g., overwriting existing drawings) or the meaning of 'best-effort'. Since annotations cover the safety profile, some credit is given for the added caveats.

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 with no filler. It front-loads the action and includes the caveats 'Experimental' and 'Best-effort' which earn their place. Zero waste.

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

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

There is no output schema, and the description doesn't mention success/failure behavior, return values, or effects on existing drawings. The experimental label adds caution but doesn't provide enough context for an agent to anticipate outcomes reliably.

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 clear descriptions for all four parameters, so the baseline is 3. The description adds no extra parameter semantics, but it doesn't need to because the schema is self-sufficient.

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') and the target ('rectangle drawing on the chart pane'). This distinguishes it from sibling drawing tools like trendline, horizontal line, and Fibonacci retracement. The 'Experimental' caveat doesn't obscure the core purpose.

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

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

No guidance is provided on when to use this tool versus other drawing tools or alternatives. There are no prerequisites, exclusions, or context hints. The description is purely definitional.

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 labels the tool as 'experimental' and 'best-effort', which indicates instability but does not disclose other behavioral traits like side effects or failure modes. Annotations correctly mark it destructive, but the description adds minimal transparency beyond that.

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—two short phrases—with no superfluous words. It front-loads the key action ('add a vertical trend line') and includes necessary 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?

The description lacks completeness: it describes a UI interaction ('two clicks on the chart pane') which may confuse an AI agent expecting a programmatic API. No return value or prerequisites are mentioned, and the 'best-effort' label adds uncertainty without specifics.

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 schema coverage is 100%, so no parameter details are needed. The description appropriately adds no further 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 clearly states the tool adds a vertical trend line via the left drawing toolbar using two clicks, distinguishing it from all sibling tools that perform different functions.

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

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

No guidance is provided on when to use this tool versus alternatives or when not to use it. The description only states what it does without context.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that it opens the Pine Editor and navigates to a default URL, and specifies non-destructive navigation, providing useful context beyond annotations.

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

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

Two sentences with clear front-loading of purpose, condition, and constraint. Every sentence adds value without redundancy.

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

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

For a simple tool with no parameters or output schema, the description covers the key behavior and constraint. It could mention what constitutes 'usable' or error handling, but overall it's sufficient.

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?

No parameters exist, so schema coverage is 100%. The description does not need to add parameter information; the baseline score of 4 applies as no further detail is required.

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

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

The description clearly states the tool ensures a usable TradingView chart tab is open, with a specific action if none exists. It is distinct from sibling tools that read or modify chart elements, though it does not explicitly differentiate itself from alternatives like tv_status.

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

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

The description implies use when a chart tab is needed, but lacks explicit guidance on when to use this tool versus checking with tv_status or other alternatives. No direct when-not or alternative tool mentions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's 'Read-only' is redundant. It adds useful context about the best-effort widget API with a DOM fallback, indicating possible reliability caveats. However, it does not describe what happens if no chart is active, error behavior, or return format, which would be valuable.

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 only two sentences and front-loads the primary action ('Extract OHLCV bars'). It efficiently conveys the mechanism, fallback, and read-only nature without unnecessary words.

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

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

For a simple read-only tool with one optional parameter, the description provides adequate context. It states what it produces, the mechanism, and the read-only safety. The absence of an output schema is not compensated, but the return concept (OHLCV bars) is straightforward. Given the low complexity, the description 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?

With 100% schema coverage for the single parameter maxBars, the schema fully documents it. The description adds no additional parameter semantics, matching the baseline of 3 for high schema coverage.

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

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

The description clearly states the tool extracts OHLCV bars from the active TradingView chart, with a specific verb and resource. It does not explicitly differentiate from sibling tools like tv_read_chart, but 'OHLCV bars' is a specific output that implies a distinct 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 implies usage when OHLCV data is needed from the currently active chart, but it offers no explicit guidance on when to use this tool over alternatives such as tv_read_chart or tv_read_strategy_tester. The mechanism (widget API with DOM fallback) is mentioned, but not the circumstances that would make it the preferred choice.

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 states 'DESTRUCTIVE: modifies the chart', which aligns with the destructiveHint=true annotation. Since annotations already cover destructiveness, the description adds minimal new behavioral context beyond reinforcement.

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 with two sentences, front-loaded with purpose, and immediately addresses destructive nature. No unnecessary words.

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

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

For a simple one-parameter tool with annotations and no output schema, the description is complete. It covers purpose, parameter, and behavioral impact.

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 one parameter 'name' with a description. Schema coverage is 100%, and the tool description does not add any additional meaning beyond what the schema already provides.

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 'Add' and the resource 'indicator or strategy', and specifies the method 'by name' with examples. It differentiates from sibling tools like tv_indicator_remove or tv_indicator_hide.

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

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

The description implies usage context (adding indicators) but does not explicitly mention when not to use or suggest alternatives. The sibling tool names provide enough context for distinction.

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 states 'DESTRUCTIVE: changes chart visibility', which adds behavioral context beyond the destructiveHint annotation. However, it could be more precise about reversibility or persistence.

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 at one sentence plus a warning, with no unnecessary words. It is front-loaded with the primary action.

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 tool with no output schema and clear annotations, the description adequately covers the purpose and effect. However, it omits potential edge cases like how invalid names are handled.

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 parameter 'nameOrIndex' is fully described in the input schema (100% coverage). The description adds no additional constraints or format details beyond what the schema already provides.

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 'Hide', the resource 'indicator', and the method of identification (legend name or zero-based index). It distinguishes from sibling tools like tv_indicator_show and tv_indicator_remove by focusing on 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 does not provide explicit guidance on when to use this tool versus alternatives like tv_indicator_remove or tv_indicator_show. Context signals show these siblings, but the description lacks comparative usage advice.

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

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

Adds 'DESTRUCTIVE' which aligns with destructiveHint annotation. No additional behavioral details beyond what annotations and schema provide.

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 plus one word, no wasted text, front-loaded with action. Very concise.

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

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

Covers core functionality adequately for a simple tool. Could mention permanence or chart scope, but annotations fill some 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 coverage 100% and description echoes schema ('exact legend name or zero-based index'). Adds minimal extra value like 'exact' but no format or range details.

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

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

Clearly states the action (remove), target (indicator from chart), and identification method (legend name or index). Distinguishes from sibling tools like tv_indicator_hide or tv_indicator_show.

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 identification method but no explicit guidance on when to use this vs alternatives (e.g., hide vs remove). Lacks when-not 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?

Annotations already declare destructiveHint=true. The description repeats 'DESTRUCTIVE' but adds no additional behavioral context such as side effects, required permissions, or irreversibility.

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

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

The description is concise with two sentences, front-loading the purpose. No unnecessary words, but could be structured with key points for clarity.

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

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

No output schema is provided, and the description does not explain return values, partial updates, or batch behavior. Given nested objects and complexity, more completeness is needed.

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

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

Schema description coverage is 100%, so baseline is 3. The description rephrases the schema for both parameters without adding new meaning, e.g., 'map of input label to value' versus schema's 'Map of setting label/placeholder to new 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 clearly states the verb 'Update' and the resource 'indicator's settings', with specific identification methods (legend name or index). It distinguishes from sibling tools like tv_indicator_add, tv_indicator_remove, etc.

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 provide guidance on when to use this tool compared to other indicator-related tools. No explicit when-not-to-use or alternative recommendations.

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 repeats the destructiveHint annotation by saying 'DESTRUCTIVE: changes chart visibility,' but adds no further behavioral context (e.g., what happens if the indicator is already visible, error states, or side effects). With annotations already providing the destructive flag, the description contributes minimally.

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 waste. The first sentence states the purpose, the second flags destructiveness. Perfectly 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 simple one-parameter tool with annotations already covering safety, the description sufficiently explains the action and state change. No output schema exists, but the return value is trivial. Slightly higher score because there is no missing critical 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 input schema covers the parameter nameOrIndex with 100% description coverage. The description adds no additional meaning beyond what the schema already provides (e.g., 'by legend name or zero-based index' vs schema's 'Indicator legend name or zero-based index'). Baseline score of 3 is appropriate.

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

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

The description clearly states the action (show), the resource (previously hidden indicator), and the selection method (legend name or zero-based index). It distinguishes from siblings like tv_indicator_hide and tv_indicator_remove by focusing on reversing a hide 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?

The description implies that this tool is used to show a hidden indicator, but it does not explicitly state when to use it versus alternatives like tv_indicator_hide or tv_indicator_remove. No guidance on prerequisites or when not to use it.

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

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

The description explicitly states 'DESTRUCTIVE: creates a new layout in your account', which adds behavioral context beyond the destructiveHint annotation. It warns about side effects (creating new layout) that may affect account limits or layout clutter.

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 with no filler. The first sentence states the core action, the second adds optionality and destructiveness. Every word earns its place.

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

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

The description covers the action and side effect, but lacks detail on return value (e.g., layout ID), behavior when no active layout exists, and whether the copy becomes active. For a simple tool with one optional param, 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?

Schema coverage is 100%, so the description adds little new information. It restates the optional name parameter as 'Optionally provide a new name', which is slightly clearer but not significantly enriching beyond schema's 'Optional name for the duplicated layout'.

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: 'Duplicate the active chart layout'. The verb 'Duplicate' and resource 'active chart layout' are specific. It also mentions optional naming, which distinguishes it from sibling tools like tv_layout_rename (rename) and tv_layout_save (save).

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 (to create a copy of the active layout) but does not explicitly state when not to use or provide alternatives. The optional naming is mentioned, but no guidance on competing tools is given.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces non-destructive behavior. However, no additional behavioral details (e.g., file overwrite behavior, permissions) are provided beyond annotations.

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

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

The description is a single sentence with no wasted words, conveying all key points 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?

The description covers destination, content, and safety for a simple export tool. It lacks details on automatic filename generation when no name is provided, but overall is adequate for an export operation without an 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 single parameter 'name' is already described in the schema as an optional base filename prefix. The description adds no further meaning, and with 100% schema coverage, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool exports a local snapshot (screenshot + metadata JSON) to a specific directory, distinguishing it from siblings like tv_screenshot or tv_layout_save.

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

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

The description implies usage for exporting snapshots with 'local snapshot' and 'non-destructive', but does not explicitly state when to use or avoid this tool versus alternatives.

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

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

Annotations declare readOnlyHint=true, so the description adds value by disclosing that it opens the UI menu and is a 'best-effort' operation, implying potential unreliability. This extra behavioral context goes beyond the annotations.

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

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

Extremely concise: one complete sentence plus a short clarifying phrase. Every word is necessary and front-loaded. No redundant or extraneous information.

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

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

Given no output schema, the description should ideally explain what the tool returns. It states it lists names, but not the format (e.g., array of strings) or behavior on failure. The complexity is low, but the lack of output details makes it 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?

No parameters exist, so the description cannot add parameter meaning beyond the schema. Schema coverage is effectively 100% since no properties. Per guidelines, 0 parameters is baseline 4.

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

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

Description clearly states the tool opens the layouts menu and lists saved chart layout names. The verb 'list' and resource 'chart layout names' are specific. However, 'Best-effort selector' is ambiguous and could imply selection beyond listing, slightly reducing clarity. It distinguishes from siblings like tv_layout_switch and tv_layout_save.

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. No mention of prerequisites or when not to use. Among many layout-related siblings, there is no explicit comparison or context for selection.

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

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

The description explicitly states 'DESTRUCTIVE: changes the saved layout name', which adds context beyond the destructiveHint annotation. However, it doesn't disclose further behavioral details like reversibility or effects on other resources.

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 waste. Purpose is stated first, followed by a clear warning. Highly efficient.

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 rename tool with a single parameter and well-understood semantics, the description is mostly complete. It lacks clarification on whether the layout must be unsaved or if name rules apply, but the core action 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?

The input schema describes the 'name' parameter as 'New layout name' with 100% coverage. The description does not add additional meaning beyond what the schema provides.

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

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

The description clearly states the specific verb 'Rename' and the resource 'active chart layout'. It is distinct from sibling tools like tv_layout_list or tv_layout_switch.

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

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

No guidance on when to use this tool versus alternatives. Doesn't mention prerequisites like ensuring a layout is active or whether renaming affects other operations.

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?

Description adds 'removes indicators and drawings' beyond the destructiveHint annotation, providing concrete behavioral context. However, it does not mention impact on other settings like timeframes.

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, front-loaded sentences with zero waste. The warning 'DESTRUCTIVE' is prominent.

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, simple reset tool with annotations and no output schema, the description sufficiently covers purpose and primary effect. All necessary context 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?

No parameters present, so baseline 4 applies. Description adds no parameter info because none exist.

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

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

Description explicitly states 'Reset the active chart layout to its default/empty state' with a specific verb and resource, clearly distinguishing from sibling layout tools like tv_layout_list or tv_layout_switch.

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

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

Description implies use when wanting to clear the layout but does not provide explicit when-not-to-use or alternatives. The destructive warning is helpful but not comprehensive.

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

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

The description discloses that the tool is destructive ('overwrites the saved layout') and clarifies the behavior with and without a name. This adds significant context beyond the destructiveHint annotation, which only flags destructiveness without specifics.

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

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

The description is two sentences, front-loaded with the main action, and every word adds value. No redundancy or unnecessary 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?

Given the simple parameter and annotations, the description covers the essential behavioral aspects (destructiveness, name optionality). It could mention the lack of output or confirm success, but overall it's adequate for a tool with 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 covers the 'name' parameter with 100% coverage. The description adds functional semantics: providing a name triggers 'Save layout as...', which is not evident from the schema alone. This helps the agent understand conditional behavior.

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 'Save' and the resource 'current chart layout'. It distinguishes itself from sibling tools like tv_layout_list, tv_layout_switch, etc., by specifying the action of saving. The additional note about 'Save layout as...' with a name further clarifies the tool's purpose.

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

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

The description implicitly indicates use for saving the current layout, but lacks explicit when/not-to-use guidance compared to siblings. It provides a clear context (saving vs. 'Save as'), but no exclusions or alternatives 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?

Annotations already indicate destructiveHint=true; description adds 'DESTRUCTIVE: changes the active layout', specifying precisely what is altered beyond the annotation flag.

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 purpose, immediate warning, no superfluous words.

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

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

Simple tool with one parameter, no output schema, and clear annotations; description fully covers necessary context for selection and 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 coverage is 100% and description repeats the schema's parameter description verbatim, adding no new meaning.

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

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

Description states verb (switch) and resource (saved chart layout) with 'by exact name' qualifier, clearly distinguishing it from sibling tools like tv_layout_list or tv_layout_save.

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 or not use this tool vs alternatives; no mention of prerequisites or context despite having siblings like tv_layout_list that could be referenced.

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 claims idempotency, but the annotation has idempotentHint: false, creating a direct contradiction. This misleads the agent about the tool's behavior. Score 1 per rules for contradiction.

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 concise sentences with zero wasted words. The key information (what it does and idempotency) 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 zero-parameter, no-output tool, the description covers the core action and idempotent behavior. However, the contradiction with annotations slightly undermines completeness, but the description itself is sufficient for the agent to understand usage.

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

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

No parameters exist, and schema coverage is 100%. Baseline for 0 parameters is 4. The description naturally adds no parameter info, which 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 specifies the action (open) and the resource (Pine Editor panel). It distinguishes from sibling tools like tv_pine_create or tv_pine_save, none of which perform this specific open action.

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 states the tool is idempotent and returns alreadyOpen=true if already open, which guides safe repeated usage. However, it does not explicitly exclude any scenarios or mention alternatives, but given the simplicity, this is adequate.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false; the description adds useful context by stating 'deterministic historical bars' and 'No real money, no broker, no live orders.' This goes beyond annotations and confirms a safe, simulated 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?

Three short sentences deliver all essential information with no filler. The opening 'Pro+' and main verb phrase make the purpose immediately clear, and the safety qualifiers are neatly appended.

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 comprehensive schema and read-only annotations, the description is sufficient for selecting the tool. It doesn't describe return values (no output schema), but for a simple simulated backtest the core behavior and constraints are well covered.

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 all seven parameters described. The description adds no extra parameter-level semantics beyond what the schema already 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?

Description uses a specific verb+resource ('Run a SIMULATED strategy backtest over deterministic historical bars') and clearly distinguishes this from real trading and other chart/backtest tools. The explicit 'No real money, no broker, no live orders' reinforces its purpose and scope.

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

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

Clearly frames when to use: simulated backtests only, with no live trading implications. It also notes the Pro+ requirement. However, it doesn't explicitly contrast with sibling tools like tv_backtest_compare, so exclusions are implicit rather than fully 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?

Annotations already set destructiveHint=true and readOnlyHint=false. The description adds value by clarifying the destructive effect: 'changes the active chart.' Also explains the mechanism (click action). No contradictions with annotations.

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

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

Extremely concise: one main sentence plus a one-word warning. Front-loaded with the action and critical destructive note. Every word earns its place; no unnecessary 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?

Despite simplicity, the description omits essential context about the 'scriptName' parameter and any usage constraints. No output schema is provided, but a simple action could benefit from clarifying whether the script must be open or selected. Agent may not know how to invoke this 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 single parameter 'scriptName' is completely undocumented in both the schema (0% coverage) and the description. Agent has no information on how to use this parameter (e.g., its purpose, expected values, or whether it 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?

Clearly states the action: 'Click 'Add to chart' on the current Pine script.' It specifies a verb ('Add to chart') and resource ('current Pine script'), and distinguishes from sibling tools like tv_pine_create or tv_pine_save by describing a specific UI interaction.

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. Does not mention prerequisites (e.g., having a Pine script selected) or scenarios where siblings like tv_pine_save or tv_pine_create would be more appropriate. Agent must infer 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?

Annotations already declare destructiveHint=true, which the description reinforces with 'DESTRUCTIVE: may save and add to chart'. It adds valuable behavioral details: the workflow (static rules first, then optional LLM), the need for API keys (OPENAI_API_KEY/ANTHROPIC_API_KEY), and how to disable destructive behavior for read-only diagnostics. This goes beyond the annotation while not contradicting it.

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 and front-loaded with the primary purpose ('Autonomous Pine Script repair loop'), followed by the workflow, a safety warning, and a usage tip. Every sentence 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 complex tool with six parameters, no output schema, and many sibling tools, the description adequately covers the key behavioral and safety aspects: the workflow, destructive nature, and read-only mode. It could be slightly more explicit about the return status or success/failure indication, but the 'verifies' step implies checking, and the main effects are the save/add-to-chart actions.

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 all parameters are documented in the schema. The description adds meaningful context for autoSave and autoAddToChart by explaining that setting them to false enables read-only diagnostics, which is not present in their schema descriptions. This extra semantic clarifies the purpose of these flags beyond their default values.

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 as an 'Autonomous Pine Script repair loop', specifying the exact workflow: reads source, compiles, applies static rules, optionally calls an LLM, patches errors, saves, adds to chart, and verifies. This distinguishes it from sibling tools like tv_pine_patch, tv_pine_compile_errors, and tv_pine_quick_fix.

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: it is an autonomous repair loop, and it includes a specific usage tip for read-only diagnostics by setting autoSave/autoAddToChart=false. However, it does not explicitly compare with alternative tools (e.g., tv_pine_patch for manual patching), so it stops short of full when-to-use vs when-not 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?

Adds non-destructive nature, which matches destructiveHint=false. Annotations already provide readOnlyHint=true (though backup creates a file, it's debatable). Description provides minimal extra behavior beyond annotations.

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

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

Single sentence, no unnecessary words. Front-loaded with key information: action, source, destination, and non-destructive property.

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

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

Given one optional param, no output schema, and annotations present, description covers core purpose adequately. Could add detail on backup naming or overwrite behavior but sufficient for 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?

Schema coverage is 100%, baseline score 3. Description does not add additional meaning beyond what schema provides for the optional 'label' 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?

Clearly states verb 'Back up', resource 'current Pine editor source', and destination './backups with a timestamp'. Distinguishes from siblings like tv_pine_restore and tv_pine_list_backups.

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

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

No explicit when-to-use or when-not-to-use guidance. Does not mention alternatives or context for use. Only states the action and non-destructive nature.

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

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

Annotations already declare readOnlyHint=true, so description adds value by specifying the order of operations (after save, before add to chart). No contradictions.

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

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

Two concise sentences, front-loaded with purpose, 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 simple read-only tool with no parameters and no output schema, the description provides complete context: what it returns (errors/warnings) and when to call it.

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 100% schema coverage, the description does not need to add parameter details. Baseline 4 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 'Read compile errors/warnings from the Pine editor.' with a specific verb and resource, and it distinguishes from sibling tools that involve creating, saving, or adding to 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?

The description explicitly says 'Call after tv_pine_save or before tv_pine_add_to_chart.' providing clear usage context, though it does not mention when not to use or 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?

The description claims to replace contents (a write operation), but annotations set readOnlyHint=true, which contradicts. This is a serious inconsistency. Beyond that, the description does not disclose requirements like the editor being open or overwriting behavior beyond the parameter.

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 action, no wasted words. Every sentence adds essential information.

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

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

For a simple replace operation, the description covers core behavior and the need to save. It lacks error handling details or prerequisites, but given no output schema, it is reasonably 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 descriptions for all parameters. The tool description adds value by specifying that the source should include '//@version=6' and clarifies the name field as informational, slightly enhancing the schema.

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

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

The description clearly states the verb 'Replace' and the resource 'Pine editor contents with a new v6 indicator source'. It distinguishes from siblings like tv_pine_save and tv_pine_patch by specifying it replaces rather than patches or saves.

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

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

The description explicitly says 'Does NOT save. Call tv_pine_save afterwards', providing clear guidance on when to use this tool and that saving is a separate step. It does not exclude scenarios like patching, but the context is sufficient.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false. The description adds behavioral context: lists from ./backups, orders newest first, and confirms read-only. This enhances transparency beyond the annotations.

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

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

The description is a single 9-word sentence that is perfectly front-loaded with the verb and resource. Every word adds value 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?

Given the tool's simplicity (no parameters, no output schema), the description covers all necessary aspects: action, source path, ordering, and read-only nature. It is complete for effective use.

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

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

The input schema has zero parameters and 100% coverage, so no parameter details are needed. The description is sufficient for a parameterless tool, earning a baseline score of 4.

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

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

The description clearly states the tool lists available Pine source backups from a specific path (./backups) ordered newest first, and explicitly marks it as read-only. This distinguishes it from sibling tools like tv_pine_backup (create) and tv_pine_restore (restore).

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

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

The description implies usage for viewing backups before restore or management, but does not explicitly state when to use this tool versus alternatives or provide exclusions. The context from sibling names offers some implicit 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?

Description states 'overwrite editor buffer', indicating a write operation, but annotations set readOnlyHint=true, creating a direct contradiction. No other behavioral context (e.g., permissions, reversal) is provided.

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, no redundant information. Front-loaded with the action and key constraint. 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?

Despite low complexity (2 params, no output schema), the description fails to mention return values, error cases, prerequisites (e.g., editor must be open), and the annotation contradiction undermines trust. Incomplete for safe operation.

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

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

Schema coverage is 50%: 'source' has a schema description matching the tool description, but 'scriptName' is undocumented in both schema and description. The description adds no new meaning for 'scriptName', leaving the agent uninformed about its role.

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?

Clear verb 'Patch' with explanation 'overwrite editor buffer', identifies resource (Pine editor), distinguishes from siblings like tv_pine_create (create new) and tv_pine_save (save after). Mentions subsequent step, enhancing clarity.

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 explicit instruction to call tv_pine_save afterwards, but does not state when to use this tool vs alternatives (e.g., tv_pine_create) or when not to use it. Context is implied but no 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?

Beyond the annotations (destructiveHint=true), the description adds critical context: it overwrites editor contents, does not auto-save, and returns the patched source only if a static rule applied. It also flags DESTRUCTIVE in caps, reinforcing the safety warning. This is excellent disclosure of side effects and conditional return 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 four short, information-dense sentences. It front-loads the primary purpose, then addresses side effects and return value. Every sentence earns its place with no fluff or repetition.

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

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

For a destructive mutation tool with no output schema, the description covers the main aspects: purpose, overwrite behavior, no saving, and conditional return value. It does not explicitly state what happens when no static rule applies (e.g., returns unchanged source or null), which is a minor gap, but the overall context is strong.

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 'source' parameter is fully documented with a clear description. The tool description does not add new parameter details beyond saying 'current editor source,' which aligns with the schema. Baseline 3 is appropriate because the schema already does the heavy lifting.

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

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

The description clearly states the tool applies deterministic, rule-based Pine Script fixes to the current editor source without calling an LLM. This specific verb+resource combination distinguishes it from LLM-based alternatives and other editor tools, making the purpose unambiguous.

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

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

The description implies when to use this tool: for quick, rule-based fixes without LLM involvement, and when you do not want to save. It explicitly notes the destructive overwrite behavior, which warns against use when saving is required. However, it does not explicitly name alternative tools like tv_pine_autofix or tv_pine_patch, so the guidance is clear but not fully 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?

Goes beyond the annotations by explicitly stating 'DESTRUCTIVE: overwrites editor contents (does not auto-save),' adding crucial behavioral context about what is overwritten and the lack of auto-save.

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 efficiently convey the action, default behavior, and destructive warning. No wasted words.

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

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

For a simple restore tool with no output schema, the description covers the restoration process and destructive nature adequately. Minor omission: no mention of success/failure feedback, but it's not critical.

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 describes backupName as 'Exact backup filename from tv_pine_list_backups.' The description adds value by explaining the default behavior when backupName is omitted.

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 'Restore a backup into the Pine editor' which is a specific verb-resource pair. It distinguishes from sibling tools like tv_pine_backup and tv_pine_list_backups.

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 guidance on omitting backupName to restore the most recent backup and warns about destructiveness. However, does not explicitly state when to use this tool over alternatives like tv_pine_create or tv_pine_patch.

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

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

Annotations already declare destructiveHint=true. Description adds context that it simulates clicking the Save button on screen and persisting the script, which goes beyond annotations. No contradictions.

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

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

Extremely concise with two sentences (including a warning label) that front-load the purpose. No unnecessary words.

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

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

Minimally covers the core action but omits details like failure modes, requirement for compilation success before saving, or whether it overwrites existing script. Given the tool is destructive and has many siblings, more context would be helpful.

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

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

Schema coverage is 100%. The single optional parameter 'scriptName' is described as 'Optional; informational only.' The description does not add further meaning beyond the schema, so baseline 3 is appropriate.

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

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

Clearly states the verb (save) and resource (Pine editor script). Description explicitly mentions persisting the script to the user's TradingView account, distinguishing it from related tools like tv_pine_create or tv_pine_patch.

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?

Implies saving is for persisting changes but lacks explicit guidance on when to use versus alternatives (e.g., tv_pine_compile_errors). No mention of prerequisites like having a valid script or having opened the Pine editor.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint, which the description does not contradict. The description adds value by listing the specific fields returned (symbol, timeframe, diagnostics, host client), giving the agent a clearer picture of the tool's behavior and output without needing to invoke it.

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

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

The description is a single sentence that efficiently states the tool's purpose as an alias and lists its return values. It is front-loaded with the alias information, making the core function immediately clear. 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?

For a read-only tool with no parameters and no output schema, the description adequately covers what the tool returns. It is complete enough for an agent to understand the tool's function. A minor improvement could be noting the output format (e.g., JSON object), but the listed fields suffice.

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

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

The tool has zero parameters, and the input schema coverage is 100%. The baseline for no parameters is 4, and the description does not need to add parameter information. It correctly omits any parameter details, as there are none to document.

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

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

The description clearly states it's an alias for tv_status and lists the returned items (symbol, timeframe, etc.), providing a specific verb and resource. However, it doesn't explicitly distinguish itself from the many sibling tools beyond noting the alias, relying on the user to understand that it's equivalent to tv_status.

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

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

The description implies use when the status information is needed by stating it's an alias for tv_status. It offers no explicit when-to-use or when-not-to-use guidance, nor alternatives beyond the alias mention. An agent might wonder when to choose this tool over tv_status itself or other status-related tools.

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

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

Annotations declare readOnlyHint=true, consistent with 'Read'. Description adds critical behavior: returns null if editor is closed. No contradiction with annotations.

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

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

Two concise sentences: first states action, second states edge case. No unnecessary words.

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

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

Complete for a simple read operation with annotations and well-described parameter. Missing explicit mention of read-only but annotation covers it.

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

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

Schema description coverage is 100% for the single parameter scriptName, which is clearly described as optional and not enforced. The tool description does not add further, but schema covers adequately.

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?

Specific verb 'read' and resource 'Pine Script source' with context 'from open editor'. Clearly distinguishable from sibling tools like tv_pine_create (write) and tv_read_chart (different data).

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

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

Description implies usage when editor is open and agent needs current source. No explicit alternatives mentioned, but the context of siblings and the null return condition provide adequate 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?

The annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds behavioral context beyond annotations by explaining that the tool returns visible:false if the panel is not open. This provides the agent with a key behavioral detail that annotations do not capture. There is no contradiction with annotations.

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

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

The description is extremely concise: one sentence that front-loads the main action and includes a critical conditional detail. Every word earns its place. There is no unnecessary 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 has no output schema, no parameters, and annotations are minimal. The description tells the agent the core behavior but does not describe the structure of the strategy tester summary (e.g., what fields or data it returns). While it covers the visible flag, an agent might need more detail about the return content to use the tool effectively. Given the simplicity, a score of 3 is appropriate.

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 description coverage is 100% (trivially). Per guidelines, baseline for 0 parameters is 4. The description does not need to explain parameters, and it is consistent. No additional parameter information is required.

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

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

The description clearly states the action ('Read the Strategy Tester summary') and the resource. It also includes a condition ('if visible') and the return value when not visible, which distinguishes it from other read tools. The verb 'Read' and resource 'Strategy Tester summary' 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 explicitly says what the tool does and under what condition it returns visible:false. While it does not mention when not to use it or provide alternatives, the usage is clear: use this when you need the strategy tester summary if the panel is open. The context signals show many sibling tools, but this one's purpose is self-contained.

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

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

Annotations already declare destructiveHint: true. The description reinforces this by stating 'DESTRUCTIVE: changes the saved script name,' but adds no further behavioral context beyond confirming the annotation.

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

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

The description is two sentences, front-loads the purpose, and includes a warning. No unnecessary information.

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

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

For a simple tool with one parameter and no output schema, the description covers the core function and destructive nature. It could mention that the script must be open, but that is implied by 'current Pine script.'

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 'name' parameter with constraints. The description does not add additional meaning beyond what the schema provides, so 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 states the specific action (rename), the resource (current Pine script), and the method (via editor title menu). It clearly distinguishes from sibling tools like tv_layout_rename.

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

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

The description implies the tool is used when a Pine script is open and you want to rename it, but it does not provide explicit guidelines on when to use or avoid this tool, nor does it mention alternatives.

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

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

Annotations already declare the operation as read-only and non-destructive. The description adds value by disclosing the two possible return formats (file path or base64) and the PNG format, which are behavioral traits not covered by annotations. It also implies a local file save (via 'local file path'), which is a side effect beyond a simple read, and this is stated transparently.

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 just two sentences, front-loaded with the primary action and target, followed by the return format. Every word contributes meaning with no redundancy or filler. It is concise yet complete.

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 capture tool with optional parameters, no output schema, and good annotations, the description fully covers the essential context: purpose, scope (active tab), and return representations. It does not need to explain return structure in detail since there is no output schema, but it clearly states what the agent will receive. The presence of annotations and full schema coverage reduces the burden, and the description meets that bar.

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 descriptions for all three parameters (name, format, fullPage), including an enum for format. The description adds no additional parameter-level meaning beyond what the schema already states, 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 the action ('Capture a PNG screenshot'), the target resource ('the active TradingView tab'), and the return format ('local file path or an inline base64 markdown image'). This distinguishes it from other TradingView tools like tv_read_chart or tv_get_ohlcv, which extract data rather than visual captures.

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 'of the active TradingView tab' provides clear contextual scope, indicating it should be used when a visual capture of the currently visible chart is needed. It does not explicitly name alternatives or exclusions, but none are necessary given the tool's uniqueness among siblings. The context is sufficient without being directive.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds value by specifying exactly what data is retrieved (symbol, timeframe, login, etc.), which goes beyond the annotations. No contradictions.

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

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

A single sentence that is front-loaded with the action ('Read') and resource, followed by a concise list of returned data. No filler words or redundancy.

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

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

Given no output schema and no parameters, the description provides a good overview of what the tool returns. It covers major areas (chart state, UI elements, diagnostics). However, it lacks details on data types or structure, and could mention if any fields are optional or conditional. Still, it is reasonably complete for a simple status 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 tool has zero parameters, so schema coverage is 100% trivially. The description does not need to add parameter details. The baseline for no parameters is 4, and the description appropriately lists the output fields instead.

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

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

The description clearly states the tool reads the current TradingView chart state and enumerates the specific data points returned (symbol, timeframe, login, etc.). It uses a specific verb ('Read') and resource ('TradingView chart state'), and distinguishes itself from sibling tools by being a general state snapshot rather than a focused read like tv_read_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 explicit guidance on when to use this tool versus its many siblings. There is no mention of prerequisites, alternatives, or conditions under which it should not be used. The description implies it's for getting an overview, but does not differentiate use cases (e.g., when to use tv_status vs tv_read_chart).

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 repeats the destructive annotation but introduces ambiguity by saying 'via the star button' which may not apply in automated contexts. The parameter description says 'informational; adds the active chart symbol' while the tool description says 'current chart symbol', causing slight confusion about the parameter's role.

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 one sentence plus a warning, with no wasted words. Front-loaded with the key action.

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 clear schema and annotations, the description covers the essential purpose and side effect. It lacks details like idempotency or what happens if symbol already exists, but given the simplicity, it is reasonably 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 single parameter is fully described in the input schema (100% coverage), so the description adds no additional meaning. It stays at 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 clearly states the action: add the current chart symbol to the watchlist. It distinguishes from sibling tools like tv_watchlist_read and tv_watchlist_sync.

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 includes a DESTRUCTIVE label, warning that it modifies the watchlist, but does not provide explicit when-to-use or alternative tools. The destructive hint is useful but not comprehensive.

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 annotations already indicate readOnlyHint=true, so the description's 'Read' is consistent. The description adds the condition 'if visible', but does not explain the behavior when the panel is not visible (e.g., returns empty, error, or requires action). No contradiction with annotations.

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

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

The description is a single sentence with no wasted words. It is front-loaded with the action and resource. 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 tool with no parameters, no output schema, and clear annotations, the description is mostly complete. It could benefit from stating the return format or behavior when the panel is not visible, but given the simplicity, it covers the essential purpose.

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 and 100% description coverage, so the schema fully defines all parameters. The description adds no parameter info, but that is acceptable given no parameters exist. Baseline of 4 is appropriate.

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

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

The description clearly states the action ('Read') and resource ('the symbols in the active watchlist panel'). The condition 'if visible' adds a qualifier that could cause uncertainty but still conveys the core function. It distinguishes itself from sibling tools like tv_watchlist_add_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?

The description implies usage when the watchlist panel is visible, but does not provide explicit guidance on when to use this tool versus alternatives (e.g., tv_watchlist_sync) or what to do if the panel is not visible. No exclusions or recommendations are given.

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