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

No annotations are provided, so the description carries the full burden. It discloses important behavioral traits: it uses the latest version, is additive only, never removes or replaces existing studies, and the user can remove the study from the chart UI. This is strong, though it does not mention persistence, error behavior, or whether adding the same script twice creates duplicates.

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

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

The description is compact and front-loaded with the core action and resource. Every sentence adds value: the purpose, the additive-only guarantee, the manual removal path, and the strategy alternative. There is no filler or redundancy.

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

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

For a simple side-effecting tool with no output schema and fully documented parameters, this description covers purpose, scope, side-effect safety, and the primary alternative. An agent has enough context to invoke it correctly and understand the consequences.

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 both parameters have meaningful descriptions: pine_id is 'Script id from list_pine_scripts' and chart_index is a chart index defaulting to the active chart. The tool description adds little parameter-specific detail beyond implying the script must be user-owned and saved.

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

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

The description opens with a specific verb and resource: 'Add one of the user's OWN saved Pine scripts (latest version) to a TradingView chart as a study.' It clearly distinguishes this from siblings by restricting scope to user-owned scripts and emphasizing additive-only behavior, which contrasts with remove_owned_study and run_backtest.

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

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

The description explicitly states when to use the tool: after save_pine_script, to show an improved indicator. It also gives a clear when-not and alternative: 'For strategies prefer run_backtest, which cleans up after itself.' This is direct, actionable routing guidance.

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

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

