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

With no annotations, the description carries the full burden and covers it well: deterministic not estimated, sector classification sourced from NSE macro-economic data rather than user input, and unclassified instruments are reported/counted rather than guessed. This is strong behavioral disclosure.

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?

Every clause earns its place: deterministic behavior, classification source, unclassified handling, and optional target comparison are all functional for selection and invocation. Information is front-loaded with the core computation.

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, the description lists the computed metrics and drift comparison, which is reasonably complete. However, the exact output shape/format is not specified, and given no annotations, slightly more return-value detail would help.

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 33%, but the description compensates for key parameters: target is explained as optional comparison for drift, groupBy sector is tied to NSE classification by ISIN/symbol, and positions are described as the list to compute over. It leaves some exact format details to 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 specific verb 'Compute', resource 'allocation weights and concentration', and names concrete outputs HHI and effective holdings count. This clearly differentiates it from sibling tools like get_holdings or compute_xirr.

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 context: use for allocation/concentration over a list of positions, with optional target drift comparison and standard sector grouping. It does not explicitly name exclusions or alternatives, so not a 5.

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

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

With no annotations, the description carries the transparency burden. It discloses the analytical scope ('Descriptive only', no ranking/recommendations) and implies a read-only, market-value computation. It does not explicitly state that the operation is non-mutating or describe external NAV-fetch dependencies, though those are expected for this kind of analysis.

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

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

Three short sentences front-load the core action, clarify the temporal scope, and set an expectation boundary. No sentence is redundant or wasted.

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 annotations and no output schema, the description explains the transformation, the valuation basis (AMFI NAV by ISIN), the output concepts (weights, concentration), and the non-evaluative nature. It could add what the returned structure looks like, but the information needed to decide to call it and invoke it is present.

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

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

