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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the data returned and does not mention any side effects, safety profile, or edge-case behavior (e.g., what happens if accountId is invalid or multiple accounts exist). The read-only nature is implied but not explicitly disclosed, and no extra context (like data freshness or ordering) is given.

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

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

The description is a single, focused sentence that lists the returned values without any redundant words or unrelated details. It is well-structured and front-loaded with the action and subject, making it highly efficient for an agent to parse.

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

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

Given the tool's simplicity (one optional parameter, no output schema, no annotations), the description is minimally adequate: it names the accessible data fields and implies the target is an account. However, it does not describe the response format, units, or how the balance relates to the accountId parameter (beyond what schema already provides), leaving some gaps for an agent.

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

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

The input schema already provides a description for the sole parameter (accountId: 'Account name. Omit for first account.'), yielding 100% schema coverage. The description adds no further meaning about the parameter beyond the generic 'for an account', so it does not elevate beyond the schema baseline.

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

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

The description clearly states the tool's function with a specific verb ('Get') and resource ('for an account'), and enumerates the exact data fields returned (cash value, net liquidation, realized/unrealized P&L, buying power). While it doesn't explicitly differentiate from sibling tools like nt_account_info, the focus on financial balance values makes its unique purpose evident.

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

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

The description provides no guidance on when to use this tool versus alternatives such as nt_account_info or nt_positions. There is no mention of preferred contexts, exclusions, or alternative tools, leaving the agent to infer when this should be invoked.

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 explaining behavior. It discloses the nature of the tool (information retrieval, not mutation), the included fields, and a notable default behavior when accountId is omitted (uses the first account). However, it does not mention potential errors, read-only guarantees, or connection requirements, which would strengthen transparency.

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

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

The description is a single, front-loaded sentence that immediately conveys the tool's purpose and scope. It includes parenthetical examples of the returned data without unnecessary verbosity, earning its place.

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

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

Given the low complexity (one optional parameter), the description is sufficient for basic understanding. It explains the input default and the type of output, but the absence of an output schema and any mention of error handling leaves small gaps. Still, for a simple info-retrieval tool, it is reasonably complete.

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

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

The schema covers 100% of parameter semantics, providing the parameter name, type, example, and omit behavior. The description does not add meaningful parameter details beyond referring to 'a specific account', so the baseline score of 3 is appropriate.

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

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

The description clearly specifies the verb 'Get' and the resource 'full details for a specific account', listing key data categories (name, connection, P&L, buying power). It effectively distinguishes itself from sibling tools like nt_accounts (likely listing accounts) and nt_account_balance (focused on balance).

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

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

The description establishes clear usage context: to retrieve comprehensive information about a single account. It implies this tool is for specific-account lookups, but does not explicitly contrast it with alternative tools such as nt_accounts or nt_account_balance, so no exclusion or alternative guidance is provided.

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

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

No annotations are provided, so the description must convey behavioral traits. It clearly indicates a read-only list operation and specifies the included data (balances and open position counts). However, it does not disclose potential performance implications, scope boundaries (e.g., demo vs live), or error behavior. The verb 'list' implies no side effects, but this remains implicit.

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

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

The description is a single, well-structured sentence that front-loads the action and resource, with no wasted words.

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

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

For a zero-parameter list operation, the description adequately covers the purpose and expected output content (balances and open position counts). There is no output schema, but the description states what is returned. It could be considered complete, though details on response format are omitted.

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

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

The tool has zero parameters, so the description adds no parameter semantics. Under the rubric, the baseline for 0 parameters is 4; the description is clear that no input is required.

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

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

The description uses the specific verb 'List' and identifies the resource as 'all trading accounts in NinjaTrader', specifying the return fields (balances and open position counts). This clearly distinguishes it from sibling tools like nt_account_info or nt_account_balance, which target a single account.

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

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

The description implies usage for retrieving a high-level view of all accounts, but it does not explicitly state when to choose this over nt_account_info, nt_account_balance, or nt_positions, nor does it mention any exclusions or alternatives. The usage guidance is only 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?

No annotations are provided, so the description carries full burden. It discloses the mutating action but omits side effects, prerequisites, reversibility, or return behavior. For a destructive operation, more transparency is needed.

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

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

The description is a single, front-loaded sentence that conveys the core function with no wasted words. It is appropriately concise.

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

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

