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

With no annotations, the description carries the behavioral burden. It explicitly discloses that the tool is read-only and fails closed on truncated history, which are meaningful behavioral traits. However, it does not cover other behaviors such as authorization requirements, rate limits, or output format.

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

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

The description is two tight sentences with no filler. The core action is front-loaded, and the safety note is placed immediately after, making it easy to parse quickly.

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

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

Given 8 parameters, no output schema, no annotations, and a large sibling toolset, the description is too sparse. It gives the tool's essence but not enough detail about parameters, return value, or how it relates to other account-level Avanza tools.

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

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

Schema description coverage is only 25%, so the description must compensate for undocumented parameters. It loosely maps 'one account' to account_id and 'modeled FX removed' to fx_fee_rate, but leaves period, start_date, include_daily, top_cost_days, and session parameters effectively unexplained.

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 ('Replay') and resource ('one account's Avanza cash-flow-adjusted return') with concrete modifications ('posted commission and modeled FX removed'). It is clear about the tool's function, though it does not explicitly differentiate itself from sibling attribution/performance 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 no guidance on when to use this tool versus alternatives like avanza_account_performance or avanza_frozen_holdings_attribution. The fail-closed note hints at a constraint, but no explicit when-to-use or when-not-to-use 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 provided, the description carries the behavioral burden. It explicitly says 'Read', making the non-mutating nature clear, and reveals useful stateful behavior: the account may come from a prior selection or be supplied directly. It does not disclose session/auth prerequisites, error behavior, or output shape, but the core read-only behavior is present.

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

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

The description is one compact sentence that front-loads the verb and resource and contains no filler. The phrasing 'performance/development' is slightly awkward, but the structure is efficient and easy to scan.

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

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

For a tool with no annotations, no output schema, and four optional parameters, this description is thin. It does not describe what the performance output contains, what happens if neither a selected account nor an account_id is available, or whether session context is required. Given the large family of Avanza session and account tools, an agent would still need to infer several invocation 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 leaves account_id undocumented, and the description adds meaning by saying it can be 'selected or supplied', which clarifies that the parameter is optional when a selected account exists. It also confirms period is user-chosen, though it adds little beyond the schema's enum and default. Session parameters are already described in the schema, so the description only partially compensates for the low schema coverage.

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

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

The description states a clear verb ('Read') and a specific resource ('Avanza account performance/development'), and it identifies the controlling variables: account_id and period. It is clear enough to convey the tool's primary job, but it does not explicitly differentiate it from nearby account tools such as avanza_accounts or avanza_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 implies when the tool should be used: to retrieve account-level performance over a period. It also gives one useful practical rule: account_id can be the currently selected account or an explicitly supplied ID. However, it does not state exclusions, prerequisites, or alternatives among the many Avanza sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the key trait that results are scoped by what is 'currently visible to the authenticated TUI session,' which is genuinely useful and non-obvious. However, it does not state what happens when no session is authenticated, whether the operation is read-only, or anything about the return structure.

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

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

A single 10-word sentence with zero filler. The verb and resource are front-loaded, and the scoping constraint is delivered immediately rather than buried in later clauses. Every word earns its place.

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

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

For a simple list tool with two optional parameters and no output schema, the description is almost sufficient, but it leaves gaps: it does not describe the expected return shape (list of account IDs, names, types?), nor behavior when no authenticated session exists. Given zero annotations and no output schema, some expectation-setting about failure modes would round 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?

Schema coverage is 50%, with tenant_session_id documented in the schema while session_id is not. The phrase 'authenticated TUI session' indirectly gives meaning to session_id by tying it to the session whose account visibility is being listed, adding some value beyond the bare property name. However, the description does not directly explain either parameter or their optionality, so it only partially compensates for the coverage gap.

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

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

The description states a specific verb ('List') and resource ('Avanza accounts') with a scoping qualifier ('currently visible to the authenticated TUI session'). This clearly distinguishes it from siblings like avanza_select_account and avanza_account_performance, though it does not name them explicitly. The only shortfall is the lack of an explicit sibling differentiation 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 avanza_select_account or avanza_account_performance. The session-scoping phrase obliquely implies it is for enumerating session-visible accounts, but there are no explicit when/when-not conditions or alternative routing. An agent would have to infer the intended use case from the name alone.

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

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

With no annotations, the description carries the full burden of explaining behavior. It communicates that this is a read-oriented reporting tool and names the consolidated categories returned, which is useful. However, it does not disclose the output shape, whether any session/live state is affected, or whether authorization 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?

A single, front-loaded sentence with no filler. The main purpose comes first, followed by parenthetical specifics that clarify scope without bloating the text.

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 status-reporting tool with only optional session-scope parameters and no output schema, the description adequately summarizes the returned concept areas. It could be more complete by detailing the status values or whether live and paper contexts are both covered, but the core invocation context is clear.

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

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

The input schema documents both parameters completely, including the legacy alias relationship and multi-session routing intent. The description adds no parameter-level insight, so the baseline score of 3 applies.

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

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

The description clearly identifies a specific action ('Return consolidated... status') and resource ('MCP safety/capability status'), with useful subcategories: paper/live guards, account context, and tool availability. It is clear enough to distinguish from most siblings, though it does not explicitly contrast itself with avanza_status or other status-like tools.

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

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

The phrase 'for automation loops' implies target usage, but the description does not explicitly say when to prefer this tool over avanza_status, data_source_status, or tv_auth_session_status. There are no stated exclusions or alternative routing conditions.

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

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

No annotations are provided, so the description carries the burden. It does disclose the conservative-assumptions behavior when exact class data is unavailable, but it does not mention side effects, whether it fetches live data, or how the estimate output is structured.

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

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

The description is a single front-loaded sentence with no filler. It communicates the core purpose immediately and the parenthetical adds a useful caution without bloating the text.

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

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

With 10 parameters, no output schema, and no annotations, one sentence is insufficient. The description leaves the agent uninformed about return values, parameter relationships, session/account context, and what 'break-even move' means operationally.

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

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

Schema description coverage is only 20% across 10 parameters, and the description does not compensate. It gives no semantics for required fields like account_id, orderbook_id, side, price, or quantity, and does not explain how market, currency, or brokerage_class affect the estimate.

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 ('estimate'), a concrete resource ('courtage/FX costs and break-even move'), and a clear context ('planned trade'). It is distinguishable from execution and post-trade attribution tools, 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?

'For a planned trade' provides a clear use context, and the parenthetical hints at when conservative assumptions apply. However, it does not explicitly say when to prefer this tool over alternatives or when not to use it.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It clearly states the operation is read-only and that it fails closed on missing history or unsupported cash events, which is valuable safety-relevant context. It does not elaborate on other behaviors such as output format or authentication requirements, but the key safety and failure semantics are disclosed.

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

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

The description is a single, dense sentence that front-loads the main purpose and then adds safety and failure behavior. Every phrase earns its place, and there is no redundant repetition of the tool name or schema fields.

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 there is no output schema, no annotations, and sparse parameter documentation, the description is not sufficient for an agent to confidently invoke the tool correctly. It would need more detail about how parameters affect behavior, what the return value looks like, and what conditions make it appropriate to 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?

Schema description coverage is only 33%, and the description does not explain the meaning of start_date, period, account_id, include_daily, or how they map to the reconstruction logic. The description's mention of prices, transactions, and cash events gives some context but does not compensate for the largely undocumented parameters.

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

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

The description states a specific verb ('Reconstruct'), a clear resource ('an account's frozen starting-holdings path'), and the inputs used (daily prices, transactions, cash events). It is distinct from most sibling tools, though it does not explicitly contrast itself with related attribution or portfolio tools such as avanza_account_cost_attribution.

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

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

There is no guidance about when to use this tool versus alternatives, no mention of prerequisites like requiring an active session or selected account, and no exclusion criteria. The description implies its use case but leaves the when-to-use decision entirely to the agent.

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

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

With no annotations, the description carries the disclosure burden. It clearly indicates a read operation (fetch) and the optional quote/spread enrichment, but it does not mention session/auth requirements, rate limits, pagination, or the structure of the returned data. Core behavior is transparent; deeper behavioral context is missing.

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

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

A single sentence that front-loads the action, states the defaults, and adds the use case. There is no filler or redundancy; every phrase contributes meaning.

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

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

This tool has no output schema and no annotations, so the description needs to explain return values and selector behavior. It neither describes what the returned constituents look like nor clarifies how index_id and index_name interact. An agent could invoke it with defaults but would be guessing about the output and index selection semantics.

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's mention of 'default OMXS30' and 'optional quote/spread enrichment' adds meaning for index_name, include_quotes, and include_spread. However, index_id is not explained at all, and the relationship or precedence between index_id and index_name is absent, so the compensation is incomplete.

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 ('Fetch index constituents') and resource, includes the default index (OMXS30), and mentions optional quote/spread enrichment. It is clear and distinct, though it does not explicitly differentiate from sibling tools like avanza_market_movers or avanza_search_stock.

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 'for building a liquid scalp universe' implies a use case, but there is no explicit guidance on when to use this tool versus alternatives, no when-not-to-use conditions, and no mention of related tools. The context is present but shallow.

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 behavioral burden. It does disclose that the tool is read-only and requires authentication, which is useful. However, it does not describe return shape, session behavior, data availability caveats, or how it behaves for different periods/resolutions, so transparency is only modest.

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

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

Two sentences with no filler: the first defines the operation and scope, the second adds safety and intent. Every phrase earns its place, and the most important information is front-loaded.

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

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

The tool has no output schema and no annotations, and the description omits detailed return-value information and any caveats about sessions or data availability. Still, 'OHLC history' combined with the schema's enums and defaults provides enough basic context for an agent to make a plausible call; it is adequate but not fully complete.

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

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

Schema description coverage is only 40%, and the description adds no parameter-level meaning beyond implying that orderbook_id identifies the order book and period controls the history window. The parameter names and enums carry most of the meaning; undocumented semantics for orderbook_id, period, and resolution are not compensated for.

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 ('Read'), a specific resource ('Avanza OHLC history'), and a clear scope ('for one order book and period'). This makes it immediately distinguishable from chart-adjacent siblings such as avanza_instrument_state, avanza_instrument_transactions, or avanza_realtime_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 frames the intended context: authenticated historical OHLC data for auditable performance and counterfactual analysis. It does not explicitly list alternatives or exclusions, but the use-case framing strongly implies this is the historical-data tool rather than the real-time or state-oriented ones.

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 'Read' does convey a non-mutating operation, and 'optional raw payload diagnostics' discloses that output may include raw payloads. However, it does not explain behaviors tied to refresh, compact, include_raw's default, or what 'diagnostics' actually contains, and it does not clarify that this excludes stoploss orders beyond the word 'regular'.

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 well-structured sentence with zero filler. The core purpose is front-loaded, and the optional diagnostics behavior is appended as a secondary clause. 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?

This is an 11-parameter tool with no output schema, no annotations, and no title, yet the description does not explain return values, parameter interactions, or the relationship to overlapping siblings. The alias parameters, status values, and the compact/refresh/include_raw interplay are all left to the agent to discover, making the description inadequate for reliable invocation.

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

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

Schema description coverage is only 18%, so the description must compensate for 9 undocumented parameters. It adds meaning for account_id/orderbook_id ('one instrument/account') and include_raw ('raw payload diagnostics'), but leaves side, status, compact, refresh, order_book_id, and instrument_name semantically unexplained. The orderbook_id vs order_book_id alias relationship is not clarified, and status is a free string with no value hints.

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

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

States a specific verb ('Read'), a resource ('open/pending regular orders'), and a scope ('one instrument/account'). The qualifier 'regular' helps distinguish from stoploss siblings, and 'raw payload diagnostics' hints at the include_raw behavior. However, it does not explicitly differentiate from near-identical siblings like avanza_open_orders, avanza_open_orders_raw, and avanza_ongoing_orders.

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 when-to-use or when-not-to-use guidance is provided, and no alternatives are named. Given a sibling list containing avanza_open_orders, avanza_open_orders_raw, and avanza_ongoing_orders, an agent has no basis for choosing this tool over those. The scope phrase 'one instrument/account' only weakly implies the per-instrument use case.

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 only says 'Read', implying a safe read operation, but does not disclose aggregation behavior, default include_raw=true, filter semantics, raw output behavior, or any side effects. For an 11-parameter tool this is a significant 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 names the core action and every major data category with zero filler. It is appropriately concise for a high-level tool summary.

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

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

Despite high complexity (11 parameters, no output schema, no annotations), the description provides only a high-level inventory. It does not explain return shape, how filters interact with the listed data groups, or how this relates to the many sibling tools.

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

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

Schema description coverage is only 18%, and the description adds no parameter-level meaning. It never explains account_id, orderbook_id, to/from/date ranges, changed_since, include_raw, or the transactions_from/to pair, leaving the agent unable to correctly construct queries.

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 verb ('Read') and a clearly bounded resource ('one instrument's ... state'), then enumerates the aggregated facets: quote, position, stops, open orders, transactions, and protection summary. This distinguishes it from narrower siblings like avanza_instrument_stoplosses and avanza_instrument_transactions.

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

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

No guidance is given on when to use this aggregate tool versus the many sibling tools that cover individual facets. The description implies a one-stop read for a single instrument but does not state exclusions, prerequisites, or alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Read', giving no detail on auth/session requirements, potential refresh/caching side effects, filter semantics, or what the returned rows contain. The presence of a 'refresh' parameter suggests a non-trivial behavior that is completely unexplained.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the action, resource, scope, and filters efficiently. While more detail would be useful elsewhere, the structure itself is ideal.

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 10 parameters, no output schema, and low schema coverage, the description is too sparse. It does not explain return shape, filter behavior, authentication/session expectations, or the effects of refresh and compact. It is minimally usable but leaves many important gaps for the agent to guess.

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

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

Schema description coverage is only 20%, and the description does not compensate. It identifies 'side/status filters' but does not explain allowed status values, the duplicate side enum casing, the meaning of compact/refresh, or the relationship between orderbook_id, order_book_id, and instrument_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 states a specific action ('Read'), a specific resource ('stop-loss rows'), and a clear scope ('one instrument/account') with optional filters. It is distinguishable from broader sibling tools like avanza_stoplosses, though it does not explicitly name the sibling it differs from.

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

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

The description provides clear context: this is for reading stop-loss rows scoped to a specific instrument/account, which implies it should be used when targeted data is needed rather than a portfolio-wide view. It does not explicitly name alternatives or exclusion conditions, but the scoping is strong enough to guide selection.

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

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

With no annotations, the description carries the full disclosure burden. Its word 'Read' signals a read-only operation, but it discloses nothing about the default executed_only=true filter (which hides pending orders), the side-effecting refresh parameter, the max_elements cap of 20000, or that 'recent' is adjustable via date parameters. These are behavioral traits beyond bare parameter names, and they are left unexplained.

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 12-word sentence with the verb and resource front-loaded and zero filler. Every word earns its place, and the key differentiator ('without dumping unrelated history') is packed efficiently into the same sentence.

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

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

For a 19-parameter tool with no annotations and no output schema, this description is far too sparse. It establishes scope and recency but omits default filter behavior, date-range semantics, the relationship between transactions_from/transactions_to and from/to, and the alternate order_book_id spelling, leaving agents to guess at most of the tool's behavior.

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

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

Schema description coverage is only 16% (3 of 19 parameters documented), so the description must compensate but barely does. It does add meaning to the two required scope parameters (account_id, orderbook_id) via 'one instrument/account', and 'recent' loosely hints at date filtering, yet 16 parameters including side, status, compact, refresh, executed_only, and the duplicate order_book_id spelling remain undocumented in both schema and 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 uses a clear verb ('Read') and a specific scoped resource ('transactions for one instrument/account'), and 'without dumping unrelated history' implicitly differentiates it from the broader avanza_transactions sibling. It falls short of 5 because 'instrument/account' is ambiguous about whether both identifiers are needed, and the schema shows both account_id and orderbook_id are required.

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

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

The phrase 'without dumping unrelated history' implies this tool is for scoped reads rather than full transaction dumps, which hints at a contrast with avanza_transactions. However, no alternative is named and no explicit when-to-use / when-not-to-use conditions are given, leaving the agent to infer selection among overlapping siblings like avanza_transactions, avanza_open_orders, avanza_ongoing_orders, and avanza_recent_fills_needing_protection.

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

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

With no annotations provided, the description carries the behavioral burden. It does disclose the core side effect (enabling live mutation permission) and preconditions, but it does not mention what happens on success, whether the permission persists, or how failures surface. This is adequate but not deeply transparent.

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

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

The description is two short sentences with no redundant phrasing. The core action and the critical prerequisite are front-loaded, making it easy for an agent to parse quickly.

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

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

Given the lack of output schema and annotations, the definition is somewhat thin. It explains what the tool does and its prerequisites, but it does not describe expected results, session-scope behavior, or edge cases around session_id/tenant_session_id. This is sufficient for a simple authorization gate, though more context 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?

The description adds important meaning by requiring acknowledge=true, which goes beyond the schema's default false. However, it does not clarify the purpose of reason or the relationship/session scoping details beyond what the schema already provides, leaving one parameter undocumented.

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 ('enable'), a clear resource ('live mutation permission'), and scopes it to the active MCP/TUI session. It is easily distinguishable from the sibling revoke tool and other session tools without requiring schema inspection.

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 by stating the required read_write mode and acknowledge=true prerequisite. It does not explicitly name the alternative (revoke) or state when not to use it, but the enabling action is unambiguous enough for an agent to select it correctly.

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

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

With no annotations, the description carries the burden of disclosing effects. It transparently states the state transition to paper-only mode, but does not mention reversibility, whether existing live orders are affected, whether the change is immediate, or what response the agent should expect. This is adequate but not rich behavioral disclosure for a mutation-like 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 tightly worded sentence with no filler. It front-loads the core action and immediately clarifies the resulting mode. Every word contributes meaning.

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

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

For a session control action with no output schema and no annotations, the description gives the essential effect but omits operational details such as session scoping behavior, reversibility, and post-call state confirmation. The schema covers parameters, but the description alone would leave an agent uncertain about side effects and how to verify success.

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

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

Schema description coverage is 100%, so the input schema already documents both parameters and the legacy alias relationship. The description does not add extra meaning about when to supply session_id or tenant_session_id, which is fine because the schema fully covers the semantics. 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 states a specific action, 'Disable live mutation permission for this MCP/TUI session and force paper-only mode,' which clearly identifies the resource and the outcome. This distinguishes it from the sibling avanza_live_session_authorize by being the inverse operation, and from paper-only tools by explicitly controlling live mutation permission.

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

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

The intended use is implied by the description: call this when you need to revoke live trading ability and switch the session to paper-only. However, it does not explicitly contrast with avanza_live_session_authorize or state conditions such as 'use this instead of X' or 'use when Y'. There is no exclusion guidance or prerequisite information.

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 disclosing behavior. It does indicate a read operation and implies repeated safe use via 'polling loops,' and it mentions payload-reduction behavior. But it does not disclose return contents, staleness, session/auth requirements, or error behavior, so transparency is only partial.

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 short and front-loads the core action and use case in a readable sentence. It earns its place but uses the somewhat vague phrase 'decision-ready' and could use that space to name the snapshot contents or key routing parameters.

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 10 optional parameters, no output schema, and no annotations, this description is too thin. An agent cannot determine what fields the snapshot contains, how instruments are selected, what refresh does, or how the various session/account/orderbook identifiers relate. The description leaves too much to inference.

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

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

Schema description coverage is only 20%, and the description does not compensate. It vaguely references 'compact instrument filtering,' which maps to compact and possibly instrument_name, but the other eight parameters—side, status, refresh, account_id, orderbook_id, order_book_id, session_id, and tenant_session_id—receive no semantic guidance.

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 clear action and resource: 'Read a decision-ready snapshot for polling loops.' It conveys that this is a read-only snapshot tool and gives a use case. It does not explicitly differentiate itself from sibling snapshot/quote tools such as avanza_realtime_quotes or avanza_orderbook_quotes, so it falls short of full clarity.

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

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

The phrase 'for polling loops' provides a clear context for when to use this tool, and 'compact instrument filtering to reduce payload size' gives concrete guidance for the compact option. However, it does not mention alternatives or when not to use this tool, despite the large sibling set.

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

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

There are no annotations, so the description carries the full behavioral burden. It only names the resource and filters. It does not disclose pagination, default limit, maximum limit, what the response payload is, whether movers are sorted by percent change or absolute change, or whether the endpoint can fail when no market data is available. This is too thin for a data-fetching tool with five optional parameters.

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 compact sentence with the core resource up front and the optional filters appended. No filler, no repetition of schema types, and every phrase adds some value. It is appropriately sized for a tool with only five parameters.

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 straightforward market-movers fetch with no required parameters, this is close to adequate: the agent knows what it returns and what knobs exist. However, it lacks any statement about default pagination or output fields, and it doesn't explain the semantics of each filter (especially 'turnover'). No output schema exists, so the description has more responsibility than it meets.

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

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

Schema description coverage is 0%, so the description must compensate for all five parameters. It names country/market/turnover filters, which maps to countryCodes, marketPlaces, and min_total_value_traded, and the phrase 'gainers/losers' implies limit and min_price are used for filtering the list. That said, the mapping is partial: 'turnover' is not self-explanatory as min_total_value_traded, and 'market' may be ambiguous with marketPlaces vs countryCodes.

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 a clear resource ('Avanza market movers (gainers/losers)'), which distinguishes it from most sibling tools focused on orders, positions, or pricing. However, it does not explicitly differentiate from other market-data siblings like avanza_index_constituents or avanza_search_stock, so it is clear but not fully differentiated.

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

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

The description implies usage context: use it when you need gainers/losers in a market, and the optional filters signal how to narrow results. But it gives no explicit guidance on when to prefer this over alternatives (e.g., avanza_index_constituents, tv_preopen_symbol_snapshot, or avanza_live_snapshot) and no exclusions.

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

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

With no annotations provided, the description carries the full burden, and it does add meaningful behavioral context by stating that the result combines live stop-losses, live open orders, and optionally paper active orders. However, it does not disclose what 'ongoing' excludes, how filters like side, status, compact, or refresh affect results, 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?

The description is a single, front-loaded sentence with no filler. It states the main purpose immediately and uses a colon to efficiently enumerate the components of the result.

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

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

For an 11-parameter tool with no output schema and no annotations, a one-sentence description is not enough. Missing context includes how account selection works, what the compact flag changes, when refresh matters, and what the returned order/stop-loss data looks like, so an agent would have to guess at most of the invocation details.

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

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

Schema description coverage is only 18%, and the description compensates for only two aspects: 'selected account' maps to account_id and 'optional paper active orders' maps to include_paper. The remaining nine parameters, including compact, refresh, orderbook_id/order_book_id, instrument_name, and status, receive no explanation in either the schema or the description.

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

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

The description names a specific verb ('List') and a concrete resource ('ongoing orders') and immediately disambiguates what that resource contains: live stop-losses plus live open orders, with optional paper active orders. This composition clearly separates it from sibling tools like avanza_open_orders and avanza_stoplosses.

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

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

No guidance is given about when to use this tool instead of avanza_open_orders, avanza_stoplosses, avanza_open_orders_raw, or avanza_paper_orders. The phrase 'selected account' implies account-level scope, but there are no explicit exclusions, prerequisites, or alternative-routing hints.

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

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

With no annotations present, the description must carry behavioral disclosure itself. It does so by explaining the dry-run vs live-cancel distinction and the R/W mode requirement. It does not mention idempotency, whether the dry-run returns a preview, or what failure modes exist, but for a cancellation tool the key behavioral risks are addressed.

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 deliver all necessary information with the core action front-loaded. There is no filler, and the alias and prerequisite are placed efficiently in the second sentence.

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

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

The description is adequate for selecting the tool but less complete for invoking it correctly in all cases. It omits how to discover order_id (e.g., via avanza_open_orders), does not distinguish paper vs live orders, and provides no return-value expectations. Still, the core conditions for live cancellation and the alias relationship are stated.

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

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

Schema description coverage is only 40%, so the description must compensate for undocumented parameters. It adds useful meaning for confirm (live cancellation requires confirm=true) and implies dry-run when false, but it does not explain account_id, order_id, or how to obtain a valid order_id. The required parameters are left to inference, which is a significant gap given the low schema coverage.

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

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

The description states a specific verb ('cancel'), the exact resource ('existing open/pending regular order'), and explicitly identifies itself as an alias of avanza_order_delete, which distinguishes it from the sibling tool. It is immediately clear what this tool acts on and how it relates to nearby alternatives.

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

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

The description gives concrete conditions for live use: 'TUI R/W mode and confirm=true'. It also makes the dry-run default evident. It does not explicitly name alternatives like avanza_paper_cancel or explain when to prefer them, but the alias note and regular-order qualifier provide enough routing context for most cases.

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

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

With no annotations provided, the description carries the behavioral burden. It transparently discloses that the tool can dry-run or live-update, that live updates mutate state, and that confirm=true plus TUI R/W mode are required for a real change. It does not describe return values or reversibility, but the core safety-relevant behavior is clearly stated.

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

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

Two dense sentences with no filler. The primary purpose and the critical confirmation requirement are front-loaded, and the alias note is concise and useful.

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

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

For an 8-parameter mutation tool with no annotations and no output schema, this description is too sparse. It omits expected formats for valid_until and price, what dry-run actually returns, likely error conditions, and post-update behavior. The agent would need to inspect sibling tools or external docs to call this correctly.

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

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

Schema description coverage is only 25%, and the description does not compensate for the undocumented fields. It usefully ties confirm to live updates, but leaves price, volume, and valid_until semantics unexplained, forcing the agent to guess formats and units.

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: 'update an existing open/pending regular order,' with a clear dry-run versus live-update distinction. It also states it is an alias of avanza_order_edit, which orients the agent, though it does not fully distinguish behavior from that sibling.

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

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

The description implies the tool is for editing existing open/pending orders and states the necessary condition for a live update: TUI R/W mode and confirm=true. However, it does not explicitly say when to prefer this over avanza_order_edit, avanza_order_set, or avanza_open_order_cancel.

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 communicates that the tool lists live data and returns stable IDs, and the verb 'List' implies a non-mutating operation. However, it does not disclose staleness/refresh behavior, session or account scope requirements, or behavior for empty results, so the transparency is only partial.

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 efficient sentence front-loads the verb and resource, then adds the filter options and the edit/cancel use case. There is no filler and no redundant restatement of the input schema.

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

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

The tool is relatively complex: 10 optional parameters, no output schema, no annotations, and a dense sibling list. The description covers the core listing purpose and filter options, but omits routing among raw/ongoing/instrument-scoped siblings, parameter semantics, and return behavior, so an agent cannot fully determine correct invocation 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 only 20%, covering just the two session-related parameters, so the description must compensate for the other eight. The description only mentions filters by instrument, side, or status, and leaves compact, refresh, account_id, orderbook_id/order_book_id, and session scoping unexplained. This is insufficient for a 10-parameter 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 opens with a specific verb, 'List', and a precise resource: 'live open/pending regular orders'. It also narrows scope with 'regular' and highlights 'stable IDs for edit/cancel flows', which separates it from siblings like avanza_open_orders_raw and avanza_instrument_open_orders.

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 'stable IDs for edit/cancel flows' implies when to use this tool: before editing or canceling an order. However, it does not explicitly route the agent away from sibling tools such as avanza_open_orders_raw, avanza_ongoing_orders, or avanza_instrument_open_orders, leaving some comparison to inference.

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

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

With no annotations provided, the description carries the full burden of disclosing side effects and safety. It reveals this is a debug/diagnostic read and that it returns both normalized and raw payloads, but it is silent on whether a session is required, whether refresh mutates state, the potential size of the raw payload, or any auth/rate-limit behavior.

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

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

The description is a single front-loaded sentence with no filler; 'Debug tool' immediately sets expectations. Every word contributes to identifying the tool's purpose and unique output.

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 11 optional parameters, no output schema, and no annotations, this one-sentence description is inadequate. It omits how parameters filter the orders, what 'schema diagnostics' means in practice, and how the raw payload should be handled. An agent would struggle to construct a correct first invocation.

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

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

Schema description coverage is only 18%, so the description must compensate for 11 parameters, but it mentions none of them. The term 'raw' hints at include_raw, but it is ambiguous whether raw is always returned or gated by the boolean. No meaning is added beyond the schema for side, status, compact, refresh, account_id, orderbook_id, or instrument_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 states a specific verb ('return'), a clear resource ('normalized open orders plus raw Avanza order payload'), and a distinct purpose ('schema diagnostics'). The 'Debug tool' label differentiates it from sibling tools like avanza_open_orders by signaling this is not the normal trading path.

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

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

There is no guidance on when to use this tool versus the many sibling order tools. No explicit alternatives, no conditions, and no exclusion like 'use avanza_open_orders for production calls'. The label 'Debug tool' weakly implies diagnostic usage, but that is not enough.

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

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

With no annotations, the description carries the burden. It discloses a key behavioral trait: it is snapshot-oriented and polling-friendly. However, it does not mention whether a live session is required, any rate limits, or what fields are returned, leaving important behavioral gaps for a no-annotation tool.

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

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

The description is a single sentence with no filler. The primary action and the most relevant usage constraint (polling loops) are front-loaded, making it easy for an agent to parse quickly.

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

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

Given zero schema descriptions, no annotations, and no output schema, the description leaves critical context unresolved: what fields can be requested, the effect of refresh, response format, and session/auth prerequisites. It is enough to attempt a call but not enough to configure parameters correctly or interpret results.

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

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

Schema description coverage is 0%, so the description must compensate for the three parameters. It only hints at 'orderbook_ids' and the 20-50 symbol scale; 'fields' and 'refresh' remain entirely unexplained, and no default or value semantics are clarified. The compensation is minimal.

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 resource ('quote snapshots for supplied orderbook IDs'), making the core action clear. It does not explicitly differentiate from siblings like avanza_realtime_quotes or avanza_live_snapshot, but the wording is specific enough to convey a batch snapshot operation.

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

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

The 'supports 5s polling loops for 20-50 symbols' clause gives concrete usage context, implying this is meant for repeated lightweight polling of a moderate set of orderbooks. It does not explicitly name alternatives or state when not to use it, but the polling support is a useful situational signal.

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 behavioral burden and clearly discloses the key destructive-operation gate: live deletion only happens with TUI R/W mode and confirm=true. It does not describe dry-run output or reversibility, but the essential safety behavior is communicated.

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

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

A single front-loaded sentence states the operation and the critical execution condition with no filler. Every phrase 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 destructive tool with no annotations and no output schema, the description covers the essential mode and confirmation behavior. It remains incomplete on what a dry-run returns, how ambiguous order targets are handled, and how this tool relates to sibling order/cancel tools.

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

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

Schema description coverage is only 40%, and account_id, order_id, and confirm have no schema documentation. The description adds meaning only to confirm in the live-deletion context, leaving the other core parameters to be inferred from names.

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 ('delete') and a specific resource ('regular open order') and introduces the dry-run mode. It does not explicitly contrast with related siblings such as avanza_open_order_cancel or avanza_stoploss_delete, so sibling differentiation is incomplete.

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 actionable usage conditions: live deletion requires TUI R/W mode and confirm=true, which also implies dry-run is the safe fallback. It does not name alternative tools or edge cases beyond the 'regular open order' scope.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses that the tool supports dry-run versus live update, that confirm=true gates the live update, and that TUI R/W mode is a prerequisite. This goes well beyond a bare 'edit order' statement, though it does not detail response behavior or failure modes.

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 dense sentence that front-loads the core action, then adds the critical condition for live execution. Every clause carries meaningful information; there is no filler or redundancy.

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

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

The definition covers the essential behavioral modes and prerequisites despite lacking annotations and an output schema. It does not describe return values or error conditions, but for selecting and invoking the tool, the required parameters and the dry-run/live distinction are sufficiently 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?

Schema description coverage is only 25%, but the description compensates for the key editable fields by naming price/volume/valid_until and explaining confirm's role in switching from dry-run to live update. However, account_id and order_id semantics are left implicit, and valid_until's format is unspecified.

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 edits an existing open order's price/volume/valid_until, and distinguishes 'dry-run' from 'live update'. The phrase 'existing open order' differentiates it from siblings like avanza_order_set (creating orders) and avanza_open_order_cancel/avanza_order_delete (removing orders).

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 context: this is for editing existing open orders, and live execution requires TUI R/W mode plus confirm=true. It does not explicitly name alternative tools for exclusion, but the intended use case is clear enough for an agent to route correctly.

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

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

With no annotations, the description carries the behavioral disclosure burden. It reveals a critical safety gate for live orders: R/W mode plus confirm=true. But it does not describe what a dry-run returns, what happens on validation failure, or other execution-side behaviors.

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

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

Two dense sentences, front-loaded with the primary purpose and followed by the essential safety condition. There is no filler or repetition of schema content.

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

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

For a 10-parameter mutating order tool with no annotations and no output schema, this is incomplete. It omits dry-run output behavior, valid_until format, and routing guidance to the paper-trading sibling avanza_paper_order_set.

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

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

Schema description coverage is only 20%, so the description must compensate for the undocumented required parameters. It clarifies confirm's role and order side, but leaves account_id, order_book_id, price, valid_until, volume, and condition without added meaning.

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

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

The description states a clear verb and resource: dry-run or place a regular buy/sell order. It is specific enough to distinguish it from stoploss and order-management siblings, though it does not explicitly differentiate from avanza_paper_order_set.

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

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

It provides actionable context: dry-run is available generally, while live placement requires TUI R/W mode and confirm=true. However, it does not explicitly state when to prefer this tool over alternatives such as avanza_paper_order_set or avanza_order_edit.

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

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

The description discloses that the operation never changes Avanza and is safe in read-only mode, which is important behavioral context beyond the schema. With no annotations present, it carries the burden and does so well, though it omits details about failure behavior or return values.

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

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

Two short sentences, front-loaded purpose and then the read-only safety note; no fluff.

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

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

For a single-parameter local cancellation tool, the description covers purpose, scope, and side-effect profile in just two sentences. It lacks an explicit return-value description and prerequisites, but given the low complexity and absence of output schema, it is adequately 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 only parameter, paper_order_id, has no schema description (0% coverage), but the description's phrase 'local paper order' clarifies that the ID identifies an order in the local paper-trading system, adding context beyond the bare schema. Still, no explicit guidance about where to obtain the ID is provided.

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

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

States a specific verb ('Cancel'), a specific resource ('local paper order'), and clarifies its scope as local/paper, distinguishing it from real-order cancellation tools like avanza_open_order_cancel and avanza_order_delete.

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

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

Explicitly frames the tool as canceling a local paper order and notes it is allowed in MCP read-only mode, signaling when it is appropriate. It does not explicitly name sibling cancellation tools, but the 'local paper order' phrase provides a clear usage context.

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

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

With no annotations provided, the description carries the full burden and does disclose a meaningful non-obvious side effect: the call creates a completed paper trade entry, not just a position close. But it is silent on whether both identifiers can be supplied, which takes precedence, prerequisites like an existing open position, error behavior, or reversibility.

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 dense sentence with the action front-loaded and zero filler. Every clause earns its place: the verb, the target, the identifier options, and the side effect.

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 mutating financial tool with no annotations, no output schema, and 0% parameter documentation, the description leaves critical gaps: the meaning of exit_price, which identifier to prefer, what the completed trade entry contains, and what happens on failure. It is not complete enough for safe, correct invocation without additional lookup.

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

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

Schema description coverage is 0%, so the description must compensate. It explains only position_id and orderbook_id, while the two required parameters, account_id and exit_price, are entirely unexplained, along with exit_reason, session_id, and tenant_session_id. An agent cannot tell what exit_price represents or why account_id is mandatory.

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 (close), a precise resource (open paper position), and a stated targeting mechanism (by position_id or orderbook_id), plus a side effect (create a completed paper trade entry). It clearly distinguishes this exit action from siblings like avanza_paper_cancel (cancel) and avanza_order_delete (delete).

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

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

The description implies the use context: it closes an open paper position and offers two identifier paths (position_id or orderbook_id). However, it never explicitly states when to prefer this over alternatives like avanza_paper_cancel, nor does it give exclusions or conditions such as 'only for open paper positions.'

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

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

With no annotations, the description must carry behavioral disclosure, and it only says 'List', implying a read-only operation, and 'local paper-trading', hinting this does not hit live order state. It does not disclose the effect of active_only, how account selection resolves, or whether any state is modified. This is below the bar for an unaided description.

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 definition is one front-loaded sentence with no filler: 'List' comes first, the resource and account scope follow immediately. It earns a high mark for efficiency even though it omits details captured under other dimensions.

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

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

The tool is simple, but without annotations or an output schema, the description leaves important gaps: active_only is undefined, 'events' is not explained, and there are many sibling paper/order tools that this description does not disambiguate. It is minimally sufficient for a simple list call but not complete enough for confident selection.

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 prose must explain parameters. It addresses account_id ('or a supplied account_id') but says nothing about active_only or its default false value. The meaning of account_id when omitted is only implied via 'selected account'.

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 a concrete resource ('local paper-trading orders and events'), and it clarifies account selection. It is not a tautology and is distinguishable from real-order tools. However, 'events' is vague and it does not explicitly separate this from closely related paper_* siblings, so it stops short of a 5.

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

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

It gives a clear usage context: the tool can run against the currently selected account or an explicit account_id. There is no when-not-to-use guidance or named alternatives among the many paper_* read tools (e.g., avanza_paper_trades, avanza_paper_positions). Usage 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 provided, the description carries the full burden of behavioral disclosure. It clearly states that no Avanza order is placed and that the operation is allowed in MCP read-only mode, which is a critical safety trait. It does not describe local state persistence, validation behavior, or order lifecycle, so it is not a 5.

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

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

Two sentences with no filler. The core action is front-loaded, and the most important safety distinction—'never places an Avanza order'—appears in the second sentence with maximum clarity.

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

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

For a 14-parameter tool with no output schema and no parameter documentation, this description is too thin. It provides useful safety context but leaves the agent to infer required field formats, how paper orders are handled, how this relates to paper exits/stoplosses, and what a successful call returns.

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

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

Schema description coverage is 0%, and the description adds no parameter-level meaning. The phrase 'buy/sell' hints at order_type, but the agent gets no help with price, volume, valid_until, stop_price, target_price, session_id, condition, or fill_immediately.

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

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

The description states a specific verb and resource: 'Create a local paper buy/sell order.' It also explicitly distinguishes itself from real-order tools like avanza_order_set by saying 'This never places an Avanza order,' and it is clearly distinct from paper stoploss and paper exit siblings.

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

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

The description gives clear context: use this for local paper orders, not live Avanza orders, and it is safe in MCP read-only mode. However, it does not explicitly name the live-order alternative or state when not to use it beyond the 'never places an Avanza order' exclusion.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a listing operation, but does not mention whether session/account selection is required, what data is returned, whether any state changes occur, or any error conditions. For a tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single sentence with no filler. It front-loads the verb and resource, then adds the key optional qualifier about active-only filtering. Every word earns its place.

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

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

For a tool with 4 optional parameters, no output schema, no annotations, and many related sibling tools, this description is too thin. It omits parameter semantics, expected return shape, prerequisite session/account selection behavior, and any guidance on how this relates to the broader paper-trading tool family.

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

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

Schema description coverage is 0% and the description only adds meaning for 'active_only' via the phrase 'optional active-only filter'. The parameters account_id, session_id, and tenant_session_id remain unexplained in both schema and description, so the description does not adequately compensate for the lack of schema documentation.

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

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

The description clearly identifies the action ('List'), the resource ('paper positions'), and the scope ('for a selected account/session'). It is immediately distinguishable from siblings like avanza_position or avanza_paper_trades because it specifically targets paper 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 phrase 'for a selected account/session' implies a prerequisite of account/session selection, but the description does not explicitly state when to use this tool versus alternatives such as avanza_position for live positions or avanza_paper_trades for trade history. Usage context is implied, not explicit.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior, but it only says 'Evaluate guardrails.' It does not state whether the tool is read-only, what it returns, how the guardrail result is represented, or whether calling it affects session state. This leaves significant behavioral ambiguity for an agent deciding how to use the result.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the core purpose and timing in as few words as possible while remaining clear.

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 eight parameters, no output schema, and no annotations, the description is too thin. It does not explain what the returned evaluation looks like, how an agent should interpret pass/fail conditions, or what side effects (if any) the call has. This leaves important operational context missing.

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

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

Schema description coverage is 0%, and the description adds no parameter-level meaning. While the parameter names and defaults are mostly self-explanatory, the relationship between account_id, session_id, and tenant_session_id is ambiguous, and the description does not clarify which of these are required or how the limit parameters interact.

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 ('Evaluate'), a specific resource ('paper-session guardrails'), and the timing ('before allowing a new trade entry'). This clearly distinguishes the tool from paper-order execution and session summary tools, though it does not explicitly name a sibling as an alternative.

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

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

The phrase 'before allowing a new trade entry' gives clear contextual guidance on when this tool should be invoked. It implies this is a pre-trade gate rather than a post-trade reporting tool, though it stops short of explicitly listing when-not-to-use cases or alternative tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies a read-only operation with 'Return', but does not explain how account_id, session_id, and tenant_session_id interact, whether a session must be active, or whether the summary covers current or historical data.

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

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

The description is a single sentence with no redundant words, and the main action is front-loaded. It is appropriately concise, though it omits essential 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?

With three undocumented optional parameters, no output schema, and no annotations, the description is far too sparse. An agent lacks the information needed to invoke the tool correctly or interpret its result.

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

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

Schema description coverage is 0% and the description does not clarify any of the three parameters. An agent cannot determine which identifier is needed or how they relate to a 'paper trading session/account'.

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 ('Return') and resource ('P/L summary for a paper trading session/account'), which distinguishes it from related paper-account tools like avanza_paper_trades or avanza_paper_positions. However, 'session/account' is ambiguous about whether the summary is for a session, an account, or both.

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

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

No guidance is given on when to use this tool versus alternatives such as avanza_paper_trades, avanza_paper_positions, avanza_sessions, or avanza_account_performance. There is also no mention of prerequisites like selecting a paper account or session first.

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

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

There are no annotations, so the description carries full responsibility for behavioral disclosure. It clearly discloses the key behavior that no Avanza order is placed and that the tool is safe in read-only mode. It does not elaborate on persistence, cancellation, or side effects of repeated calls, but the most important safety trait is explicit.

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 short, front-loaded, and contains no filler. Both sentences earn their place by stating the core purpose and the critical no-real-order constraint. It is arguably too terse for such a complex parameter set, but as a structural matter it is clean and direct.

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

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

For a 16-parameter tool with no annotations, no output schema, and zero schema description coverage, this description is far too minimal. It establishes high-level purpose and safety but leaves essential context unexplained, such as the meaning of strategy_intent values, how trigger/price percentage types work, what 'local' implies for persistence, and what the tool returns.

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

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

Schema description coverage is 0% and the tool has 16 parameters, yet the description provides no parameter-level guidance. Required fields such as strategy_intent, trigger_value, order_price, and order_price_type are left entirely to the schema, and the description does not explain their meaning, defaults, or relationships.

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: 'Create a local paper stop-loss order.' It clearly distinguishes this from real Avanza orders by stating 'This never places an Avanza order,' which separates it from sibling tools like avanza_stoploss_set and avanza_order_set.

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

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

The description provides clear context by positioning the tool as a paper-only, local operation and explicitly notes it is allowed in MCP read-only mode. It does not name alternatives or explicitly list when-not-to-use cases, but the paper/local framing strongly implies the boundary against real order placement.

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 word 'List' implies a read-only operation, and 'completed paper trades' communicates that only closed/fully paired trades are returned. However, with no annotations, the description carries the full burden and does not mention authorization needs, failure behavior, or whether an active session/account 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?

A single concise sentence that front-loads the action and resource. Every word adds meaning without redundancy.

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

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

The tool has no annotations and no output schema, and its parameters are undocumented. The description covers the core function but omits necessary context about parameter usage, authorization prerequisites, and edge cases, making it insufficiently complete for confident invocation.

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

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

Schema description coverage is 0%, so the description must compensate, but it only vaguely references 'account/session'. It does not explain account_id, session_id, or tenant_session_id individually, nor their optionality or relationships. This leaves an agent guessing how to populate the parameters correctly.

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

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

The description uses a specific verb ('List') and resource ('completed paper trades') and clarifies the data shape as 'entry+exit ledger rows'. This clearly distinguishes it from siblings like avanza_paper_orders, avanza_paper_positions, and avanza_paper_session_summary.

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 such as avanza_paper_orders or avanza_transactions. The phrase 'for account/session' implies a scoping requirement but does not explain when an agent should prefer this tool or when it should not be used.

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 says 'List,' which implies a read operation, but does not explain the meaning of side, status, compact, refresh, or orderbook_id parameters, nor what happens when no account_id is provided 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?

The description is a single concise sentence with no filler. It front-loads the core action and includes a meaningful optional qualifier, though it does not expand on important parameters.

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 10 parameters, no annotations, and no output schema, the description is too sparse to fully guide an agent. It lacks information about how the selected account is determined, what side/status/compact/refresh do, and what the returned portfolio position data looks like.

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

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

Schema description coverage is only 20%, so most of the 10 parameters are undocumented. The description adds minimal semantic value by mentioning account scope and optional filtering by one instrument, but it does not clarify the many unexplained fields or their relationships.

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 clear action and object: 'List portfolio positions for the selected account, optionally filtered by one instrument.' It conveys the verb, resource, and scope. However, it does not explicitly differentiate from siblings like avanza_position or avanza_paper_positions, leaving some ambiguity about live vs. paper context.

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 avanza_position or avanza_paper_positions. It implies a selected account is needed but does not state prerequisites, exclusions, or conditions that would route an agent to a sibling tool.

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

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

No annotations are provided, so the description carries the full burden. The word 'Read' and the scoping statement about not dumping the full portfolio convey that this is a safe, targeted read operation. But it does not disclose auth/session requirements, behavior when the position is not found, or any pagination/response details.

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

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

A single 12-word sentence with zero filler. The core action, resource, and distinguishing constraint are all front-loaded and immediately actionable.

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-position lookup, the description covers the essential 'what' and 'which'. However, with no output schema and no annotations, it omits return-format details, authentication/session prerequisites, and error behavior, which an agent might need to fully trust the invocation.

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

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

Schema description coverage is only 50%, and the two required parameters (account_id, orderbook_id) lack schema descriptions. The description clarifies that account_id identifies the account and orderbook_id identifies which position to read. The session-related parameters already have schema descriptions, so the description reasonably compensates for the gaps.

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

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

The description uses a specific verb ('Read'), names the exact resource ('one account position'), and identifies the lookup key ('orderbook_id'). The contrast with 'dumping the full portfolio' clearly distinguishes it from broader position tools like avanza_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 phrase 'without dumping the full portfolio' implies this tool is for targeted single-position lookups rather than full portfolio reads. However, it never explicitly names an alternative tool or states when not to use it, leaving some selection logic 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?

There are no annotations, so the description carries the full burden. It clearly states the tool is read-only at Avanza and explains the fail-closed behavior for missing/stale reviewed plans, contradictory protection classifications, and REPAIR_REQUIRED rows. It does not detail error modes, rate limits, or session authorization behavior, but the core behavioral traits are well disclosed.

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

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

The description is a single dense sentence with no filler. It front-loads the main action ('Refresh exact holdings...'), states the validation behavior, and closes with the read-only guarantee. 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?

The description gives strong behavioral context, especially the fail-closed criteria and read-only nature. However, there is no output schema and no description of the return value or result shape, and the session/account parameter semantics remain unresolved. For an audit tool with this complexity, a bit more about expected outputs and prerequisites would make it complete.

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

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

Schema description coverage is 0%, and the description only says 'for one account', which clarifies account_id at a high level. It provides no additional meaning for session_id or tenant_session_id, their relationship, format, or why they are optional. Since the schema itself has no parameter descriptions, the agent is left without sufficient guidance for the non-account parameters.

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

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

The description names a specific action, resource, and scope: refresh holdings, stop exposure, open orders, and stop-intent metadata for one account. It also differentiates itself from the sibling avanza_stoploss_strategy_audit by covering the broader position strategy and protection classification. The fail-closed clause further clarifies that this is a validation/audit tool, not a generic data fetch.

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 appropriate when an account-level position strategy audit is needed, and it mentions 'for one account' as the scope. However, it does not explicitly say when to prefer this tool over avanza_stoploss_strategy_audit, avanza_protection_gaps, or avanza_portfolio, nor does it list exclusions or prerequisites such as an authorized session.

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

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

With no annotations, the description carries the full safety burden and does it well: it discloses that the tool only mutates the private local registry, never Avanza, explains the confirm authorization boundary, and describes strict refusal behavior for stop/order or other mismatches plus the preservation flag semantics. It does not describe dry-run return shape or error behavior, but the disclosed behavioral traits are substantive and go well beyond the schema.

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

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

Four dense sentences, front-loaded with the core purpose and safety boundary. Each sentence introduces a distinct and necessary constraint, and there is no filler, though the heavy jargon around 'rebaselining a reviewed holding-only exception' slightly reduces immediate clarity for an agent.

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

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

For a batch registration tool with six top-level parameters, a very large item schema, no output schema, and no annotations, the description covers the most critical selection and safety decisions. It omits dry-run return semantics, prune_stale behavior, session parameter usage, and the specific difference from the stoploss registration sibling, so it is not fully complete for confident invocation.

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

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

Top-level schema description coverage is 0%, so the description must compensate. It adds real meaning to confirm (R/W auth requirement), preserve_audit_exception_fingerprint (update without rebaselining, refuses mismatches), and protection_classification/protection_reason (explicit per-row requirement). However, session_id, tenant_session_id, and prune_stale receive no explanation at all, so compensation is only partial.

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

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

The description states a specific verb and resource: 'register reviewed strategy plans for exact live account-position states' and clearly scopes it as local-registry-only, 'never Avanza.' It distinguishes itself from live order/stoploss mutators and audit siblings by emphasizing dry-run or atomic local registration, so an agent can tell what this tool does.

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

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

The description gives clear operational context: dry-run or commit behavior, confirm=true requiring MCP R/W but not live-trading authorization, and no Avanza side effects. However, it never explicitly tells an agent when to choose this over closely related siblings such as avanza_stoploss_strategy_register_batch or avanza_position_strategy_audit, so part of the selection decision is left to inference.

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

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

No annotations are present, so the description carries the full behavioral burden. It does disclose an important trait: it preserves current active SELL volume as the baseline and does not infer full-holding protection for core positions. However, it does not explicitly state whether the tool is read-only, what happens when optional overrides are supplied, or what the audit output 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?

The description is two sentences with no filler. The core purpose is front-loaded, and the default-baseline caveat is placed immediately after it, where it has the most value for an agent deciding whether to call the tool.

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

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

With no output schema, no annotations, and 8 parameters, the description is too thin to be complete. It does not describe the audit result shape, the effect of coverage_target_percent versus the default baseline, or any failure/safety behavior, so an agent cannot fully predict the tool's behavior from the definition alone.

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

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

Schema description coverage is only 50%, and the description does not compensate for the undocumented fields. It loosely ties 'strategy-classified SELL targets' to coverage_targets, but it says nothing about account_id, exclude_eth, exclude_orderbook_ids, or exclude_non_stop_eligible, leaving meaningful parameter semantics unexplained.

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 ('Audit') and names three concrete audit targets: strategy-classified SELL targets, failed SELL stops, and overcoverage. It also clarifies a distinguishing default behavior, making the tool easy to tell apart from sibling audit tools.

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

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

No guidance is given about when to use this tool versus related siblings such as avanza_stoploss_strategy_audit, avanza_verify_protection, or avanza_recent_fills_needing_protection. The default-behavior note explains how it operates, not when an agent should select it over 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?

No annotations are provided, so the description carries the full disclosure burden. It reveals the tool is a snapshot suitable for polling and hints that holdings must be 'selected', but it does not disclose authentication/session needs, rate-limit behavior, side effects, or failure modes. This is minimal for a real-time financial data 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 sentence with a front-loaded verb, a clear object, and a parenthetical polling tip. There is no filler, and every phrase 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?

With no output schema and no annotations, the description should explain what the snapshot contains, how account selection works, and how this tool differs from similar quote tools. It provides none of those, so an agent may know how to invoke it but not how to interpret results or choose it confidently among siblings.

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

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

Schema description coverage is 67%, with session_id and tenant_session_id described, but account_id has no schema description. The phrase 'selected account holdings' loosely implies account_id maps to an account, but it does not clarify optionality or how selection interacts with the parameter, so the description only partially compensates.

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 identifies a clear resource ('real-time quote snapshot for selected account holdings'), making the core action understandable. However, it does not differentiate from closely related siblings such as avanza_live_snapshot or avanza_orderbook_quotes, so it stops short of a 5.

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

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

The only usage guidance is 'best with a 5s polling loop', which provides a cadence but no explicit statement of when to use this tool versus alternative quote/orderbook tools. It implies a near-real-time monitoring use case but leaves selection among the many siblings 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 disclosure burden. It does reveal an important behavioral trait: BUY fills are not automatically assumed to need full-holding SELL stops, and missing coverage is only reported against explicit targets. It does not, however, state whether the operation is read-only, describe the output shape, or mention session/auth prerequisites.

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

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

The description is two sentences with no filler. The primary action and key behavioral caveat are front-loaded in the first sentence, and the reporting condition is placed in the second. Every phrase earns its place.

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

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

For a tool with seven parameters, no annotations, and no output schema, the description captures the core invocation policy but leaves gaps: output format, time-window semantics for 'since', account/session requirements, and routing against sibling protection tools are not addressed. It is minimally viable but not fully self-contained.

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

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

Schema coverage is 57%, leaving 'since', 'account_id', and 'exclude_eth' undocumented. The description reinforces the meaning of the two target-related parameters by tying missing-COVERAGE reporting to an explicit percentage or strategy-classified target, but it adds no meaning for the undocumented parameters.

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

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

The description states a specific action ('Review recent BUY fills') and a specific scope, then adds the distinguishing policy: it does not assume full-holding SELL stops and reports missing coverage only against explicit targets. This differentiates it from generic protection-gap or audit siblings even without naming them.

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

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

The wording implies when the tool is appropriate: it should be used when the caller has an explicit percentage or strategy-classified coverage target, and not as a default full-coverage audit. However, it does not name alternative tools or provide explicit when-not-to-use guidance, so the usage direction remains implicit.

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

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

With no annotations, the description itself discloses the key behavioral traits: read-only, fail-closed, flagging rather than recommending, and not treating thresholds as placement advice. It doesn't cover failure modes or session/auth requirements, but the core side-effect and safety profile is unusually explicit.

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

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

Two dense sentences front-load the safety profile and audit nature, then list the flagged conditions and end with the placement-advice caveat. Every clause contributes meaning 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?

The definition is adequate for an expert: it gives purpose, side-effect profile, and criteria. However, with no output schema and most parameters undocumented, an agent is left to infer the exact return shape, how account/session scoping works, and what fail-closed means operationally.

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%, so the description must compensate for undocumented parameters. It frames the numeric thresholds as audit-only limits and references the review-distance limit and reversal gliders, but it never explicitly maps those concepts to the parameter names, nor does it explain account_id's role.

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

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

The description names a specific verb and resource: a read-only audit of active BUY reachability, and then enumerates the exact conditions it flags. This distinguishes it clearly from order-execution and general status tools in the sibling list.

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

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

It establishes clear usage context as a fail-closed, read-only audit and explicitly warns that thresholds are not placement advice, which is a useful when-not boundary. It does not name alternative tools or state when to prefer this audit over related audit siblings, so it stops short of full routing guidance.

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

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

No annotations are provided, so the description carries the full burden of disclosing side effects and prerequisites. It does not state whether this is a read-only operation, whether current quotes require an active Avanza live session, or what happens on failure; 'load' is the only signal that it is non-mutating.

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

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

A single, front-loaded sentence with no filler; every phrase adds information about the operation or its optional behavior. This is appropriately concise for a two-parameter retrieval tool.

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

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

The description covers the core load-and-maybe-quotes behavior and is adequate for a simple getter, but with no output schema or annotations it leaves the return shape, prerequisite session/auth state, and failure semantics unstated. An agent can select the tool but may not know exactly what to expect from the response.

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

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

With 0% schema description coverage, the description at least maps watchlist_id to a named scalp watchlist and include_quotes to returning current quotes, which adds meaning beyond the bare type names. However, it gives no details on watchlist_id format/source or the precise behavior/limitations of the quotes inclusion.

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 concrete resource ('a named scalp watchlist'), a specific action ('load'), and the optional behavior of including quotes for all members. This makes it easy to tell apart from the sibling avanza_scalp_watchlist_set and from generic 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 phrase 'optionally include current quotes' gives some context for deciding on include_quotes, but the description never states when to prefer this tool over alternatives or when not to use it. The get/set sibling relationship is only implicit, so the agent must infer usage.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that this writes to local paper session state rather than live broker state and that the operation is an upsert ('Store/update'). However, it does not disclose whether an existing watchlist is fully replaced or merged, whether a paper session must be active, or what the function returns.

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

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

The description is one tight sentence with the action front-loaded. It contains no filler and each phrase adds meaningful context: action, resource, payload shape, and storage scope.

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

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

For a simple two-parameter local-state write tool, the description gives enough for an agent to make a correct call: what to store, where, and the required payload. The main omissions are replacement semantics and return behavior, but the tool's complexity is low and the sibling getter clarifies the overall 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 description coverage is 0%, but the description partially compensates: 'named scalp watchlist' maps to watchlist_id, and 'orderbook IDs + optional labels' maps to the items array. It does not explain orderbook_id format/source or the semantics of watchlist_id beyond being a name, so parameter understanding remains incomplete.

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 phrase ('Store/update') and names the exact resource: a named scalp watchlist containing orderbook IDs and optional labels. It also specifies the scope ('local paper session state'), clearly distinguishing this setter from the sibling avanza_scalp_watchlist_get.

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 as the write-side of a get/set watchlist pair, but it never explicitly names the sibling avanza_scalp_watchlist_get or states when not to use this tool. Some inference is required, which is a moderate gap.

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

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

With no annotations provided, the description carries the behavioral burden. 'Search' and 'data' indicate a read-only lookup and the identifier types define scope, but it does not disclose output shape, match behavior, or authentication prerequisites. This is adequate but thin.

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 short, front-loaded sentence that names the action, object, and acceptable inputs. There is no filler and no unnecessary 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 simple two-parameter search tool, the essential call details are present: the query semantics and the optional limit. However, with no output schema and no annotations, the agent is left to infer the return format and whether an active session is required, so completeness is only partial.

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 no property descriptions, so the description must clarify parameters. It clarifies that 'query' accepts a name, ticker, or ISIN, which is the critical semantic. The 'limit' parameter is not described but is already well-specified by the schema's default, minimum, and maximum.

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 resource ('Avanza stock/order book data'), and acceptable identifier types ('name, ticker, or ISIN'). This makes the tool's role clear even among many Avanza siblings, though it does not explicitly differentiate it from similar 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 identifier types imply a use case: when the agent needs to resolve a stock by name, ticker, or ISIN. However, the description does not mention alternatives or conditions for choosing another sibling, so usage guidance is only 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.