The tool description itself contributes little to parameter understanding beyond the schema. However, the schema already documents groupBy at length and filePath clearly; only password lacks semantic explanation, and its purpose is inferable. This is adequate but not exceptional.

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 ('Take the holdings in a CAS, revalue them at today's published AMFI NAV ... and compute allocation weights and concentration') and clearly identifies the resource and scope. It also distinguishes itself from generic parsers or return-calculators by focusing on the current mutual fund side of the portfolio.

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 usage context: use it when a current, NAV-based view of mutual fund holdings is needed rather than the statement-date view, and only for descriptive analysis since it 'does not rank or recommend anything.' It stops short of naming explicit sibling alternatives, so the exclusion guidance is slightly 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 provided, the description carries the behavioral disclosure burden. It transparently reveals that out-of-universe instruments return unmatched rather than guessed, states the approximate universe size, and explains the no-argument vocabulary response. It lacks detail on return shape, but the non-judgemental, read-only nature of the operation is well conveyed.

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 sentences with no filler. It front-loads the core purpose, immediately follows with the key limitation that differentiates the tool, and ends with a practical usage tip. Each 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 look-up tool with two optional parameters and no required inputs, the description covers what an agent needs to decide when to call it and what to pass. It even explains the no-argument call for exploring the vocabulary. The only gap is the exact shape of the returned sector assignments, but the 'resolves to sector' phrasing and unmatched behavior make the expected outcome reasonably clear.

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

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

Schema description coverage is 100%, so the schema already documents the isins and symbols parameters, including examples. The description adds only a high-level 'by ISIN or trading symbol' mapping and the no-argument behavior, which is useful but not a substantial addition 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-resource pair: 'Resolve instruments to NSE's macro-economic sector by ISIN or trading symbol.' It clearly distinguishes itself from sibling tools by emphasizing it is an official published classification, not a judgement call, which prevents confusion with search or quote 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 context: use it for official NSE sector classification of Nifty Total Market constituents, and explicitly warns that anything outside that index returns unmatched rather than guessed. It also provides a concrete invocation strategy ('Call with no arguments'), though it does not explicitly name alternative tools or state when not to use it.

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

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

With no annotations provided, the description carries the disclosure burden, and it does so well by stating this is 'pure arithmetic on the numbers you supply'—communicating determinism, no data fetching, and no side effects. It also explicitly disclaims advice/recommendation behavior. It stops short of describing the exact return format, but the core behavioral traits an agent needs are 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 sentences with no filler: the operational behavior is front-loaded and the disclaimer earns its place by preventing misuse. The em-dash extension adds context without bloating the description.

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 appropriate for a simple computational tool and covers what the tool computes and its scope. Yet with no output schema and no annotations, it leaves out explicit details such as the returned value, compounding convention, and parameter units, which would make invocation fully unambiguous.

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 clarifies the roles of regularExpensePct and directExpensePct as the 'two expense ratios' and years as the 'holding period,' supplementing the sparse schema. However, with schema coverage only at 40%, it does not fully explain the formula relation of amount and assumedReturnPct or the units/output precision, leaving the agent to infer some parameter semantics.

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

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

The description identifies a specific operation—compounding the difference between two expense ratios over a holding period—and makes the output purpose explicit: showing what a fee difference costs. It also explicitly distinguishes itself from a recommendation tool ('does not recommend a fund'), which sets it apart in a sibling list dominated by data-lookup tools.

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

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

The description implies use when one wants to quantify the cost of an expense-ratio difference over time and explicitly warns it is not for fund recommendations. It does not name sibling alternatives or give explicit selection conditions, so the agent must infer suitability from the calculation phrasing rather than from a routing rule.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explains the cash-flow sign conventions ('Purchases and levies count as outflows, redemptions and dividend payouts as inflows') and how the series is closed by current value, which are meaningful behavioral details. It does not mention failure modes or whether the operation has side effects, but this is clearly a read/compute operation.

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

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

Three tightly written sentences front-load the core purpose, use the sibling reference to add context, and finish with the essential cash-flow conventions. There is no filler; 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 what the tool does, how flows are counted, and how it differs from compute_xirr. Gaps remain: the password parameter is unexplained, and without an output schema the return format is only implied ('annualised return').

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 75% and the schema already documents filePath, scope, and valueAt well, so the description does not need to repeat them. The description adds no new parameter detail, and the password parameter remains completely undocumented in both the schema and 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 opens with a specific verb and resource: 'Compute annualised return (XIRR) from the real, dated cash flows in a consolidated account statement.' It also explicitly contrasts itself with compute_xirr, saying that tool handles arithmetic but this one pulls the flows from the statement, so an agent can tell them apart.

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 clearly implies when to choose this tool: when you have a CAS PDF with many dated flows, because 'nobody can hand-type years of SIP instalments.' It references compute_xirr as the alternative, though it stops short of explicitly stating 'use compute_xirr only when you have a small set of manually entered cash flows.'

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 transparency burden. It does add important conventions: outflows must be negative, inflows positive, and the current portfolio value must be included as a final positive flow dated today. Still, it does not disclose potential failure modes such as non-convergence, the need for at least one negative and one positive flow, or the exact form of the returned annualised value.

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

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

Two dense, purposeful sentences. The core concept is front-loaded, followed immediately by the operational rules an agent needs to construct valid input. 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?

For a single-parameter computation tool with no output schema, the description provides sufficient input semantics and the one special cash-flow requirement. It is missing an explicit disambiguation from compute_cas_xirr and does not mention edge cases such as non-convergence, but the description is otherwise complete for an agent to produce a valid call.

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

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

The schema describes only the date format and leaves 'amount' semantically empty. The description compensates by defining the amount sign convention and instructing the agent to include the portfolio value as a final positive flow. It does not discuss ordering or duplicate-date handling, but the core meaning of the single cashFlows parameter is substantially clarified.

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 computational goal ('Annualised return across irregular cash flows') and illustrates the resource with SIP instalments, lumpsums, and redemptions. This makes it clear that the tool computes XIRR for a raw dated cash-flow series rather than for a parsed CAS file, distinguishing it from the sibling compute_cas_xirr even without naming it.

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

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

The description clearly implies when the tool is relevant: whenever an agent has a dated series of irregular cash flows and needs an annualised return. However, it never explicitly contrasts this with compute_cas_xirr or other portfolio-analysis siblings, and it gives no when-not-to-use guidance such as 'do not use for already-parsed CAS data.'

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

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

With no annotations, the description carries the transparency burden. It adds meaningful behavioral context: paths are verified against official docs, so failures indicate auth/entitlement issues rather than invalid paths. However, it does not explicitly state whether the probe is read-only, what output format to expect, or any side effects, which would provide fuller 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 focused sentences with the main action and outcome front-loaded in the first. The second sentence earns its place by preempting a likely misinterpretation of failures.

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

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

For a zero-parameter tool with no output schema, the description covers the essentials: what it does, what the report tells you, and how to interpret failures. Nothing an agent needs to invoke it correctly 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, so there is no schema-level ambiguity to resolve. The description still adds useful domain meaning by explaining what 'resolve' means in terms of account entitlements.

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 ('Probe every configured endpoint') and the expected outcome ('report which resolve on your account'). It clearly distinguishes this from sibling data-retrieval tools by focusing on endpoint connectivity rather than market 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 context for use is clear: this is the tool to run when you need to check whether configured API endpoints are reachable and authorized for the account. It advises how to interpret failures (expired token or missing entitlement), which is useful guidance. It stops short of explicitly naming alternatives or exclusion conditions, but no sibling tool serves the same diagnostic role.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose the read-only nature and account scope, but it does not describe response contents, currency, or any data-freshness limitations. It provides a baseline level of transparency without 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, efficient sentence with the core data point upfront and the access mode stated at the end. There is no redundancy or filler.

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

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

For a zero-parameter, read-only balance check, the description covers what is returned (cash balance and margin), where (INDstocks account), and that it is safe to call. A marginally more complete description might mention the return shape or currency, but the simplicity of the tool makes this 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 has zero parameters, so there is nothing to document beyond the schema itself. The description correctly omits parameter guidance, matching the baseline for a parameterless tool.

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 resource—'cash balance and margin'—and scopes it to the INDstocks account. It clearly distinguishes this from sibling tools like get_holdings or get_positions by identifying the financial data being retrieved.

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 notes 'Read-only', which implicitly tells the agent it is safe to call without side effects. However, it does not explicitly say when to prefer get_funds over related tools or mention any exclusions, leaving usage context mostly 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. It usefully discloses input quirks: intervals must be spelled out, dates are plain YYYY-MM-DD, 'to' is exclusive, and only 5 scrip codes are allowed. However, it does not describe the response shape or any operational caveats, keeping it at a 3.

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 brief sentences, each necessary: the first states function and scope, the second covers interval formatting, and the third covers date formatting and exclusivity. Information is front-loaded and there is no filler.

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

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

For a tool with four parameters, no output schema, and no annotations, the description covers the important calling contract: maximum scrip count, interval spelling, date format, and exclusivity. It could be more complete by explicitly describing the returned candle structure or pagination, but those are implied by 'OHLCV candles'.

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 scripCodes, from, to, and the interval enum, so the baseline is 3. The description adds the crucial 'never abbreviated' interval rule and reinforces the inclusive/exclusive date semantics, which adds real 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 identifies a specific resource and operation: retrieving historical OHLCV candles for up to 5 scrip codes. 'Historical candles' clearly sets it apart from live-quote/streaming siblings such as get_quotes and stream_quotes, even though those tools are not named explicitly.

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

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

The description makes the applicable context clear: use it for historical candle data across up to 5 scrip codes, in contrast to live or streamed market data. It does not explicitly name alternative tools or give when-not-to-use conditions, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure and does so well: it states 'Read-only', explains the limitation of no current price/market value/P&L, and documents the transformation of API fields into quantity/averagePrice and NSE scrip code. This is meaningful behavioral context beyond a simple action verb.

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 dense sentences with the key scope and limitation front-loaded. Every phrase adds information: read-only, return fields, exclusions, downstream routing, and normalisation behavior, with no filler.

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

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

For a no-input read-only endpoint without an output schema, this is nearly complete: it defines return semantics, the critical omission (no market value), and how results should be consumed downstream via get_quotes and analyze_allocation. The only minor ambiguity is the mechanics of 'normalised', but an agent still has enough to invoke the tool and interpret its output.

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

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

There are zero parameters and the schema is empty, so the baseline is 4 and there is no parameter detail for the description to add. The mention of 'normalised' adds useful output/behavior context but does not fully resolve how that representation is requested, which keeps it from a 5.

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 first sentence names a specific resource ('long-term delivery holdings') and a read-only retrieval action. The second sentence sharpens scope by enumerating what is returned (quantity, average price per scrip) and explicitly excluding current price, market value, and P&L, which clearly separates it from valuation tools like get_quotes.

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 strong workflow context: pass security_ids to get_quotes to value the book, and use the normalised vocabulary for analyze_allocation. It does not explicitly state when to prefer get_positions or other holdings-related siblings, so the guidance is clear but not exhaustive.

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 behavioral burden and does so thoroughly. It discloses the read-only nature, the server's inability to mutate orders, and the important quirk that the response shape is unpublished and passed through unvalidated, so the agent must inspect field names rather than assume them.

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

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

Three concise sentences, each earning its place: the first states what the tool does, the second clarifies the read-only scope, and the third flags a crucial response-handling caveat. 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 zero-parameter, read-only tool with no output schema, the description covers everything an agent needs: the resource being viewed, the read-only constraint, and the unvalidated response shape with explicit guidance to read field names. Nothing important is missing for invoking the tool correctly.

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

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

The tool takes zero parameters and schema coverage is 100%, so there are no parameter semantics to document. The description appropriately focuses on behavior and response shape rather than adding 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 states a specific verb ('View'), a precise resource ('today's orders and their fill status'), and clearly frames the tool as a read of the order book. It is distinguishable from siblings like get_positions or get_holdings because it focuses on today's orders and fill status rather than holdings or 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 explicitly says this is a READ operation and that the server cannot place, modify, or cancel orders, giving an agent clear boundaries on when to use this tool versus actions that mutate orders. It does not name specific sibling alternatives, but the context is clear and sufficient for a read-only order-book lookup.

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 does state that the operation is read-only and that omitting both filters returns the default view. This goes beyond the schema, though it could have disclosed more about response shape or error 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 short sentences put the resource and read-only guarantee first, then the filter usage. Every sentence adds 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?

For a simple read-only list tool with two optional parameters and no output schema, the description provides the main behavior, default view, and filter semantics. It is sufficient for an agent to call the tool correctly, though return field details would have rounded it out.

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?

Although schema description coverage is 0%, the schema's enums already define allowed values. The description adds the critical facts that both parameters are optional and that omitting them yields the default view, compensating for the schema's lack of prose.

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 resource ('open intraday and derivative positions') and the read-only nature of the operation, which makes it clearly distinct from sibling tools like get_holdings. It is not quite a 5 because it never explicitly contrasts itself with a sibling and the double use of 'open' (verb and adjective) introduces mild ambiguity.

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

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

It gives concrete guidance on using the optional filters and the default behavior when filters are omitted. However, it does not explain when to choose this tool over alternatives such as get_holdings, so the selection context is implied rather than explicit.

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

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

With no annotations, the description carries the full burden, and it does disclose key behavioral traits: it is a read-only fetch, requires an authenticated token, and is inexpensive to call. It does not describe error behavior or response format, but for a side-effect-free, zero-parameter endpoint this is sufficiently 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 exactly two sentences with no filler. The first sentence states the operation, and the second adds a concrete decision-useful purpose, making every word earn its place.

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

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

For a zero-parameter read endpoint, the description provides all essential context: what resource is fetched, that it requires an authenticated user, and why an agent would call it. No output schema exists, but the absence of inputs and side effects means nothing blocks 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?

This tool has zero parameters and the schema coverage is 100%, so there is no parameter-level meaning for the description to add. The baseline of 4 applies because no input guidance is needed.

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

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

The description uses a specific verb ('Fetch') and names a concrete resource ('authenticated user's INDstocks profile'), making the tool's target unambiguous. The additional sentence about token validation further sharpens its purpose and differentiates it from sibling tools about holdings, orders, and schemes.

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

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

The description explicitly tells agents when to use this tool: as the cheapest way to confirm the API token is valid and not expired. It does not name alternatives such as refresh_token or diagnose_endpoints, nor does it list exclusions, but the primary use case 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 burden of behavioral disclosure. It reveals that quotes are 'live,' that scrip codes follow a specific format, and that mode='ltp' returns only last traded price. However, it does not describe the response shape, what 'full' mode includes, error behavior, or any side effects—though this appears to be a read-only quote 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?

Three short sentences, each contributing useful information: purpose and format, prerequisite workflow, and mode semantics. No filler or repetition; the most important operational detail (code format) 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 quote-fetching tool with no output schema, the description provides enough to call it correctly: scrip code format, prerequisite lookup step, and mode behavior. It does not describe the returned payload or error handling, but the core usage is adequately 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?

The schema documents only an example for scripCodes and an enum for mode (50% coverage), so the description adds meaningful semantic value. It explains the scrip code format and what mode='ltp' does, covering both parameters beyond what the schema alone provides.

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

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

The description clearly states the tool provides 'live market quotes' for scrip codes and specifies the required format (e.g., 'NSE_2885'). It is specific about the resource and action, though it does not explicitly distinguish itself from closely related siblings like stream_quotes or watch_prices.

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 workflow guidance: 'Use search_instruments first to get scrip codes' and 'Set mode='ltp' for last traded price only.' This is clear practical context, but it does not state when not to use this tool or suggest an alternative sibling for streaming or historical needs.

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 transparency burden. It usefully specifies 'latest published' to indicate only the most recent NAV is returned, not historical data. However, it does not disclose output format, error behavior for invalid scheme codes, or whether any authentication is required.

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 with no filler. Every word contributes meaning, and the key constraint 'specific AMFI scheme code' is front and center.

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

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

For a simple single-parameter lookup, the description covers the core input semantics but lacks important contextual details. Since there is no output schema, it should at least hint at the return value shape, such as whether it returns just the NAV amount or an object with date and scheme details.

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

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

The schema provides no description for schemeCode and schema coverage is 0%, so the description's 'AMFI scheme code' is the only semantic guidance. It correctly tells the agent what kind of code to supply, though it omits format details such as expected length or digit pattern.

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

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

The description clearly identifies the tool's purpose: retrieving the latest published NAV for a specific AMFI scheme code. The phrase 'specific AMFI scheme code' distinguishes it from broader tools like get_funds or get_quotes, though it does not explicitly name a 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 description explains what the tool does but provides no guidance on when to choose it over related tools such as get_historical, get_quotes, or search_mutual_funds. No exclusions, prerequisites, or alternative conditions are given.

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

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

With no annotations, the description carries the full burden and does so well: it discloses local-disk, in-process parsing, no upload, password protection, automatic statement-kind detection, and the presence/absence of transactions by statement type. This is substantial behavioral context beyond merely saying 'parse PDF'.

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 opens with the core purpose, then adds scope, rationale, privacy, and password context in dense but non-redundant sentences. Every sentence earns its place and no fluff 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?

For a parse tool with no output schema, it communicates what the output will represent (holdings and optional transaction history) and covers inputs and constraints. It does not define the return structure or error behavior, a minor gap given the absence of an output schema, but the core call and chaining context are clear.

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

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

Schema coverage is 100%, so a baseline of 3 applies; the description adds useful meaning by linking includeTransactions to the transaction-bearing CAMS/KFintech type versus the no-transaction NSDL/CDSL type. It also signals that password is commonly required, reinforcing the schema's password hint.

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 — parse a consolidated account statement PDF — and explicitly enumerates the two handled statement types with their characteristics. It is clearly distinct from sibling analysis tools by framing this as the raw parsing step rather than portfolio analysis.

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 states when this is the only route (investor mutual fund holdings) and explicitly names the alternatives that do not cover it (INDstocks for equity/F&O/currency, AMFI for NAVs only). The kind detection also tells the agent it does not need to decide which parser to invoke.

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 transparency burden and meets it well: it discloses token lifetime, no-restart activation, server-derived TOTP behavior, transcript exposure of a passed MPIN, and revocation of any existing TOTP-issued token. This gives the agent a clear view of side effects before 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?

The description is dense but efficient: the core action and immediate effect are front-loaded, and every subsequent sentence contributes distinct operational information. There is no filler or redundant restating 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?

For a two-parameter tool with no output schema and no annotations, the description covers prerequisites, authentication modes, side effects, and security considerations. The only omitted detail is exact return formatting, but that is self-evident for a refresh action and does not block correct invocation.

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

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

Although the schema already describes both parameters, the description adds meaningful conditional semantics: if INDSTOCKS_TOTP_SECRET is set, no arguments are needed; otherwise a six-digit code is expected. It also connects the mpin parameter to a privacy trade-off, helping the agent decide whether to pass it or rely on the environment.

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: 'Generate a fresh INDstocks access token', and clearly states the immediate effect: 'start using it immediately'. None of the sibling tools concern token management, so the purpose is unambiguous.

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

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

The description explicitly identifies the trigger condition: 24-hour token expiry causing every other tool to fail. It also gives conditional guidance on when no arguments are needed versus when a TOTP code is required, and warns against passing an MPIN when environment credentials are available.

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

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

No annotations are provided, so the description carries the full burden. It discloses the core mapping behavior and the prerequisite relationship to quote lookups, but omits detail about ambiguity handling, pagination, limit behavior, or whether the operation is read-only. This is adequate but leaves behavioral gaps.

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

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

The description is two sentences, front-loaded with the core purpose and an illustrative example. Every word contributes meaning, and there is no redundant or filler content.

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

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

The description covers the essential purpose, when to call the tool, and the key return concepts (security_id, scrip code). With no output schema, it could more fully describe the return format or multiple-match behavior, but for a simple search tool the provided context is sufficient for an agent to use it correctly in the intended workflow.

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 67%: query and exchange have descriptions, while limit does not. The description adds helpful examples for query ('RELIANCE', 'HDFC Bank') but does not explain limit or exchange beyond what the schema already states. It provides moderate added value over 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 'Resolve' and clearly states the resource (human symbol or company name) and the output (numeric security_id and scrip code). It is distinct from siblings like search_mutual_funds and get_quotes because it focuses on resolving instruments to API-required identifiers.

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 instruction 'Call this before any quote lookup' gives clear contextual guidance on when to use the tool. However, it does not explicitly exclude alternatives or mention sibling tools like search_mutual_funds, so the routing guidance is strong but not fully comprehensive.

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

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

With no annotations provided, the description carries the full behavioral burden. It adds useful non-obvious facts: the tool requires no authentication, is free to use, and relies on AMFI's daily NAV feed. It does not disclose response format or matching semantics, 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?

The description is two tight sentences. The first sentence immediately states what the tool searches and how, and the second sentence adds high-value context about cost, authentication, and why this tool exists. Every clause 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 low-complexity search tool with only two parameters, the description covers the key operational context: data source, search dimensions, authentication, and cost. There is no output schema to document the return shape, and the description does not state what fields each result returns, which is a modest completeness 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 only 50%, since 'query' has an example but 'limit' has no descriptive text in the schema. The description compensates partially by specifying that query can match by mutual fund name or AMC, adding meaning beyond the raw parameter names. The limit parameter is still adequately explained by its schema type, default, and bounds.

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 ('Search'), a clear resource ('every Indian mutual fund scheme'), and two search dimensions ('by name or AMC'). It also identifies the data source (AMFI's daily NAV feed), which distinguishes it from sibling tools like search_instruments that cover a broader instrument space.

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 meaningful context: 'Free, no auth' removes a common access concern, and 'The INDstocks trading API does not cover mutual funds, so this fills that gap' clarifies when this tool is needed. It does not explicitly contrast this tool with sibling mutual-fund tools like get_funds or get_scheme_nav, but the search-by-name/AMC intent 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, the description carries the behavioral burden and does well: it discloses cache semantics, immediate return, zero rate-limit cost, and the meaning of stale ageMs. It does not cover error cases or what happens if no subscriptions exist, but the disclosed behavior is materially useful and non-obvious.

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 focused sentences with no filler. The core purpose is front-loaded, and the caveat about ageMs is a necessary, well-placed warning rather than extraneous 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?

The description is complete for a low-complexity one-parameter cache lookup, but there is no output schema and the description only names ageMs as a row field. It leaves the exact tick/price field names to inference, which is a meaningful gap for an agent needing to present a price.

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 optional scripCodes parameter is already fully documented. The description adds context about streamed instruments and ageMs but does not need to repeat the schema's parameter semantics.

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

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

The description states a specific verb ('Read') and resource ('streamed instrument'), and clarifies it is a cache lookup rather than a network call. This clearly distinguishes it from siblings like get_quotes and watch_prices without ambiguity.

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

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

The description gives clear context: this returns the most recent cached tick instantly and costs no rate limit, implying it is for quick cache reads rather than live fetches. It also advises checking ageMs before presenting prices, which is practical usage guidance, but it does not explicitly name alternatives or exclusions.

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

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

With no annotations, the description carries the transparency burden. It discloses that the subscription is standing/background, that nothing is pushed tick by tick, and that reads happen later via stream_quotes without consuming a REST rate-limit token. It does not mention how to cancel or whether resubscribing overwrites an existing stream, which is a moderate 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?

Three sentences, front-loaded with the core action, then behavioral expectation and use case. Every sentence adds distinct value 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?

The description covers the key invocation context, follow-up read path, and cost behavior despite having no output schema or annotations. It omits cancellation (stream_unsubscribe) and mode distinctions, but those are secondary to correct initial 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?

scripCodes is documented well in the schema, including example format and a pointer to search_instruments, but mode ('ltp' vs 'quote') has no semantic explanation in the schema or description. Schema description coverage is only 50%, and the description does not compensate for the undocumented mode parameter, leaving its meaning 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 uses a specific verb and resource: 'Open a standing subscription so prices keep updating in the background.' It clearly differentiates itself from stream_quotes by stating 'Nothing is returned tick by tick — call stream_quotes afterwards,' so an agent can tell what this tool does without opening the schema.

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

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

It gives a concrete use case: 'Useful when the same names come up repeatedly in one conversation,' and tells the agent to use stream_quotes afterwards. It does not spell out when not to use it or compare with get_quotes/watch_prices, but the guidance is enough to route a typical call.

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?

Since no annotations are provided, the description carries the full burden. It discloses the core effect (dropping standing subscriptions), the all-or-none behavior when scripCodes is omitted, and the consequence of letting the connection go idle. This goes beyond the schema and gives an agent useful side-effect awareness. It does not mention partial-drop behavior or permissions, but for a simple tool the important behavior is covered.

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

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

The description is a single, tightly worded sentence. The primary purpose is front-loaded, followed by the conditional behavior. Every word earns its place, with no repetition of the title or schema. This is exemplary conciseness.

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

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

Given the tool has one optional parameter, no output schema, and no nested objects, the description covers the main action and the important edge case of omitting scripCodes. It also adds the connection-idle consequence, which is relevant context for an agent. Missing details such as return value or connection state after partial drops are minor and do not undermine the ability to use the tool correctly.

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

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

The input schema fully documents scripCodes with the same 'Omit to unsubscribe everything' note, so baseline is 3. The description reinforces this and adds the connection-idle context, which is helpful but not essential to understanding the parameter itself. There is no meaningful semantic addition 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 and resource: 'Drop standing price subscriptions.' This clearly communicates the tool's action and scope, and the title 'Stop streaming prices' reinforces it. It distinguishes itself from siblings like stream_subscribe by the verb 'drop,' though it doesn't explicitly name the alternative. The purpose is unambiguous.

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

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

The description implies the tool is for ending price subscriptions, especially given the sibling stream_subscribe, but it does not explicitly state when to use it or mention alternatives. The instruction 'Omit scripCodes to drop all of them' is about parameter behavior, not about choosing between tools. This is adequate but relies on 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 clearly discloses that the call blocks for the requested duration and that instruments not already subscribed are unsubscribed afterwards. This goes beyond a basic summary and gives the agent important execution-time and side-effect awareness.

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

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

The description is three short sentences with no wasted words. It front-loads the core behavior, then adds a critical blocking warning and a cleanup guarantee. Each 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?

Given the lack of an output schema and annotations, the description covers the essential operational behavior: subscription, collection window, blocking, cleanup, and summary fields. It could be slightly more explicit about the exact returned series shape, but overall it is complete enough for an agent to invoke the tool correctly.

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

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

The input schema already documents all four parameters with 100% coverage, so the baseline is 3. The description adds useful context around seconds (blocking) and the summary output, but it does not need to repeat parameter meanings already present 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 clearly states a specific action sequence: subscribe to the live price feed, collect ticks for a duration, then return a series with per-instrument summary fields. It also differentiates this tool from the sibling stream_* tools by emphasizing the fixed-window, one-shot nature and the cleanup behavior.

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 useful context, such as 'This blocks for the requested duration, so keep it short,' and explains the unsubscribe behavior. However, it does not explicitly state when to choose this tool over stream_subscribe, stream_quotes, or get_quotes, so usage guidance is implied rather than explicit.

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