Given the simple parameter set and no output schema, the description covers the basic function. However, it lacks details about expected outcomes or safety considerations for a cancel operation, so it is minimally complete but not fully comprehensive.

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

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

Schema description coverage is 100% for the single parameter, with 'Omit to cancel across all accounts.' The description adds the phrase 'all working orders' but does not provide additional parameter-level meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the action ('Cancel'), the resource ('all working orders'), and the scope ('for an account (or all accounts)'). It effectively distinguishes from siblings like nt_cancel_order (individual) and nt_flatten_all (positions).

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

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

The description implies usage for bulk cancellation but does not explicitly state when to prefer this over nt_cancel_order or other alternatives. It provides context (account or all accounts) but no exclusions or conditional guidance.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It states the action (cancel) but does not disclose side effects, irreversibility, error behavior, or prerequisites. An agent cannot infer what happens if the order is already filled, whether cancellation is permanent, or what the response contains.

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

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

One sentence, directly to the point, no redundant words. The description is front-loaded with the verb and clearly scoped.

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

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

For a one-param tool with no output schema and no annotations, the description is minimally adequate but lacks context about outcomes, conditions, and error handling. It doesn't explain what 'working order' means or what happens on cancellation, but for a simple tool it is not severely under-specified.

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

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

The schema has a single string param 'orderId' with no description, so coverage is 0%. The description's 'by its ID' clarifies that orderId is the identifier of the working order, providing minimal additional meaning. This is sufficient for the simple param but doesn't offer format or domain-specific details.

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

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

The description uses a specific verb 'Cancel' with a specific resource 'specific working order' and a qualifier 'by its ID', clearly distinguishing it from siblings like nt_cancel_all_orders and nt_modify_order.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. For example, it does not direct users to nt_cancel_all_orders for bulk cancellation. The only clue is the word 'specific' which implicitly contrasts with the sibling tool, but no explicit when-to-use guidance is provided.

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

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

No annotations are present, so the description is the only source. It discloses the mutation nature and local mode restriction, but lacks information on side effects (e.g., effect on indicators or orders) or whether the chart must be active.

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

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

Single compact sentence with clear front-loaded action, followed by useful usage context and constraint. No redundant phrasing.

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

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

For a simple 2-parameter mutation with no output schema, the description adequately covers purpose, use case, and local-mode restriction. It omits post-condition behavior but does not need to explain return values.

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?

Input schema covers both parameters with descriptions (100% coverage), so baseline is 3. The tool description adds no additional parameter-level detail beyond what schema already provides.

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

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

Description states a specific action ('Change the primary instrument on a chart') and resource ('chart'), clearly distinguishing it from sibling chart tools like chart_state (view state) and chart_reload.

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

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

Provides explicit use context ('Use for quarterly futures rolls') and a constraint ('Local mode only'). The right-click analogy clarifies intent, though it does not explicitly name alternatives or when not to use.

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

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

With no annotations, the description carries the transparency burden. It discloses the 'Local mode only' restriction and clarifies that it lists all open charts, implying a read-only operation. However, it does not mention failure modes, prerequisites (e.g., NinjaTrader running), or whether the result is a simple list or a structured payload.

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

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

The description is a single, clear sentence followed by a brief constraint. It is front-loaded with the action and output fields, with no filler words or redundant schema information.

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

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

For a simple list tool with no params and no output schema, the description adequately covers what it does, what it returns (symbol, timeframe, chart ID), and the local-only limitation. Minor gaps remain about error behavior and return format, but these are not critical for a straightforward enumeration tool.

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

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

The input schema has zero parameters, so schema coverage is trivially 100%. Per rubric, a tool with 0 params gets a baseline of 4. The description adds no parameter details because none exist; thus it cannot add more meaning beyond the schema.

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

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

The description clearly states 'List all open chart windows in NinjaTrader' with specific outputs (symbol, timeframe, chart ID). This distinguishes it from sibling tools like nt_chart_state or nt_chart_instrument, which target individual charts rather than enumerating all open windows.

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: call this when you need to see all open charts. However, it does not explicitly contrast it with alternatives or mention when not to use it. The 'Local mode only' constraint is a limitation but not a comparison.

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 supplies the safety/behavior context. It discloses the local-mode limitation and the F5 analogy, but does not mention potential side effects like resetting indicator states or losing unsaved chart settings.

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

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

The description is extremely concise, delivering purpose, usage, and mode constraint in a single sentence without any wasted words.

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

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