With no annotations present, the description carries the full disclosure burden and delivers: the fail-closed guardrail, the read-only preview behavior without confirm=true, the precise mutation boundary ('changes only that overlay's inputs'), the post-write verification readback, and the explicit exclusion 'It never places orders or alerts.' This is exemplary behavioral disclosure for a state-changing tool.

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

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

Four sentences, each earning its place: purpose, safety guardrail, mode semantics (split into two tight clauses), and side-effect exclusion. Purpose is front-loaded, and the structure flows logically from what the tool does to how it behaves safely. Zero 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 high complexity (19 params, 12 required, no output schema, no annotations), the description covers the essential behavioral contract thoroughly: modes, guardrails, mutation scope, verification, and side-effects. It gives partial return information ('returns a preview', 'reads them and its drawing totals back for verification'). What remains absent is error-response detail and explicit analysis-payload semantics, but the description is sufficient for safe 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 description coverage is only 32%, so the description must compensate. It does meaningfully for the most behaviorally critical parameter (confirm, going beyond the schema by describing the readback/verification contract) and for expected_symbol/expected_timeframe by placing them in the fail-closed matching logic. However, 13 of 19 parameters (bias, entry_low, entry_high, invalidation, stop, targets, confidence, etc.) receive no description-level meaning beyond their names, leaving the analysis payload semantics partially to inference.

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

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

The description opens with a specific verb pair and resource: 'Preview or apply a structured market analysis to an existing Bushido Analysis Overlay study.' It clearly distinguishes the two operating modes and the specific target (an existing overlay), which separates it from sibling tools like ensure_analysis_overlay (creation) and get_analysis_overlay_status (read-only 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 provides clear invocation context: it applies to an existing overlay, requires symbol/timeframe/contract matching (otherwise fails closed), and explains the preview-vs-commit decision via the confirm flag. It does not explicitly name alternatives or state when not to use it, leaving some routing inference to the agent.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses that the audit is static/source-level and explicitly warns that it is not proof of non-repainting. It also reveals an important pipeline constraint: results remain restricted until restart-difference validation is recorded. This is meaningful behavioral context beyond the bare action.

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

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

The description is two sentences with no fluff. The first sentence states the action, target, and purpose; the second adds the critical limitation and downstream validation dependency. It 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?

The description is complete enough for an agent to understand when to call the tool, what it does, and what constraints apply to its results. There is no output schema, but the description's mention of 'constructs that can repaint' and the restriction on results gives the agent a reasonable mental model of the output. It could go further by describing the shape of the audit findings, but this is not a serious gap.

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

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

Schema description coverage is 100%, and both parameters have useful descriptions: pine_id references list_pine_scripts and version includes a default and regex pattern. The tool description adds no parameter-specific meaning, but it does not need to because the schema already explains both parameters adequately. 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 opens with a specific verb and resource: 'Statically audit one of the user's Pine scripts for constructs that can repaint or make realtime values differ from historical values.' This clearly distinguishes the tool from siblings like get_pine_source or list_pine_scripts, which fetch rather than audit. It also names the exact concern the audit addresses.

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

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

The description makes the intended use clear: check a user's Pine script for repaint or realtime/historical divergence risks. It also sets expectations that this is a source-level screening step, not definitive proof, and that results stay restricted until validation is recorded. It does not explicitly name alternative tools for non-repaint proof, but the distinction between screening and validation is strongly implied.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does this well by specifying that it uses only first-seen, available-at policy rates, counts non-overlapping business-day anchors, and returns 'not_evaluable' rather than fabricating history. This covers data-source integrity, counting methodology, and missing-data behavior, though it does not describe return values on 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 two sentences with no filler. The main purpose is front-loaded, and the second sentence adds high-value behavioral detail about data sourcing and fallback behavior. Every sentence earns its place.

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

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

The tool is complex with nine parameters, nested objects, and no output schema or annotations. The description explains the core preflight intent but is missing crucial context: what a successful evaluation returns, what 'not_evaluable' looks like in practice, how parameters like fixed_regime or minimum_observations affect the check, and how this relates to sibling tools like measure_carry_panel_dependence. The description is too thin for an agent to confidently construct a correct invocation.

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

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

Schema description coverage is 0%, so the description is responsible for explaining parameter semantics. It does not mention any of the nine parameters by name and does not clarify the meaning of pairs, from, to, fixed_regime, price_evidence, minimum_observations, or horizon_business_days. Some domain hints like 'business-day anchors' relate to horizon_business_days, but overall the description does not compensate for the schema's lack of parameter documentation.

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

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

The description clearly states the tool's purpose with a specific verb ('Check whether') and resource ('policy-rate evidence can support a fixed carry panel'). It differentiates itself from sibling preflight tools by focusing on locally first-seen policy rates and the fixed carry panel context, though it does not explicitly name any sibling alternative.

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 'before any return study runs' gives explicit timing for when this tool should be used, establishing it as a preflight gate. It does not provide explicit when-not-to-use guidance or alternative tool names, but the intended usage context is clear and actionable.

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

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

With no annotations provided, the description carries the full behavioral burden and does so thoroughly. It discloses that no recorded overlap means unknown rather than unused or approved OOS, that declared-unused assertions are user-supplied and cannot prove unused status, and that the tool has no side effects.

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

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

The description is three dense sentences, each earning its place: scope, negative-result semantics, and side-effect clarification. There is no filler, no repetition of schema patterns, and the most important distinguishing 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?

The description is strong given the absence of annotations and output schema, covering behavior, parameter semantics, and limitations. However, terms like 'journal' and 'OOS' are unexplained domain jargon, and the description does not specify the result shape beyond implying overlap findings, which matters more 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?

Schema description coverage is 0%, but the description compensates by defining the UTC half-open interval [from,to), the search key series_id across data versions, and the meaning of a declared-unused assertion. The optional prior_usage_declaration parameter is not named explicitly, but its semantics are clearly captured by the explanation that a declared-unused assertion is user supplied and cannot prove unused status.

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

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

The description opens with a specific verb and resource ('Check recorded research data usage for a UTC interval [from,to)') and states the exact search scope: overlapping use of the same stable series_id across all research IDs and data versions. It also distinguishes the tool from the recording sibling by explicitly saying it does not record an access or reserve a period.

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 that this is a read-only lookup and explicitly states what the tool does not do ('Does not record an access or reserve a period'), which implies when not to use it. However, it does not name the alternative tool such as record_research_period_usage or provide an explicit 'use this when...' 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?

With no annotations provided, the description carries the full burden and discloses meaningful behavior: it temporarily borrows an auxiliary chart, restores it after each read, applies a frozen same-UTC-slot baseline contract, and restricts output to observed state. This is substantial transparency about side effects and scope, though it does not explain what the returned classified state rows contain or whether the operation is idempotent.

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

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

The description is compact and front-loaded with the core purpose, followed by key behavioral caveats. Every sentence contributes value, though the phrase 'frozen same-UTC-slot baseline contract' is jargon-heavy and could be clearer.

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, no annotations, eight parameters, and low schema coverage, the description is not complete enough for correct invocation. It covers scope and chart side effects but leaves parameter semantics, output structure, and the meaning of 'classified state rows' undefined, so an agent cannot confidently determine all required inputs and expected result formatting.

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 only 25%, leaving important parameters like target_chart_index, auxiliary_chart_index, count, and minimum_classified_states without meaningful schema descriptions. The tool description adds some context by explaining that the auxiliary chart is used for DXY, US10Y, and XAUUSD, and that the target is EURUSD or USDJPY, but it does not compensate for the majority of undocumented parameters.

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

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

The description clearly states a specific action ('Classify observed EURUSD or USDJPY shocks') with a precise resource scope and method ('after exact-time cross-asset collection'). It also differentiates from siblings by explicitly saying it 'reports observed state only, never a forward outcome, candidate, order-flow claim, or trading instruction', which distinguishes it from related tools like evaluate_cross_asset_shock_outcomes.

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 communicates the intended context: use after exact-time cross-asset collection and for observed-state classification rather than forward-looking evaluation. However, it does not name sibling tools or explicitly state when to use alternatives like preflight_cross_asset_shock or evaluate_cross_asset_shock_outcomes, leaving some routing to inference.

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

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

With no annotations provided, the description carries the full burden. It does disclose a key behavioral trait: 'it does not persist either capture,' which reassures the agent about side effects. However, it does not mention whether the tool is read-only, how epsilon affects the comparison, or what happens if the two captures are structurally mismatched. The disclosure is useful but incomplete.

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

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

The description is two sentences with no redundancy. It opens with the core action and context, then immediately states the return value and a critical side-effect. 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 schema is complex, with nested objects and three parameters, and there is no output schema to describe the return format. The description does not explain what 'closed-bar captures' means, what 'changed plot values' look like, or the role of epsilon. For an agent deciding whether and how to call this tool, significant gaps remain.

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

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

Schema description coverage is 0%, so the description must compensate for the schema's silence. It loosely explains 'before' and 'after' as 'two closed-bar captures' but gives no detail about the required structure (study_id, symbol, resolution, bars). Most importantly, the 'epsilon' parameter is never mentioned, leaving a key input undocumented. The description fails to convey the meaning or usage of one of the three parameters.

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 ('Compare'), the exact resource ('two closed-bar captures of the same indicator'), and the situational context ('after a chart reload/restart'). It also differentiates itself by stating what it returns ('changed plot values') and what it does not do ('does not persist either capture'). This distinguishes it from sibling comparison tools like compare_research_evidence and compare_strategy_experiments.

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 'after a chart reload/restart' provides a clear context for when this tool should be used. However, it does not explicitly mention alternatives or state when not to use it, such as when comparing live values or arbitrary datasets. The absence of explicit exclusions keeps it from a 5.

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

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

With no annotations available, the description carries the full behavioral burden and does so excellently. It explicitly discloses that missing values never match, and that the tool does not read files, authenticate hashes, execute code, persist records, or certify compatibility, calibration, unused OOS, or candidate eligibility. This is unusually transparent and prevents false assumptions about side effects and guarantees.

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 tightly packed sentences with no filler. The main action and resource are front-loaded, what it reports follows immediately, and the non-behaviors are listed compactly. Every sentence earns its place and the structure makes the tool's boundaries easy to scan.

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 output schema and no annotations, the description does a strong job: it covers the input kind, the comparison axes, the report contents, and important caveats. It could add a bit more about the exact output shape or the meaning of 'unknown axes', but what is missing is minor given the schema already defines the input structure.

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

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

Schema description coverage is 0%, so the description must compensate. It names the six compared axes (data, code, runner, candidate rule, parameters, environment) and clarifies that manifests are caller-supplied, but it does not explain how the 'previous' and 'current' objects map to the schema fields beyond enumeration. The 'Missing values never match' statement adds useful semantic, but the parameter semantics are only partially fleshed out.

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

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

The description uses a specific verb ('Compare') and identifies the exact resource ('caller-supplied SHA-256 manifests for previous/current research data, code, runner, candidate rule, parameters and environment'). It also states what the tool reports ('changed and unknown axes plus required revalidation checks'), making it clearly distinguishable from sibling comparison tools like compare_strategy_experiments or compare_indicator_observations.

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

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

The description clearly implies when to use this tool: when comparing previous and current research manifests to identify changes and required revalidation. It does not explicitly name alternatives or exclusion conditions, but the context is strong and the negative boundaries ('Does not read files...') help an agent understand what this tool is not for.

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

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

With no annotations provided, the description carries the behavioral burden. It explicitly states 'Read-only and does not access TradingView', which discloses side-effect profile and external dependencies. It also describes a behavioral constraint: no ranking or combining. It does not mention what happens with invalid references or duplicate entries, but the core transparency is above average.

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

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

Two sentences, front-loaded with the core action and scope, followed by essential constraints. Every clause earns its place: count range, no ranking/combining, required fields, and read-only guarantee. No redundancy or vague 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 read-only comparison tool with one parameter and no output schema, the description covers invocation requirements and behavioral boundaries well. The only notable gaps are the lack of explicit sibling differentiation and no hint about the return format, though 'compare' implies a comparative result. Overall, it is sufficiently complete for a capable 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 0%, so the description must compensate. It does: it explains the references array accepts 2–20 items and each reference must contain both experiment_id and evidence_hash. It omits the exact object shape but the schema itself provides the pattern constraints, so the textual guidance is meaningful and adequate.

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 'Compare' and the resource 'saved experiment-evidence records', and adds a scope of 'two to twenty'. It also notes what the tool does not do ('without ranking or combining incompatible populations'). However, it does not explicitly name or distinguish the closely-related sibling tool 'compare_research_evidence', so it falls just short of full sibling differentiation.

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

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

It gives clear conditions for use: 'exact saved experiment-evidence records' and 'References must include both experiment_id and evidence_hash'. It also provides an exclusion, noting the tool works 'without ranking or combining incompatible populations', implying those operations are not appropriate here. It stops short of explicitly naming alternative tools for those cases.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses a non-obvious behavior (missing bars are never forward-filled) and a scope limitation (closed bars must share exact UTC timestamps). It also frames the output as descriptive, which helps set expectations. It does not mention side effects or return format, but the core computational behavior is transparent.

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

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

Three sentences, each earning its place: purpose, data alignment requirement, and interpretive caveat. The most important constraint is front-loaded immediately after the purpose, and there is no filler or redundant schema repetition.

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

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

Given the tool's complexity (9 parameters, 5 required, no output schema, no annotations), this description is not sufficient for an agent to invoke it correctly. It omits what the output looks like, how thresholds map to regimes, and how the required symbol/timeframe fields should be populated. The description gives a solid high-level orientation but lacks critical operational detail.

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

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

Schema description coverage is 0%, so the description must compensate, but it only references two charts and timestamp alignment. It does not explain count, window, strong_threshold, neutral_threshold, or the expected symbol/timeframe parameters. An agent is left to guess how rolling window and thresholds affect the classification.

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

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

The description uses a specific verb ('Classify') and a precise resource ('rolling return correlation between two explicitly bound layout charts'), making the tool's function immediately clear. It also introduces a defining constraint (exact UTC timestamp matching) that separates it from more generic correlation 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 gives clear contextual guidance: it works on two explicitly bound layout charts and requires exact timestamp alignment. It also gives a when-not-to-use signal by stating the output is descriptive evidence, not a trading signal, though it does not name specific alternative tools or explicit exclusions.

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

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

No annotations are present, so the description carries the full burden. It discloses data scope ('using only the signal bar and prior OHLC'), behavioral non-actions ('without optimizing thresholds, changing the chart, or making a trade recommendation'), and output shape ('bucketed forward-return, upside, downside, and fold distributions'). This is substantial behavioral disclosure that helps the agent predict 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?

Three sentences, front-loaded with the central purpose, then method, then output and exclusions. No redundancy; every sentence adds distinct information and the description is compact for the tool's complexity.

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

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

For a 28-parameter analysis tool with no output schema, the description gives a solid high-level summary of what it computes and returns. However, it omits invocation prerequisites (e.g., data must be loaded on the active chart), does not explain the 'fold' concept or the signal_from/to fixed-window behavior, and does not tie the description to the required parameters. Adequate for tool selection, not for full invocation guidance.

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 only 39%, so the description must compensate, but it does not fully. It does map the six feature enum values and hints at signal-bar/lookback semantics, yet it leaves the majority of the 28 parameters unexplained—including required minimum_effect_bps, signal_from/to, the regime object, configuration_trials, and observation_limit. This is meaningful but insufficient compensation for such a large parameter surface.

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

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

The description states a specific verb ('Measure'), resource ('relationships between selected closed-bar price features and later observed returns'), and tight constraints ('point-in-time', 'one exact TradingView chart'). It enumerates the six feature classes and adds negative scope ('without optimizing thresholds, changing the chart, or making a trade recommendation') that distinguishes it from related falsification and audit 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?

Clear context is provided: use this tool to measure feature-outcome relationships on a single chart in a point-in-time, non-optimizing way. It does not explicitly name alternative sibling tools like run_feature_outcome_falsification_audit or run_feature_outcome_power_audit, so routing among similar research tools remains implicit.

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

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

With no annotations present, the description carries the full burden and does so thoroughly: exact UTC timestamp matching, no forward-filling, v3 causal RMS scaling, per-lag interval/stability output, no best-lag selection, disabled eligibility/journal promotion due to calibration, and descriptive-only status. This goes well beyond the tool name and schema.

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

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

The description is dense but every sentence carries distinct information and the primary purpose is front-loaded. There is no repetition of schema fields or filler; the technical constraints are ordered logically from alignment to scaling to output to calibration implications.

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 15-parameter tool with no output schema and no annotations, the description covers a remarkable amount: alignment behavior, defaults, output characteristics, calibration restrictions, and evidence status. It still lacks explicit guidance on the return payload shape beyond interval/stability and on the semantics of some parameters like confidence_level, so it is 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 only 47% and the description compensates for some parameters (symmetric lag range maps to max_lag_bars, prior-20 RMS scaling maps to return_standardization, exact UTC alignment maps to alignment_mode, per-fold stability maps to folds). However, several parameters such as count, confidence_level, folds structure, and the required expected_* fields receive no semantic explanation in either the schema or the description.

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

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

The description states a specific action ('Scan return correlation') on a specific resource ('two explicitly bound layout charts') with a clear investigative goal (whether reference market leads primary). It also distinguishes itself from audit siblings by emphasizing 'Descriptive evidence only, never a trading signal' and by noting no best lag is selected.

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

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

It gives clear intended-use context: use this to explore lead-lag correlation via symmetric lags, and explicitly warns it is descriptive evidence, not a trading signal. It does not name alternative tools or give explicit when-not-to-use conditions beyond the descriptive-evidence caveat, so it stops short of a 5.

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

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

With no annotations supplied, the description carries the behavioral burden and does well: it discloses that the computation is deterministic, non-directional, has no side-effect of fetching or gap-filling, and does not emit trade recommendations. It does not mention error handling, insufficient observation behavior, or return formatting, but the core side-effect profile is clearly disclosed.

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

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

Two purposeful sentences: the first states what the tool computes and with what inputs; the second states three important exclusions. Every clause earns its place and the key scoping appears immediately.

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

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

The description is complete enough for an agent to select and call the tool: it explains the input provenance, the computation scope, and the main outputs. The lack of an output schema means the description could have added more about return shape, but the listed features plus full parameter schema provide sufficient operational context.

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

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

Schema description coverage is 100%, so every parameter already has a semantic description. The tool description reinforces that observations are aligned closed bars from get_aligned_history and that primary_symbol is the object of the return/volatility/ATR computation, but it adds no new parameter-level meaning beyond the schema, which is the baseline expected at this 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 names a specific operation ('compute'), a precise resource ('deterministic, non-directional features from exact-time-aligned closed OHLCV observations'), and enumerates the concrete outputs (close-to-close return, realized volatility, ATR, return correlations). It also distances the tool from data retrieval by pointing at get_aligned_history, which disambiguates it from the many sibling analysis 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 clearly frames the intended context: use it on observations 'typically returned by get_aligned_history' and not to fetch data, fill gaps, or generate trade recommendations. It stops short of explicitly naming alternative tools for those adjacent tasks, so it misses the top anchor for explicit when-to-use routing, but the context is unambiguous.

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

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

With no annotations provided, the description carries the full burden and delivers richly: it discloses no-lookahead behavior ('uses only that bar and earlier evidence'), determinism ('deterministic', 'Thresholds are explicit', 'no future-fitted quantiles'), and side-effect absence ('no ... chart changes, or trade recommendations'). It also reveals the underlying methodology (efficiency ratio, ATR-normalized directional movement, ATR vs trailing median), which is non-obvious and highly useful.

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 front-loaded sentences: purpose first, then methodology, then boundary disclosures. Each sentence earns its place, though the final sentence's negation list ('no future-fitted quantiles, ranking, chart changes, or trade recommendations') is slightly dense and could be tightened without losing 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 13-parameter tool with no annotations and no output schema, the description covers purpose, methodology, and behavioral guarantees well, but it omits the return contract entirely: observation_limit implies a rows-plus-aggregates result and minimum_classified_bars implies a status concept, yet neither is explained. It also doesn't clarify why expected_symbol/expected_timeframe are 'expected' (presumably validation against the loaded chart), which is a meaningful behavioral gap.

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

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

Schema coverage is 85%, so the baseline is 3, but the description adds genuine conceptual glue: it explains how parameter groups map to the classification logic (efficiency ratio → trend/range thresholds, ATR-normalized movement → directional_move_atr_threshold, ATR vs trailing median → volatility ratios and baseline lookback). This helps an agent reason about parameter interactions beyond the per-field defaults and constraints in the schema.

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

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

The description opens with a specific verb+resource ('Classify deterministic directional and volatility regimes from closed OHLC bars') and enumerates the exact labels produced (trend/range/transition, low/normal/high volatility). It distinguishes itself from siblings like compute_correlation_regimes and compute_market_features by specifying its scope: point-in-time deterministic classification from chart bars only, with no future-fitted quantiles or trade recommendations.

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 clear prerequisites ('bars already loaded on the active chart', 'closed' bars) and implies when the tool is appropriate, but it never explicitly names alternatives or states when-not-to-use in favor of another sibling. The determinism and 'no trade recommendations' disclosures hint at boundaries, but an agent must infer the routing decision rather than having it spelled out.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly: quantity 'is always rounded down,' the tool 'fails closed when conversion evidence or minimum-size capacity is missing,' and it is side-effect-free regarding accounts/orders. These are precisely the behavioral traits an agent cannot infer from the 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?

Three dense sentences with no filler; the core operation is front-loaded, then deterministic behavior and safety exclusions follow. Every sentence contributes distinct 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 16-parameter calculator with no annotations and no output schema, the description covers the operation, key input classes, fail-closed behavior, and side-effect safety. The main gaps are the missing risk-parameter relationship and precise return payload, which are mitigated by the clear 'instrument quantity' phrasing and self-descriptive parameter names.

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 only 6%, so the description must compensate. It adds useful semantic grouping: 'explicit execution cost,' 'quantity constraints,' and 'fresh quote-to-account currency evidence' map to several optional parameters, and 'risk-budgeted' signals the risk inputs. However, it does not explain the risk_amount/risk_percent choice, contract_multiplier, or which constraints are min/max/step, leaving real invocation ambiguity.

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

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

The description names a precise operation: 'Compute a risk-budgeted instrument quantity' from a specific set of inputs. It also disambiguates from execution/order tools by stating it 'does not access an account or place an order.' This is a verb+resource statement that separates it from the many compute_* siblings.

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

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

It gives clear context: pure pre-trade calculation using entry, stop, cost, constraints, and currency evidence, and explicitly excludes account access/order placement. It does not name a specific sibling alternative or provide a when-not condition beyond that behavioral exclusion, so it falls one step short of explicit routing guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the result is an assumption-based estimate rather than broker data, which is a meaningful behavioral trait. It does not disclose defaults for optional parameters like commission_per_unit or slippage_pips_per_side, nor does it explain units or validation 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 two tightly written sentences, with the primary action first and the caveat second. It contains no filler or repetition of schema details, so every sentence earns its place.

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

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

The description is acceptable for a relatively simple calculator but has clear gaps: there is no output schema and the description does not state return format, units, or handling of omitted optional parameters. It also does not connect to sibling tools or typical workflow context, leaving an agent to infer how the result should be consumed.

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

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

Schema description coverage is 0%, so the description must compensate. It links bid/ask to spread, slippage_pips_per_side to slippage, and commission_per_unit to commission, which adds semantic grouping beyond the raw schema. However, it does not explain the required symbol and quantity parameters or how optional parameters behave when 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 opens with a specific verb and resource: 'Compute explicit round-trip spread, slippage, and commission cost for a supported instrument.' It clearly identifies the tool's purpose and distinguishes it from broker execution data, so an agent can understand its role.

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

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

The caveat 'This is an assumption model, not broker execution data' gives useful context for when the result should not be treated as execution evidence. However, it does not explicitly state when to use this tool instead of related siblings such as compute_position_size or get_quotes, so usage guidance remains implied 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states non-actions ('does not change the chart, optimize session definitions, or make a trade recommendation') and discloses a data quality caveat: volume is 'clearly labelled as unverified tick-or-exchange volume.' It also specifies use of closed minute bars and deterministic profiles. It does not mention side effects like API-side computation cost or rate limits, but the main behavioral traits are transparent.

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

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

The description is four sentences, each earning its place: the main purpose, timezone/boundary support, the list of computed outputs, and explicit non-goals. Key qualifiers like 'deterministic,' 'closed minute bars,' and 'one exact TradingView chart' are front-loaded. No filler or repetition is present.

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

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

Given the tool's complexity (7 parameters, no output schema), the description lists the major return components—coverage, OHLC range, return, opening-range extension, high/low timing, VWAP, PDH/PDL/PDC reactions, and volume—which gives an agent a good sense of what to expect. It also clarifies that observation limits apply only to returned sessions while aggregates use all rows. It does not provide a precise output structure, but for invocation purposes 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 description coverage is 71%, so the schema already documents most parameters. The description adds meaning beyond the schema by explaining session semantics: caller-specified IANA timezones, daylight-saving and cross-midnight boundary support. It also maps to outputs like 'opening-range extension' (relating to opening_range_bars) and 'coverage' (relating to minimum_coverage). This extra context enriches parameter understanding without being redundant.

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 begins with a specific verb-resource pair: 'Summarize deterministic session-day profiles from closed minute bars on one exact TradingView chart.' This clearly distinguishes it from sibling tools like get_ohlcv or compute_market_regimes. The scope is explicit via 'one exact TradingView chart' and 'deterministic,' making the tool's purpose unambiguous.

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

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

The description conveys clear usage context: analyzing session-day profiles with caller-specified IANA timezones, daylight-saving, and cross-midnight boundaries. It also states exclusions—'does not change the chart, optimize session definitions, or make a trade recommendation'—which helps agents understand what not to expect. However, it does not name specific sibling tools to use as alternatives for those excluded tasks.

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

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

With no annotations provided, the description carries the full burden, and it does so well. It discloses the read-only default, the confirmation gate, the verifications performed (Pine source, chart binding, analysis_id, current price, existing owned alerts, post-create readback), and exclusions such as no webhooks, email, SMS, broker APIs, or orders. This is rich behavioral context beyond the 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?

Three dense sentences, each earning its place: purpose, verification behavior, and safety boundaries. The key safety information about confirm=true is front-loaded. No filler or repetition.

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

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

The tool has no output schema and no annotations, and the description does not explain what the return value looks like, though it hints at 'post-create readback.' For a 9-parameter mutation tool, the description covers core invocation and safety but leaves return format and exact failure conditions unspecified, making it adequate but not complete.

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

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

Schema description coverage is only 44%, so the description needs to compensate for undocumented required parameters. It adds meaning around confirm=true and mentions analysis_id and Pine source/chart binding verification, but it does not explicitly explain pine_id, expected_symbol, expected_timeframe, chart_index, or output behavior. The schema patterns and 'expected_' prefix provide partial semantics, so the description adds moderate 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 states a specific verb and resource: it previews or creates bounded, one-shot TradingView price alerts for Confirmation, Invalidation, and Target 1 from an audited Bushido Analysis Overlay. It also distinguishes itself from pure listing tools by emphasizing creation and verification, so an agent can tell it apart from list_alerts.

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

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

The description clearly explains the preview-versus-create behavior: 'Without confirm=true it is read-only.' This gives the agent an explicit condition for invoking mutation versus safe preview. It does not name sibling alternatives or explicitly state when not to use the tool, but the context is clear enough for correct selection.

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

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

With no annotations, the description carries the full burden and does so thoroughly. It discloses idempotency, transactional ordering, migration, verification, old-instance removal, fail-closed checks, and preview-only behavior without confirm=true. This is exceptionally transparent for a mutating tool.

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

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

The description is compact, front-loaded with the core purpose, and every sentence adds crucial behavioral detail. There is no filler or unnecessary repetition; it reads as a tight, information-dense spec.

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 transactional tool, the description is highly complete: it explains the idempotent flow, transactionality, fail-closed validation, and preview gating. The main omission is chart_index semantics and any indication of return/result shape, which would improve completeness but are not fatal given the strong behavioral coverage.

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 only 20%, so the description must compensate. It adds meaning for confirm (preview-only), expected_symbol/expected_timeframe (checked), and pine_id (checked), but chart_index is left unexplained. This is a clear gap, though most parameters gain some context from the description.

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

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

The description clearly states a specific operation: idempotently ensure the audited Bushido Analysis Overlay is present once at the latest Pine version. It further explains the exact mechanisms (reuse, add, transactional migrate, verify, remove old), which distinguishes it from sibling tools like add_pine_to_chart or apply_analysis_overlay.

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: when the overlay must be present exactly once and at the latest version. However, it does not explicitly name alternatives or state when not to use it, leaving the agent to infer the distinction from the behavior described.

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

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

With no annotations provided, the description carries the full behavioral burden, and it discloses real methodology: 'resamples whole anchor-date cross-sections in circular moving blocks, preserving same-date pair dependence and serial dependence.' It also states its role boundary as a planning diagnostic rather than an adoption rule or return-study runner. It does not disclose output format or explicitly flag stochasticity (despite the required seed), which keeps it from a 5.

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

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

Three sentences with zero waste: purpose, methodology, then role boundaries. Each sentence earns its place and the purpose is front-loaded. The statistical method disclosure is dense but compact.

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 what, how, and when well, but there is no output schema and no mention of return semantics — for a stochastic estimator the result shape (point estimate, distribution, confidence bound?) matters. It also leaves seed/iterations unexplained and does not state prerequisites or runtime characteristics. Solid on the conceptual side, incomplete on the invocation side.

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

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

Schema description coverage is 0%, so the description must compensate, and it partially does: 'circular moving blocks' hints at block_length_anchors and 'resamples' hints at the stochastic role of seed/iterations. However, no parameter is explicitly mapped or explained — seed, iterations, and observations receive no direct semantic treatment. The methodology language adds some meaning beyond the schema but does not fully cover the 4-parameter space.

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

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

The description names a specific verb and resource: 'Estimate the precision-equivalent sample size of an already fixed carry panel.' The timing qualifier 'before its primary test' and scope 'already fixed carry panel' sharply distinguish it from siblings like run_carry_core_primary_test (which runs the test) and measure_carry_panel_dependence (which measures dependence). No ambiguity about what this tool does.

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

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

The description gives clear when-to-use context ('before its primary test') and explicit when-not-to-use boundaries ('a planning diagnostic only, never an adoption rule or a return-study runner'). It does not name sibling alternatives by name, but the exclusions implicitly route the agent away from adoption and return-study tools. Missing only explicit alternative tool names for a 5.

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

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

Even though no annotations are provided, the description carries the full behavioral burden and does so thoroughly. It discloses the read-only default, the temporary timeframe change with restoration, explicit reporting of restoration failures, and the non-guessing policy for same-bar ordering, gaps, and incomplete history. This is genuinely informative beyond any structured 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 dense but front-loaded: the core purpose appears first, followed by scoping constraints, edge-case handling, and side-effect behavior. Every sentence contributes a distinct constraint or behavioral guarantee, with no filler or redundant restatement of the tool name.

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 many edge cases and side effects, which is valuable for a tool with no output schema. However, it never states what the evaluation actually returns—e.g., an outcome label, a confidence level, or a structured result object. It says results are 'reported as ambiguous or incomplete' and that restoration failures are 'returned explicitly,' but the return contract remains underspecified.

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 57%, so the description does not need to compensate entirely, but it adds real value for evaluation_timeframe by explaining that it temporarily changes only the selected chart, captures evidence, and restores afterward. It also ties expected_timeframe to verification semantics. A few parameters like chart_index remain unelaborated, but their meaning is reasonably inferable from context.

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

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

The description uses a specific verb ('Evaluate') and names a precise resource: 'the first confirmed Target-versus-Stop outcome of an audited Bushido Analysis Overlay.' It clearly delimits the scope with constraints like 'only loaded, closed OHLCV bars after the analysis time' and distinguishes itself from batch or status tools like evaluate_due_analyses by focusing on a single overlay's first confirmed outcome.

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

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

The description provides clear context on when this tool applies: after an analysis, with loaded closed bars, and excluding forming bars. It gives an explicit exclusion for calendar-month charts. It does not name alternative sibling tools, so the routing is implied rather than stated, but the prerequisites and non-evaluable cases are concrete.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It clearly states that the tool uses exact-time common bars, excludes overlapping state windows, and never produces a candidate or trade instruction, which meaningfully signals its non-execution and non-trade nature. It does not mention possible side effects or output format, but the core behavioral constraints are disclosed.

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

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

The description is two sentences and every clause earns its place: the outcome horizons, the bar-alignment constraint, the overlap exclusion, and the no-trade caveat. Information is front-loaded and there is no filler or repetition of schema details.

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

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

The description explains the high-level behavior but leaves the 8-parameter input surface completely undocumented and provides no return-value or output-shape information. For a research tool of this complexity, especially with no output schema and no annotations, an agent would not have enough context to invoke it correctly without external knowledge.

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

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

Schema description coverage is 0%, and the description does not explain any of the 8 parameters, including the 4 required ones: target_chart_index, auxiliary_chart_index, expected_target_symbol, and expected_timeframe. The tool name and description imply cross-asset context, but an agent cannot determine parameter meaning or valid combinations from this description.

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

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

The description states a specific action, 'measure', and a specific resource, 'descriptive 15/30/60/120-minute outcomes for frozen observed cross-asset shock states.' It also differentiates itself from trading/execution tools by saying it 'never produces a candidate or trade instruction,' though it does not explicitly name an alternative sibling.

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

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

The description implies use when frozen cross-asset shock states have been identified and descriptive outcome measurement is needed. It provides no explicit when-to-use or when-not-to-use guidance and does not reference alternative tools such as classify_cross_asset_shocks or preflight_cross_asset_shock, leaving some routing to inference.

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

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

With no annotations provided, the description carries the full behavioral burden and does so excellently. It discloses side effects (temporary chart changes, recording results, restoration), the conditional nature of those effects, and failure semantics: 'Individual failures do not stop the batch; a chart restoration failure stops all remaining work.' This is transparent and actionable.

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

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

Three sentences, each earning its place: purpose, execution flow, and failure handling. It is front-loaded with the core action and avoids redundant restatement of schema details. No filler or unnecessary elaboration.

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

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

Given 7 parameters, no annotations, and no output schema, the description covers the essential behavior, side effects, and failure modes. It states what preview returns (candidates and estimated chart changes) and what execution does (records results and restores charts). It does not describe the return format after execution or prerequisites like having a chart selected, but the schema covers parameter details, making this 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 description coverage is high at 86%, so the baseline is already 3. The description adds real semantic value beyond the schema by explaining that confirm=true is what triggers chart mutation and result recording, tying the parameter to observable behavior. It does not cover all parameters, but the schema already documents most of them.

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

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

The description opens with a specific verb and resource: 'Preview or evaluate due analyses directly from the local analysis journal.' It clearly distinguishes two modes—preview without confirm and execution with confirm—so an agent understands exactly what the tool does and can tell it apart from analysis-retrieval and study-runner siblings.

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

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

The description gives explicit context for when to use each mode: 'Without confirm=true it only lists candidates and estimated chart changes' vs. 'With confirmation it temporarily changes...'. It does not name alternative sibling tools or explicitly state when not to use it, but the preview/confirm distinction serves as clear usage guidance.

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

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

With no annotations provided, the description fully carries the behavioral burden. It explicitly states the tool 'never changes charts and never forward-fills' and describes how edge cases are handled: 'forming bars, different resolutions, missing bars, and retrieval failures are reported as quality conditions.' This is unusually transparent.

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

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

Three sentences with no filler: purpose is first, behavioral caveats second, and usage prerequisite last. Every sentence contributes distinct, needed information.

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

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

The description covers purpose, side effects, quality reporting, and usage prerequisites, which is strong given the parameter schema. The only notable gap is that there is no output schema and the description does not describe the shape of the returned aligned data, so an agent still has some uncertainty about the exact response.

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

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

Schema description coverage is 100%, so the input schema already documents count, chart_indexes, and max_missing_ratio. The description adds context about prerequisites and quality conditions but does not meaningfully extend parameter-level semantics beyond the schema, matching 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 names a specific verb ('Align'), resource ('closed OHLCV bars already loaded in two or more TradingView layout charts'), and a precise criterion ('exact UTC timestamps'). This clearly differentiates the tool from data-loading siblings like get_ohlcv and load_more_history.

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

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

The description gives a clear prerequisite: 'Use a layout where each required market is already open.' It also implies data must already be loaded and that forward-filling will not happen, which shapes when this tool is appropriate. It does not explicitly name alternatives or list when-not-to-use cases, so it stops short of a 5.

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

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

With no annotations provided, the description carries the full burden, and it does disclose a meaningful non-obvious behavior: only target_before_stop is positive, stop_before_target is negative, and ambiguous/incomplete/cancelled/neutral/unevaluated entries are exclusions. It does not cover side effects, permissions, or output format, but the most important behavioral rule is stated clearly.

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

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

Two sentences with no filler. The action and scope are front-loaded, and the essential labeling/exclusion policy immediately follows. Every sentence earns its place.

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

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

The tool has 3 optional parameters, no output schema, and no annotations, so the description alone must enable correct invocation and interpretation. It explains labeling and exclusions but omits parameter meanings, the shape of the calibration result, and when to choose this over performance/audit siblings.

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

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

Schema description coverage is 0%, and the description never mentions bias, bins, or symbol. The schema only provides types, an enum, and a pattern; the agent must guess what 'bias' filters, how 'bins' affects calibration, and what 'symbol' selects.

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

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

The description opens with a specific verb ('Calculate') and a specific resource ('confidence calibration from the local analysis journal'), and it adds the positive/negative labeling and exclusion policy. However, it does not explicitly differentiate from siblings like get_analysis_performance or the audit/study tools, so the distinction must be inferred.

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

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

The intended use is implied: use this when you need confidence calibration from the local analysis journal. But there is no explicit when-not-to-use guidance, no prerequisite mention, and no comparison against the many research/audit sibling tools.

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

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

With no annotations, the description carries the full burden, and it delivers strong behavioral context: results are locally journaled, evaluations are 'monotonic latest,' and 'a completed evaluation is never displaced by a later stale ongoing read.' It also clarifies that the tool does not access or change the TradingView chart, which is valuable for an agent deciding whether to call 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 compact and well-structured: the primary purpose is stated first, followed by a key monotonicity guarantee and a useful exclusion. Every sentence adds meaningful information, and there is no redundant filler.

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

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

The description gives a strong behavioral and purpose overview, which is good given there is no output schema and no annotations. However, it omits any guidance on the three optional parameters, which are the only way to scope the read. The agent can probably call the tool without parameters, but cannot confidently know how to use filters correctly.

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

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

Schema description coverage is 0%, and the description adds no explanation of the three parameters: limit, symbol, and analysis_id. While the parameter names are somewhat self-explanatory, the description does not say how they filter the journaled analyses or what the limit applies to, so the agent has to infer this from the schema alone.

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

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

The description uses a specific verb and resource: 'Read locally journaled analysis definitions and their monotonic latest evaluations.' It also differentiates itself from chart-related siblings by explicitly stating 'This tool does not access or change the TradingView chart.' This is sufficiently specific and clearly distinguishes the tool from nearby alternatives.

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

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

The description establishes a clear context: this is for reading local journaled analysis evaluations, not for chart interaction. It explicitly states what the tool does not do, which provides a when-not signal. However, it does not name specific alternative tools such as get_analysis_performance or get_analysis_calibration, so the routing guidance is implicit rather than explicit.

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

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

With no annotations provided, the description carries the full behavioral burden, and it does so well. It explicitly states the operation is read-only ('without changing the chart'), explains internal validation behavior (resolving by USER pine_id, verifying Pine version source and input contract), and enumerates what the response contains: analysis metadata, expiry, current-price relations, risk/reward references, and drawing integrity. It also discloses the limitation about level states vs. historical touch order.

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

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

The description is efficiently sized at three sentences and front-loads the most important fact ('Read... without changing the chart'). Some phrasing is dense and jargon-heavy, such as 'context-bound input contract,' but every sentence contributes substantive information and there is no filler.

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

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

Given no output schema and no annotations, the description provides a solid inventory of returned content and read-only behavior. It could be more complete by addressing the optional chart_index parameter and potential validation failure modes, but for a status-read tool the core selection and invocation context is 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 description coverage is only 25%, so the description should compensate. It does add meaning by mentioning that the study is resolved by USER pine_id and that expected_symbol and expected_timeframe form a 'context-bound input contract,' which helps clarify their role as validation constraints. However, it does not explain chart_index at all, and the individual parameter semantics remain mostly implicit.

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

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

The description opens with a specific verb and resource: 'Read the current Bushido Analysis Overlay state without changing the chart.' This clearly identifies the tool as a read-only status inspection and distinguishes it from mutation-focused siblings like apply_analysis_overlay and ensure_analysis_overlay. It also names the key entity (Bushido Analysis Overlay) and the kind of data returned.

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

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

The description gives a clear usage context: it is for reading current overlay state without mutation, and it explicitly warns that level states do not reflect historical touch order, directing the agent to 'a future outcome tool' instead. This is a useful exclusion, though no sibling tool is named by name, so routing is slightly less explicit than it could be.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states 'Read-only,' which is the most important behavioral trait for this zero-parameter getter. It also clarifies that the returned source is meant for a one-time setup, adding useful lifecycle context beyond a bare 'get template' statement.

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 convey the resource, its content, its read-only nature, and the entire setup workflow without wasted words. The key identifying information is front-loaded, and the follow-up tool references earn their place by preventing misuse.

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 template getter with no output schema, the description is complete: it explains what the tool returns, that it is read-only, and how the returned value should be used across the intended Pine overlay lifecycle. Nothing essential is missing for an agent to invoke it correctly.

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

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

The input schema has no parameters and schema description coverage is 100%, so there are no parameter semantics to document. The baseline for a zero-parameter tool is 4, and the description appropriately focuses on the return value and downstream usage rather than parameters.

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

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

The description states a specific verb ('Get'), a specific resource ('audited generic Pine overlay'), and the overlay's purpose: rendering a structured market analysis with entry zone, confirmation, invalidation, stop, targets, confidence, and expiry. It clearly distinguishes this tool as the template-getter in the Pine overlay workflow, separate from save_pine_script, add_pine_to_chart, and apply_analysis_overlay.

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 outlines the intended workflow: pass the returned source to save_pine_script, add_pine_to_chart once, and use apply_analysis_overlay for subsequent analyses. This gives the agent clear when-to-use and when-not-to-use guidance, including the correct alternative for updating existing studies.

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

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

With no annotations, the description carries the behavioral burden and does well: it declares read-only status, explains how missing/non-binary/cost data are handled (excluded with counts, not zero-filled), and clarifies the population boundary. It omits details like rate limits or response format, but the key behavioral traits are disclosed.

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

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

Three focused sentences with the core purpose front-loaded and exclusions stated efficiently. Every sentence adds meaningful information and there is no redundant filler.

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

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

For a read-only aggregation tool with six optional filters and no output schema, the description gives a solid picture of scope, exclusions, and data handling. Some gaps remain around return shape and how grouping affects output, but overall it is substantially complete for selection and basic invocation.

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

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

Schema description coverage is only 17%, and the description does not compensate by explaining the meaning or usage of most parameters. It only indirectly relates to cost_assumptions; bias, symbol, group_by, timeframe, and strategy_version remain dependent on schema enums/names for understanding.

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

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

The description names a specific verb ('Aggregate'), a clear resource ('live analysis-journal outcomes'), and the exact metrics produced (win rate, gross/net R, MFE/MAE, timing). It also differentiates itself from backtest-related tools by explicitly stating it never mixes Strategy Tester backtests.

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 for live analysis-journal performance aggregation, and it explicitly excludes backtest data. However, it does not name specific sibling alternatives or state direct when-to-use versus other performance and journal tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the internal logic: combining first-seen policy rates with complete collection heartbeats, rounding evidence start onto the frozen anchor grid, and reporting heartbeat-gap status. This gives a solid picture beyond just saying 'read readiness', though it stops short of specifying side-effect-free guarantees or output details.

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

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

The description is compact and front-loaded with the core action and resource. The second sentence is dense and packs multiple behavioral details into one long clause, but every clause adds value and there is no redundancy or filler.

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

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

The description gives a strong overview of the algorithm, but with no output schema it does not describe what the readiness result contains or how heartbeat-gap status is represented. More importantly, the optional as_of parameter is left completely unexplained, so an agent invoking the tool cannot confidently decide whether or how to set it. These are meaningful gaps for a tool whose only configurable input is undocumented.

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 defines one optional parameter as_of with only a timestamp pattern and no description, and the description never mentions as_of or how it influences the result. The parameter name hints at a date, but the description does not explain whether it sets the evaluation time, affects the anchor-grid rounding, or is safe to omit. This is a clear semantic gap.

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

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

The description states a specific verb ('Read') targeting a named resource ('frozen carry_core_primary_v1 collection readiness') and explicitly distinguishes itself from chart-manipulating workflows by saying 'without switching a chart'. This is precise and clearly differentiates from siblings like get_oanda_flow_collection_readiness or chart-related tools.

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

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

The phrase 'without switching a chart' provides clear context for when this tool is appropriate. However, it does not explicitly mention when not to use it or point to a specific alternative for other readiness or collection checks, so it lacks exclusions.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It explains what the tool returns, including the format for indicators and the fact that the id is consumable by get_indicator_* tools. It implies a read-only state inspection without side effects, which is clear enough for this tool type.

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

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

Two sentences with no filler. The first sentence front-loads the core purpose and output contents; the second adds practical guidance. Every word contributes value.

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

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

For a zero-parameter, no-output-schema tool, the description fully covers what an agent needs: what the tool returns, the shape of indicator entries, and when to invoke it. No critical information is missing.

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

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

The tool has zero parameters and 100% schema description coverage, so no parameter explanation is needed. The description correctly focuses on output meaning rather than parameter details. Baseline 4 applies.

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

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

The description states a specific verb ('Get'), a specific resource ('current TradingView layout state'), and enumerates exactly what is included: symbol, timeframe, active indicators as {id, name}, and active chart. This makes the tool's purpose immediately clear and distinguishable from sibling tools like get_chart_screenshot or get_ohlcv.

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 this first to know what the user is looking at,' providing a clear usage cue. It does not explicitly name alternative tools or exclusion conditions, but for a state-introspection tool this is sufficient context.

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

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

With no annotations, the description carries the full safety-and-behavior burden. It discloses what gets captured (whole window including watchlist, or one chart at full resolution) but stays silent on important traits: it targets the 'TradingView desktop app', implying the app must be running/visible, yet that precondition is unstated; it also doesn't say whether the capture has side effects or how the image is returned.

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 and roughly 40 words carry action, purpose, default behavior, and the parameter exception. It is front-loaded with the core action and every clause earns its place; no filler or unnecessary schema 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 simple two-optional-parameter tool, parameter knowledge is complete via the schema. But with no output schema and no annotations, the description omits what the caller receives (image binary, base64, or URL) and any preconditions on the desktop app being open — both matters an agent needs to handle the result and failure modes correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds genuine value beyond the schema: it frames chart_index as for 'a multi-chart layout' and promises 'full resolution' capture, which the schema description does not state. The format parameter's trade-off (jpeg smaller vs png sharper) is already fully covered in the schema.

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

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

States the specific action ('Capture a screenshot of the TradingView desktop app') with a clear purpose ('for visual analysis'). The scope detail (whole window vs single chart) further disambiguates it from siblings like get_chart_context, get_mtf_overview, and get_execution_snapshot, which return data rather than images.

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

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

The description implies when to use it (whenever a visual capture is needed) and offers clear parameter-level guidance (use chart_index for a single chart of a multi-chart layout; the index comes from get_chart_context). However, it never names alternatives or states when-not-to-use, leaving tool-selection distinctions to inference from 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?

Even without annotations, the description fully covers behavioral side effects: it states the observation is appended to local first-seen history and explicitly says the call never changes a chart, Pine script, alert, or order. This goes well beyond a basic function summary and tells the agent exactly what persistent effects to expect.

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

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

Three sentences, each earning its place: the first states the primary purpose, the second clarifies scope and history behavior, and the third draws the safety boundary. There is no redundant or promotional language.

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

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

For a zero-parameter, no-output-schema tool, the description covers source, scope, persistence behavior, and non-effects. It does not explicitly describe the return shape, but the simple aggregate value is strongly implied; this is a minor gap only.

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 description coverage, there are no parameter semantics for the description to clarify. The baseline of 4 applies, and the description still adds context about the specific data source and scope.

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

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

The description names a specific verb and resource: 'Get CME's Daily Bulletin aggregate open interest for COMEX Gold futures (TOTAL GC FUT).' It clearly identifies the data as exchange-wide and independent from TradingView chart indicators, so an agent knows what this tool is for. It does not explicitly compare against sibling tools such as reconcile_gold_open_interest, so it stops short of full sibling differentiation.

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 'exchange-wide ... total, independent from TradingView chart indicators' gives useful context for when this tool is appropriate, and the note about appending to first-seen history implies later analytical use. However, it does not explicitly state when to use this tool instead of an alternative, nor does it mention exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently describes what the tool computes and, importantly, what it does not observe or claim. This gives an agent a clear mental model of the tool's limitations and output nature, though it stops short of describing the exact return format.

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

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

The description is two sentences with no filler. The main purpose is front-loaded, and the second sentence provides necessary caveats and methodological detail without redundancy.

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

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

Given no annotations and no output schema, the description provides useful context about methodology and limitations, but it omits practical invocation details and parameter meanings. It is adequate for an expert who already knows the domain, but less complete for an agent that must decide when to call it versus sibling tools.

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

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

Schema description coverage is 0%, so the description needs to compensate, but it only indirectly addresses expected_timeframe and expected_symbol by mentioning 'daily FX chart'. It does not explain count or chart_index, leaving two of four parameters underspecified from a semantic standpoint.

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

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

The description uses a specific verb ('Describe') and names a clear resource: an exploratory COT crowded-position unwind proxy on a bound daily FX chart. It adds the proxy's composition (positioning percentiles combined with a 20-day price break), which clarifies the tool's focus. It does not explicitly differentiate from siblings like get_cot_crowding_unwind_overlay_template, but the core purpose is 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 signals when this is appropriate by labeling it 'exploratory' and explicitly stating it never claims to observe orders, stops, institutions, or execution flow, which warns against using it as an actual flow or order tool. However, it does not name alternatives or give explicit when-to-use / when-not-to-use conditions relative to sibling tools such as get_futures_flow_context or get_positioning_context.

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

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

With no annotations, the description carries the full behavioral burden. It explicitly discloses that the overlay does not fetch or infer CFTC data, orders, stops, or execution flow, and that COT values are supplied externally. This is meaningful transparency beyond basic purpose.

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 tightly written sentences with no filler. The main action and resource are front-loaded, followed by a precise behavioral clarification. Every phrase adds value.

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

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

For a zero-parameter, no-output-schema template tool, this description is nearly complete: it names the artifact, its inputs, and what it excludes. The only minor gap is not explicitly stating the return format, but the name and description strongly imply a Pine Script overlay.

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% schema description coverage, so there is nothing for the description to document. The description adds useful context by clarifying that COT values are explicit inputs to the overlay rather than tool parameters the caller must pass to this MCP call.

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

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

The description states a specific verb ('Get') and a specific resource ('audited Pine overlay'), and clearly defines what the overlay renders: a supplied COT crowding context plus the chart's prior daily structure range. This differentiates it from siblings like get_cot_crowding_unwind_context, which fetches context, and get_analysis_overlay_template, which is generic.

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

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

The description makes the usage context clear: use this when you have a COT crowding context to supply and need the corresponding Pine overlay. It does not explicitly name alternatives or state when not to use it, but the boundary between this tool and data-fetching tools is implied well.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It explicitly says 'Read-only,' which is important, and adds that the template reads confirmed DXY daily data with lookahead_off. This is meaningful behavioral context for an agent.

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, information-dense sentence with no filler. It front-loads the action ('Return'), names the resource, and includes the key behavioral qualifiers without wasting words.

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

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

For a parameterless read-only template getter, the description fully covers what the tool does, what the template contains, and its read-only nature. No output schema is present, but the description usefully identifies the exposed plots, so an agent knows what to expect.

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

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

The tool has zero parameters and the schema coverage is 100%, so there is no parameter documentation burden. The description adds no parameter details, but none are 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 states the tool returns a fixed Pine Study template specifically for DXY context gate, naming the exact outputs (dxy_return_20 and dxy_gate plots). This distinguishes it from sibling template tools like get_volume_profile_context_template and get_price_action_context_template.

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 an agent needs the DXY context gate Pine template and notes it is read-only. However, it does not explicitly state when to prefer this tool over alternative template getters or mention any exclusions.

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

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

No annotations are provided, so the description carries the transparency burden. It discloses defaults (next 7 days, medium+ importance, US/EU/JP/GB) and the data source, but does not mention rate limits, pagination behavior, update frequency, or whether values may be missing.

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

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

The description is compact and front-loaded, stating the resource, the returned data, the use case, and key defaults in just a few sentences. 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 read-only getter with fully documented optional parameters, the description and schema together cover purpose, defaults, use case, and returned fields. Slightly more behavioral context (e.g., output structure or limitations) would make it fully complete.

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

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

Schema description coverage is 100%, so the schema already documents every parameter and its default value. The description repeats some defaults but adds no new parameter-level 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 names a specific verb ('Get') and resource ('economic calendar events') and enumerates concrete event types and returned fields. It is clearly distinguishable from the sibling tools, none of which target economic calendar 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 explicitly states when to use the tool: 'Use this to check whether upcoming news could invalidate a technical setup.' It does not mention exclusions or name alternative tools, but the intended context is clear.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It reveals that the underlying records are 'append-only,' implying immutability, and explicitly states the tool 'never accesses a chart,' which is a useful behavioral constraint. It does not detail output format or error behavior, but it provides meaningful transparency beyond the name.

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

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

The description is compact and well-structured: the primary listing behavior comes first, the conditional comparison mode follows, and the key exlusion is in a short final sentence. Every sentence adds useful information with no filler.

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

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

The description provides enough to understand the two invocation modes and the tool's relationship to charts, given the absence of an output schema and annotations. However, it does not explain what the returned records look like, how hypothesis_id affects behavior, or what exactly 'compare' returns, leaving some important context missing for correct invocation and interpretation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the conditional role of study_ids and evidence_hashes in compare mode, but it does not describe hypothesis_id at all, and the exact meaning of 'compare exact selected records' is only partially specified. This is adequate but leaves a clear gap.

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

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

The description names a specific verb and resource: it 'List[s] append-only market-event and observational feature-study evidence records' and can also 'compare exact selected records'. It also disambiguates itself by stating 'It never accesses a chart,' which separates it from chart-related 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 gives clear mode-selection logic: listing is the default behavior, while comparison is used 'when both study_ids and evidence_hashes are supplied.' It also states a clear when-not condition: it never accesses a chart, so it should not be chosen for chart access. It does not explicitly name alternative tools, but the context is clear.

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

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

With no annotations provided, the description carries the full burden. It discloses critical behavior: normalization of spread and tick/pip units, rejection of crossed quotes and delayed data, and the readiness condition (only ready after a streaming bid/ask change). It also explicitly states it does not access accounts or place orders. This is rich, non-obvious behavioral context that an agent could not infer from the 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?

Three dense sentences, each earning its place: what it observes, critical filtering/normalization behaviors, and explicit exclusions. The most important scoping ('read-only', 'one or more symbols') is front-loaded. No filler or repetition.

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

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

For a read-only observation tool with 4 parameters and no output schema, the description covers the key behavioral guarantees (data quality checks, readiness condition, no account access). It could have mentioned what the return value looks like (e.g., aggregated bid/ask per symbol) since there is no output schema, but the readiness semantics effectively inform the agent what to expect.

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 75%, and the description adds context around timing parameters ('polling interval while waiting for an update', 'how long to poll for a post-request bid/ask change'). The main parameter 'symbols' has pattern constraints in the schema but the description adds the semantic that these are scanner symbols. Coverage is good, but the description could have clarified the units/meaning of max_quote_age_ms beyond 'chart lp_time'.

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

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

The description opens with a specific verb ('Observe') and resource ('read-only TradingView scanner bid/ask conditions for one or more symbols'), clearly distinguishing itself from order-execution or account tools. It even states what it does not do ('does not access accounts or create, modify, or execute orders'), which eliminates ambiguity and reinforces its read-only nature.

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 observing scanner bid/ask conditions and explicitly says it is read-only, which signals against using it for trading actions. It names no direct alternative among siblings, but the contrast with execution tools is implicit. It does not state explicit exclusions like 'use get_quotes for ...', so it stops short of a full 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It adds meaningful context: the history is separately stored, officially revised, and the tool never asserts historical availability. This goes beyond a generic read description, though it does not discuss error cases or response 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?

Two sentences carry all the essential information with no filler. The primary purpose is front-loaded, and the caveat is placed immediately after, making the description easy to parse and act on.

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

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

For a simple one-parameter read tool with no output schema, the description is mostly complete: it defines the data source, scope, and critical limitations. However, it does not describe what the returned history contains or any response format details, which would be useful given the absence of 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?

Schema description coverage is 0%, so the description must compensate by explaining parameter usage. It does not mention the 'currencies' parameter at all, leaving the agent to infer from the schema alone. The tool name hints at policy-rate history, but the description adds no meaning about how to supply currency selections.

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

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

The description states a specific verb ('Read'), a specific resource ('separately stored official revised policy-rate history'), and a clear scope ('for exploratory research only'). It also distinguishes the data from prospective or out-of-sample carry evidence, which helps differentiate it from related carry and policy-rate 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 explicitly limits usage to exploratory research and explicitly warns against using it as prospective or out-of-sample carry evidence. It provides clear context and exclusions, though it does not name a specific alternative tool to use instead.

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

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

With no annotations, the description carries the full disclosure burden. It explicitly states that CFTC data is delayed, the result is a proxy rather than realtime order flow, and 'it never changes the chart,' which addresses the main side-effect concern. It does not describe return shape, COT freshness details, or any non-chart side effects, so it stops short of full transparency.

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

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

Two sentences contain no filler: the first packs the exact resource and the four data components, and the second adds the decisive caveats about being a proxy and never changing the chart. Every part contributes to selection or safe invocation.

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 16-parameter tool with no output schema and no annotations, the description gives a strong conceptual overview but leaves the return contract unstated — an agent does not know what the combined context looks like, such as normalized observations, OI quadrants, or roll flags. The rich parameter schema mitigates input ambiguity, but output semantics and sibling routing remain gaps.

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

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

Schema description coverage is 94%, so the schema already documents most parameters and their defaults, constraints, and provider-specific behavior. The description adds high-level conceptual framing for groups of parameters — trailing volume z-scores, OI quadrant analysis, roll anomaly detection — but no parameter-level details beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific action and resource: it combines one exact TradingView CME/COMEX/CBOT/NYMEX continuous-futures daily chart with delayed CFTC COT, volume z-scores, daily OI four-quadrant analysis, and roll-anomaly detection. It also labels itself a 'market-participation proxy, not realtime institutional order flow,' which helps an agent distinguish it from execution/order-flow and other context siblings. The composition is distinctive enough that the tool is not easily confused with watchlist, journal, or price-action 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 communicates a clear context of use — futures market-participation context combining COT, OI, and volume — and gives one exclusion: it is not realtime institutional order flow. However, it never explicitly says 'use when X' or names an alternative sibling for other cases, so routing among the many related context tools is left to inference.

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

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

With no annotations, the description carries the behavioral burden and it provides useful details: most recent primitives first, and extrapolated times flagged timeEstimated. These are real behavioral traits beyond the basic 'get' semantics, though it doesn't discuss errors or response shape.

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

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

Three sentences, each carrying distinct value: what it returns, when to use it, and ordering/flag behavior. No filler or repetition, and the most important 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 read tool with three optional, fully-described parameters, the description covers the key context: primitive kinds, use case for drawing-only indicators, ordering, and extrapolation flagging. Without an output schema it could specify return structure more, but the given detail is sufficient for correct invocation.

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

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

Schema description coverage is 100%, and each parameter already has a clear description including defaults and constraints. The tool description adds only redundant ordering context already present in limit_per_kind, so it provides no meaningful additional parameter semantics.

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

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

States exactly what it does: retrieves drawing primitives (labels, trend lines, boxes/zones) from a Pine indicator on a TradingView chart. It also differentiates itself from numeric-plot tools by calling out drawing-only indicators, which clearly separates it from siblings like get_indicator_values.

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

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

Explicitly says this is how to read drawing-only indicators with no numeric plots, giving clear context for when to use it. It does not explicitly name alternative tools for numeric plots, but the contrast with 'no numeric plots' implies the boundary well enough.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It clearly indicates this is a retrieval operation and specifies what data will be returned (names, current values, defaults, tooltips). It doesn't cover edge behaviors like missing studies or empty results, but for a non-mutating getter this is sufficient.

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

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

The description is concise, front-loaded, and includes a useful example. Every word earns its place, with no filler or redundant detail.

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

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

For a simple getter with two optional parameters and no output schema, the description adequately covers what the tool returns. It includes example output to clarify the format. The only minor gap is the lack of explicit mention of behavior when no study_id is provided, though the schema already documents 'Default: all indicators'.

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

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

Schema description coverage is 100%, so the baseline is 3. The description doesn't add parameter-specific meaning beyond what the schema already states about study_id and chart_index defaults, although the example does contextualize the output format.

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

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

The description clearly states the specific action ('Get the input parameters (settings) of indicators') and the resource (indicators on a TradingView chart). It also lists the output contents (names, current values, defaults, tooltips) with a concrete example, making it easy to distinguish from siblings like get_indicator_values or set_indicator_input.

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

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

Usage is implied by the name and description — if you need indicator settings, this is the tool. However, it does not explicitly mention alternatives or exclusion criteria, such as when to use get_indicator_values instead, which would have earned a higher score.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It discloses that the operation is a read of tables, describes the exact return shape (grid[row][column] plus on-chart position), and clarifies the table-only scope. It does not discuss potential errors or rate limits, but for a read-only tool the core behavior is transparent.

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

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

The description is two tightly packed sentences. The first sentence front-loads the action, the resource, and the output format; the second adds a decisive scoping fact. There is no filler or repetition of schema 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 having no output schema and no annotations, the description covers what is returned, how it is structured, and when this tool is uniquely necessary. The optional parameters are fully documented in the schema, so the description plus schema is sufficient for an agent to call the tool correctly.

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

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

Both parameters are already fully documented in the schema with descriptions and defaults, giving 100% schema description coverage, so the baseline of 3 applies. The description adds no parameter-level detail, but none is needed because the schema already explains study_id and chart_index 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?

The description states a specific verb ('Read') and resource ('tables drawn by Pine indicators on a TradingView chart'), and precisely describes the output form as text grids with row/column plus on-chart position. The phrase 'only way to read table-only summaries that have no plots or drawings' distinguishes it from sibling tools like get_indicator_values and get_indicator_graphics.

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

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

The description gives clear context for when to use the tool: to read Pine-indicator tables, especially table-only summaries without plots or drawings. It adds a strong exclusivity signal ('This is the only way'), but it does not explicitly name or compare alternative sibling tools, so it stops short of a full when/when-not matrix.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses that cosmetic plots are excluded by default, that plot names come from the indicator's own style titles, and that long-history requests require plot_titles for readability. These are meaningful behavioral details beyond the schema, though it does not describe return formatting or explicitly confirm read-only behavior.

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

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

The description is four sentences with no fluff. The core purpose is front-loaded, and each sentence adds relevant operational context: style titles, cosmetic exclusions, the prerequisite get_chart_context, and the plot_titles condition with rationale.

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

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

Given no annotations and no output schema, the description covers the key invocation needs: how to discover indicators, how to narrow plots, and when plot_titles is required. The schema handles parameter defaults and constraints. A brief statement of the return shape would make it fully complete, but nothing critical for actually calling the tool is missing.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description adds some context, such as plot titles coming from style titles and the default exclusion of cosmetic plots, but mostly reinforces what the schema already states, e.g. the above-500 plot_titles requirement.

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

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

The description opens with a specific verb and resource: 'Get recent plot values of indicators (studies) on a TradingView chart', with concrete examples like signal levels and oscillator readings. It clearly distinguishes this from sibling tools such as get_indicator_graphics or get_indicator_tables by scoping to plot values, and it further narrows scope by noting cosmetic plots are excluded by default.

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

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

It gives explicit pre-requisite guidance: 'Use get_chart_context first to see which indicators exist' and explains when to narrow with plot_titles, including the condition that plot_titles is required above 500 bars. It does not explicitly name alternative value-adjacent tools or say when not to use it, but the context provided is clear and actionable.

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

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

With no annotations to rely on, the description carries full responsibility for behavioral disclosure. It discloses what is included (level-named plots, horizontal lines, box/zone edges, label prices), what is excluded (oscillator panes, generic OHLC mirrors), that results are tagged with source indicator, and that output is sorted by distance from current price. This is rich, specific behavioral context beyond a bare 'get' statement.

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

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

Four purposeful sentences, each earning its place: scope definition with examples, explicit exclusions, ordering behavior, and usage guidance versus alternatives. The most decision-relevant information is front-loaded, and there is 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?

No output schema exists, so the description must convey output nature. It does: levels are tagged with source indicator and sorted by distance. It also covers inclusion criteria, exclusions, and the alternative approach. Minor gaps remain, such as not explicitly stating the return type (e.g., array/table) or behavior when no levels are found, but for a read-only aggregation tool this is largely 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 individual parameter descriptions already present, so the baseline is 3. The description adds conceptual context like 'near the current price' for range_percent and clarifies what 'level-named' means (relevant to include_all_plots), but it does not add syntax, formatting, or behavior details that go substantially 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 states a precise verb ('Aggregate') and a specific resource ('key price levels near the current price from ALL price-scale indicators'), and further details what counts as a level (S/R, pivot, VWAP, bands, BOS/CHoCH, horizontal lines, box/zone edges, label prices). It also explicitly contrasts this with manually combining get_indicator_values and get_indicator_graphics, making the tool's purpose unmistakable among siblings.

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

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

The final sentence directly prescribes the use case: 'Use this instead of manually combining get_indicator_values and get_indicator_graphics when you need a support/resistance table.' This is an explicit when-to-use statement that names the alternative approach it replaces. The exclusion of oscillator panes and generic value plots further clarifies what the tool is optimized for.

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