For a simple tool with one optional parameter and no output schema, the description covers the essential context: what it does, when to use it, and its limitation. It could briefly mention side effects, but overall it is adequate.

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

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

The schema already describes the only parameter (chartId) with 100% coverage. The description adds no extra parameter detail, so the baseline score of 3 applies.

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

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

The description states a specific action: 'Reload all NinjaScript on a chart (equivalent of pressing F5)'. This clearly identifies the tool's purpose and distinguishes it from sibling chart tools that query state or list windows.

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

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

Provides a clear when-to-use context ('Use after changing data series') and a constraint ('Local mode only'). However, it does not explicitly mention alternatives or when-not-to-use, stopping short of a 5.

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

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

With no annotations, the description carries full responsibility for behavior disclosure. It adds the useful constraint 'Local mode only' and lists the state components, but it does not explicitly state that the tool is read-only (though 'Get' implies it) or describe error handling (e.g., invalid chart ID, no charts available). It covers some behavioral context but not comprehensively.

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 action first. The additional details (state components, prerequisite, local mode constraint) are all relevant and concise. No redundancy or filler.

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

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

For a simple getter with one optional parameter, the description covers the output contents, the prerequisite workflow, and a key environment constraint. It doesn't address edge cases like what happens if the chart ID is invalid or if no chart exists, but the overall context is sufficient. The lack of an output schema is compensated by the description listing the returned state elements.

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

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

The input schema already provides a thorough description of chartId (origin, example, default behavior when omitted). The description only repeats the dependency on nt_chart_list, adding no new semantic meaning beyond the schema. Since schema coverage is 100%, the baseline is 3, and the description doesn't elevate it.

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

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

Clearly states it retrieves the current chart state and enumerates the components (symbol, timeframe, indicators, strategies). This explicitly distinguishes it from sibling tools like nt_chart_list (list charts) or nt_chart_reload (reload chart). The verb 'Get' + resource 'current chart state' is specific and complete.

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

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

Provides a clear usage instruction: 'Use nt_chart_list first to get chart IDs,' establishing a prerequisite workflow. Also states 'Local mode only,' which is a boundary condition. However, it doesn't explicitly contrast with alternatives beyond the sequential hint, so it's not a full when-to-use vs. when-not-to-use guide.

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 burden of behavioral disclosure. It adds 'Submits a market order at NT8 side', which is useful, but lacks details on what happens if no position exists, how accountId is handled, or potential risks of a market order. Some behavioral traits are disclosed but not comprehensively.

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

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

The description is two concise sentences with no wasted words. It front-loads the primary action ('Flatten (close)') and follows with the mechanism ('market order'), making it 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?

Given no output schema and no annotations, the description is fairly complete for a simple close-position tool. It explains the core function and execution method, but misses edge cases like no open position, account selection, and order result return. Adequate but not comprehensive.

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

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

The description adds no information about parameters beyond the input schema. Schema coverage is 50% with only the 'instrument' parameter described; 'accountId' is undocumented. The description does not compensate for this gap, so parameter semantics are insufficient.

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 'Flatten (close)' and the specific resource 'a specific position by instrument'. This distinguishes it from sibling tool nt_flatten_all, which flattens all positions, making the scope 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 implies usage for closing a single position by instrument but does not explicitly state when to use this versus alternatives like nt_flatten_all or nt_place_order. No exclusions are provided, leaving the context somewhat implied rather than explicit.

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

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

With no annotations, the description carries the full burden. It discloses the tool's scope ('all broker connections'), the state values it returns, and a limitation ('Local mode only'). It does not explicitly state non-destructiveness, but the verb 'Get' implies a read-only operation, and the additional constraint adds value 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 a single, front-loaded sentence that clearly communicates the action, object, result types, and a key constraint. Every word earns its place; 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?

Given no parameters and no output schema, the description covers all essential aspects: what the tool does, what it returns, and an important environmental restriction ('Local mode only'). This is complete for a simple status-checking tool.

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

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

The tool has zero parameters, so the schema fully documents the input (empty object). With 100% schema coverage and no params, the description has no obligation to explain parameter syntax. It correctly avoids inventing unnecessary parameter details.

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

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

The description clearly states the specific action ('Get'), the resource ('status of all broker connections in NinjaTrader'), and the result values ('Connected / Disconnected / Connecting'). This distinguishes it from siblings like nt_health_check or nt_accounts by focusing on broker connections.

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 you need broker connection status. However, it lacks explicit alternatives or exclusions, such as 'use this instead of nt_health_check for connection-level detail' or 'not for account-level health'. The 'Local mode only' constraint provides context but no comparative guidance.

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

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

With no annotations, the description must disclose all behavioral traits. It clearly states the sweeping action (flatten all positions, cancel all orders across all accounts), which implies destructive and far-reaching effects. However, it doesn't mention irreversibility, execution method (e.g., market liquidation), or any safety caveats—leaving room for more transparency.

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

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

The description is a single, impactful sentence that front-loads the emergency warning and immediately states the action. Every word contributes to clarity, with no redundancy.

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

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

For a zero-input tool with no output schema, the description provides the essential action and scope. The emergency-stop framing contextualizes the tool's severity, though a brief note on confirmation or irreversible consequences would enhance completeness.

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

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

The tool has zero parameters, so the input schema already provides complete coverage. Per the baseline for 0-parameter tools, the description need not add parameter details, and the score reflects that.

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

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

The description clearly states the tool's purpose with a specific verb ('flatten') and explicit scope ('all open positions and cancel all working orders across all accounts'). This distinguishes it from sibling tools like nt_cancel_all_orders (which only cancels orders) and nt_close_position (which closes a single position).

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 'EMERGENCY STOP' prefix conveys a strong situational context for urgent use. However, it doesn't explicitly name alternative tools or conditions when not to use, so it stops short of full when/when-not guidance.

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

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

With no annotations, the description carries the full burden. It states the tool verifies the addon and returns account count, implying a read-only health check, but does not disclose error behavior, return format, or whether it has any side effects. For a simple health check, this is adequate but lacks depth.

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

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

The description is a single sentence, direct, and front-loaded with the action. There is no redundant information.

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

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

Given the tool's simplicity (no parameters, no output schema, no annotations), the description provides the essential information: purpose and return value. It is complete for this 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?

The tool takes zero parameters, so the description does not need to elaborate on parameter meaning. Baseline of 4 applies.

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

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

The description uses the specific verb 'Verify' and names the McpBridgeAddon resource, clearly distinguishing it from sibling trading tools. It also states the return of account count, making the tool's function unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention typical use cases, prerequisites, or scenarios where this would be preferred, leaving the agent to infer its purpose from the name.

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

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

The description discloses the async nature of NT8 historical bars and the placeholder return, which is a significant behavioral trait given the absence of annotations. Yet it leaves out details on how to retrieve the actual data or handle failures.

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 purpose and a key caveat are front-loaded. This is a model of concise, useful documentation.

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

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

The description covers the core request and a key caveat but lacks guidance on retrieving the eventual data after the placeholder, as well as parameter semantics. Given the sparse schema and no output schema, this leaves users with open questions.

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 only 33% description coverage, and the description adds no parameter-specific details. The meaning of 'bars' and 'symbol' is left to inference, and only 'interval' has schema-level 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 'Request historical OHLCV bars' with a clear verb and resource, and distinguishes it from nt_quote for live data. This effectively clarifies the tool's role even without elaborate detail.

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

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

The note explicitly directs users to nt_quote for live data, providing a clear alternative. It also warns about async behavior, helping users set expectations. However, it does not elaborate on when to prefer this over other chart-related siblings.

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

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

With no annotations, the description carries the burden. It does disclose that the operation is a read ('Read'), scopes to current output series values, and is local-only. It does not describe error behavior, prerequisites beyond an open chart, or return format, leaving some gaps.

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

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

A single, front-loaded sentence conveys the action, target, and a key constraint. No wasted words.

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

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

The tool is simple with only two well-described parameters. The description names the resource and scope ('current output series values', 'on an open chart'), which is sufficient context for a read-only chart data retrieval. No output schema means return values are not formalized, but the phrase 'output series values' hints at the result.

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

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

The input schema covers both parameters with clear descriptions (symbol as instrument, indicatorName as class name). The description adds no extra meaning beyond the schema, so the baseline 3 applies.

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

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

The description uses a specific verb ('Read') and identifies the resource ('current output series values of a NinjaScript indicator on an open chart'). This clearly distinguishes it from siblings like nt_quote and nt_chart_state.

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

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

The description implies the use case: reading indicator values on an open chart. It mentions 'Local mode only' as a constraint but does not provide explicit when-to-use or when-not-to-use guidance or name alternatives.

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

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

With no annotations, the description carries the full burden. It lists the returned fields, implying a read-only getter operation, but does not explicitly state side-effect-free behavior, error handling (e.g., behavior for invalid symbols), or whether the data is cached or real-time. This is minimal but not misleading.

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

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

The description is a single, front-loaded sentence that immediately states the purpose and lists the key output fields. Every word adds value, with no redundancy or filler.

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

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

For a simple one-parameter tool with no output schema, the description is fairly complete: it enumerates the return fields and the parameter is fully documented in the schema. It lacks any note on error conditions or availability, but given the simplicity, this is a minor gap.

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

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

Schema description coverage is 100% for the sole parameter 'symbol', which includes an example. The description adds no additional parameter semantics beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function with a specific verb ('Get') and resource ('instrument details'), and enumerates the exact fields returned (tick size, point value, exchange, currency, instrument type). This distinguishes it from sibling tools like nt_quote (which returns pricing) and nt_search_instruments (which finds instruments).

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

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

No explicit guidance is provided on when to use this tool versus alternatives. The description does not mention that this is for static instrument metadata rather than real-time quotes or historical data, nor does it reference sibling tools. Users must infer usage from the tool name and context.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It adds the key requirement of an L2 subscription, which signals a potential error condition if absent. However, it does not describe return format, data structure, or any other behavioral traits beyond the subscription prerequisite.

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

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

The description is a single, focused sentence that delivers the core purpose and a critical prerequisite without redundancy. Every word earns its place, and the structure is immediately scannable.

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

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

For a simple tool with one parameter and no output schema, the description provides the essential function and a key requirement. However, it lacks information about the return structure, error conditions (e.g., without subscription), and explicit parameter mapping, leaving some gaps for an agent to infer.

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 has one parameter (symbol) with 0% description coverage. The description mentions 'for an instrument' but does not explicitly map 'symbol' to the instrument identifier or provide value formats/examples. This leaves the parameter semantics largely undefined beyond the schema's basic type 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 clearly states the tool retrieves the Level 2 order book for an instrument, using a specific verb ('Get') and resource ('Level 2 order book'). This distinguishes it from sibling tools like nt_quote or nt_historical_bars, which serve different data retrieval purposes.

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

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

The description implies usage when market depth data is needed, but it does not explicitly contrast with alternatives or state when not to use it. It provides a prerequisite (L2 subscription), which offers some usage context, but no guidance on choosing between related quote/depth 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?

No annotations are provided, so the description must carry the full behavioral burden. It only states that fields can be changed but does not disclose side effects like order replacement, authorization requirements, validation constraints (e.g., cannot modify partially filled orders), or whether changes are atomic.

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

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

The description is a single, concise sentence that is front-loaded with the primary action ('Modify an existing working order') and immediately lists the relevant fields. No wasted words or redundant 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?

Given the simple input schema (four scalar parameters, no output schema), the description provides a baseline level of completeness by identifying the target resource and editable fields. However, it omits behavior details like return values, error conditions, and side effects, which are not covered elsewhere because there are no annotations and no output schema.

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

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

Schema description coverage is 0%, so the description should compensate. It enumerates the three modifiable fields (quantity, limit price, stop price) but merely paraphrases the parameter names without adding constraints, units, or relationships. The required orderId is not mentioned, though its purpose is fairly obvious from the tool name.

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 modifies an existing working order and specifies the modifiable fields (quantity, limit price, stop price). This distinguishes it from sibling tools like nt_place_order (create) and nt_cancel_order (cancel).

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 'existing working order' indicates the intended context of use—orders that are already active and filled/rejected orders are excluded. However, it does not explicitly name alternative tools or state when not to use it, though sibling tool names provide implicit context.

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

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

With no annotations provided, the description carries the burden of conveying safety and behavior. 'List' implies a read-only operation, and the optional filters are mentioned, but the description does not disclose return format, default behavior (all orders), or any potential side effects. It is adequate but lacks richer behavioral context.

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

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

The description is a single, front-loaded sentence with no redundant words. It states the primary action first and then provides concise filter information.

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

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

For a simple list tool with two optional parameters and no output schema, the description covers the essential purpose and filters. It implies default behavior (all orders) via 'optionally filtered', though it does not describe the response structure. This is adequately complete given the tool's simplicity.

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

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

Despite 0% schema description coverage, the description effectively explains both parameters: 'account' maps to accountId and 'status' lists all allowed enum values. It also indicates both are optional. This compensates well for the lack of schema-level 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 uses the specific verb 'List' with the resource 'orders', and explicitly mentions optional filters for account and status. This clearly distinguishes it from sibling tools like nt_place_order and nt_cancel_order, which perform different actions.

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

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

The description clearly implies when to use this tool (to view orders) and mentions the filtering options. However, it does not explicitly state when not to use it or name alternatives, but the context of sibling tools makes the intended usage 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 of behavioral disclosure. It only states that it places an order and lists order types, but does not mention execution risks, account selection behavior, validation requirements, or any side effects of placing an order. For a potentially market-moving action, this is a notable transparency gap.

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

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

The description is a single, front-loaded sentence that states the action, object, and scope without any redundant or vague wording. Every word adds value, making it exceptionally concise and well-structured.

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

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

For a 7-parameter trading action with no output schema and no annotations, the description is too sparse. It omits return values (e.g., order ID), conditional price requirements in prose, default account behavior, and risk information. Sibling tools like nt_close_position present clear alternatives that are not referenced, making the context incomplete for correct agent invocation.

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

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

Schema coverage is 71%, and the schema already documents instrument, quantity, accountId, stopPrice, and limitPrice with 'Required for' notes. The description adds only 'any instrument' and echoes the orderType enum values already present in the schema. It does not compensate for the 29% gap or explain parameter interactions (e.g., StopLimit requires both prices), but it doesn't mislead either.

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 ('Place') and a clear resource ('a new order'), and explicitly lists the supported order types (Market, Limit, Stop, StopLimit). The word 'new' distinguishes this from sibling tools like nt_modify_order and nt_cancel_order. This is a precise and unambiguous purpose statement.

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

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

The description gives no guidance on when to use this tool versus alternatives such as nt_close_position for reducing exposure or making directional trades. It also does not explain when to choose Market versus Limit or Stop order types. No context or exclusions are provided, leaving the agent to infer usage from the schema alone.

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

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

No annotations are provided, so the description carries the burden. The verb 'Get' implies a read-only operation, which is sufficient at a basic level, but the description does not disclose behavior when the position is not found (e.g., returns null or errors) or any other constraints. It adds minimal depth beyond the operation itself.

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

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

The description is a single clear sentence, front-loaded with the action and key qualifiers. No wasted words.

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

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

For a simple 2-parameter getter, the description is adequate. It lacks an explicit return value description, but since there is no output schema, a note on what is returned would strengthen completeness. Missing usage exclusions are the main gap, but overall the description covers the core 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%, providing descriptions for both accountId and instrument. The description only restates 'by account and instrument' without adding further meaning or parameter-specific details, so it does not exceed the baseline for fully covered schema.

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

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

The description clearly states it gets a specific position, with the qualifiers 'by account and instrument' distinguishing it from sibling tool nt_positions which presumably lists all positions. The verb 'Get' is specific and the resource is unambiguous.

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

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

The description implies usage when a single position is needed by account and instrument, but it does not explicitly contrast with nt_positions (for all positions) or mention any exclusions. It conveys context but lacks clear when-to-use vs alternatives guidance.

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

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

With no annotations, the description carries the full burden. 'List' clearly implies a read-only operation, and the scope is stated, but it does not add details like response format, pagination, or performance considerations. Still, the core behavior is transparent enough for safe invocation.

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

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

A single, front-loaded sentence that clearly states the action and optional scope. No wasted words; the structure is ideal for quick agent parsing.

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

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

Given the low complexity (one optional parameter, no output schema), the description and schema fully specify what the tool does and how to invoke it. The agent can confidently call it to retrieve open positions with or without an account filter.

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

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

The schema already provides 100% parameter coverage, describing accountId as 'Filter to a specific account. Omit for all.' The description largely repeats this ('across all accounts (or a specific account)'), adding little semantic value beyond the schema.

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

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

The description uses a specific verb ('List') and resource ('open positions'), and clearly scopes the action to 'all accounts' or 'a specific account'. This distinguishes it from sibling tools like nt_position (singular) and nt_close_position.

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

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

The description provides clear usage context: use it to list open positions, optionally filtering by account. It does not explicitly exclude alternatives or state 'use nt_position instead for a single position', but the scope is evident.

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

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

No annotations are provided, so the description carries the burden. It discloses a behavioral requirement (subscription) and the specific data fields returned. It does not mention error cases, read-only nature, or response format, but for a simple quote tool this is moderate.

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

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

Two sentences, no filler, front-loaded with the action and data fields. Every word earns its place.

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

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

For a one-parameter, no-output-schema tool, the description covers the core functionality and the key precondition. It is sufficiently complete 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 schema already documents the single 'symbol' parameter with an example. The description adds no additional semantics beyond referring to it as an instrument, so baseline 3 is appropriate.

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

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

The description clearly states the tool retrieves current bid, ask, last price, and volume for an instrument. The verb 'Get' and resource specification are precise, and it distinguishes itself from siblings like nt_market_depth (order book) and nt_instrument_info.

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

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

It explicitly states the prerequisite that the instrument must be subscribed in NT8, which is a key condition for usage. However, it does not explicitly compare to alternative tools like nt_market_depth or mention when to prefer this over others.

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

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

With no annotations, the description carries the full burden. It discloses the result limit (up to 50 matches) and the data source, but does not mention case sensitivity, partial match behavior, or any connection requirements. It provides some useful context but omits specific behavioral traits that could affect how an agent uses the tool.

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

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

The description is a single, front-loaded sentence that names the action and resource, then adds the search criteria and a constraint. There is no redundant or filler content; every word earns its place.

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

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

For a one-parameter search tool with no output schema, the description covers the core functionality, parameter meaning, and result expectation. However, it does not explain how the returned matches can be used with other tools (e.g., converting an instrument identifier for nt_quote or nt_historical_bars), which is a minor context gap.

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

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

The schema has one parameter 'query' with no description, and schema_description_coverage is 0%. The description compensates by clarifying that 'query' is the name or symbol to search for. This directly explains the parameter's meaning, though it could add details like whether wildcards are supported.

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

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

The description clearly states the action 'Search for instruments' with specific criteria 'by name or symbol' and the data source 'NT8 instrument database'. It also specifies a result limit of 50 matches, which helps distinguish it from related tools like nt_instrument_info that likely retrieve details for a known instrument.

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

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

The description implies this tool is used when you need to find instruments by name or symbol, but it does not explicitly state when to use it over alternatives or provide exclusions. For example, it doesn't mention that this should be used when you don't already have an instrument identifier, unlike sibling tools like nt_instrument_info.

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. The verb 'List' implies a read-only operation, and 'Local mode only' adds a behavioral constraint. However, it does not disclose potential errors, connection requirements, or side effects (though clearly a read operation), leaving some gaps.

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

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

The description consists of two concise sentences, with the primary action front-loaded and no redundant information. Every word 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 simple list tool with no output schema and no annotations, the description sufficiently describes functionality and lists the output fields. The only minor gap is the lack of an explicit return format (e.g., array of objects), but the fields listed are enough for an agent to infer the shape.

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

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

The tool has zero parameters, and the schema is empty. The description has nothing to add beyond the baseline, which is 4 for no-parameter tools.

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

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

The description uses a specific verb ('List') and resource ('currently running NinjaScript strategies'), and enumerates the returned fields (state, chart ID, symbol). The 'Local mode only' constraint further specifies scope, distinguishing it from strategy management tools like nt_strategy_stop.

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

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

The description provides a clear context for use by stating it only applies to local mode, implying it should not be used for live trading. However, it does not explicitly name alternatives or state when-not-to-use beyond the local mode constraint, so it falls short of a 5.

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

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

With no annotations, the description must carry the full burden. It discloses a limitation ('Local mode only') and implies a state change, but does not mention potential side effects (e.g., impact on open positions), error handling, or irreversibility. This is a moderate disclosure for a destructive 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?

Two short, front-loaded sentences with no wasted words. The first sentence states the core purpose, the second gives essential usage and constraint information.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, prerequisite, and a key constraint. However, it omits what happens on success/failure (e.g., feedback response), but given the simplicity, this is a minor gap.

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

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

The schema already describes the parameter ('Strategy class name'), but the description adds critical context on how to obtain the exact value: 'Use nt_strategies_running first to get exact names.' This goes beyond the schema, improving parameter understanding.

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

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

The description clearly states the action ('Stop') and the resource ('a running NinjaScript strategy') with specific method ('by class name'). It distinguishes from siblings by being the only stop-related tool among the listed tools.

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

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

The description provides a clear usage prerequisite: 'Use nt_strategies_running first to get exact names.' It also notes a constraint ('Local mode only'), which helps set expectations. It does not explicitly state when not to use it, but the guidance is actionable.

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