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

The description goes beyond annotations by spelling out the overwrite rule ('Same (symbol, date) overwrites the existing point') and the idempotency consequence ('passing the same input twice yields the same end state'). This aligns with idempotentHint=true and adds practical knowledge about effects on previously stored values. No contradiction with annotations.

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

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

The description is compact, front-loaded with the primary action, and each sentence adds a distinct fact: scope, endpoint, and repeated-call behavior. There is no filler or redundant 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?

Given the fully described input schema and presence of an output schema, the description covers the operation, scope, and repeated-call semantics. The MANUAL-only data source constraint is not in the description text but is covered in the schema, so nothing essential is missing. Explicit routing guidance versus read siblings would push this to a 5.

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

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

With 100% schema description coverage, the baseline is 3. The description adds meaning by establishing the (symbol, date) tuple as the uniqueness key and by clarifying that multiple market data points can be passed in one call. This semantic linkage goes beyond the schema's syntactic descriptions.

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

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

The opening sentence uses a specific verb ('Add') and resource ('market data points for a specific asset'), and the second sentence disambiguates the exact endpoint and keying ('symbol, date'). This clearly separates it from read-only siblings like get_market_data_for_asset.

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 writing/upserting market data points and notes that repeated calls are idempotent, but it never explicitly states when to prefer this tool over alternatives or when not to use it. No exclusions or alternative tool names are given, leaving routing mostly to the name and context.

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

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

Annotations already declare the tool as non-read-only, idempotent, and non-destructive, so the safety profile is covered. The description adds the 'user's watchlist' scope, which is useful context, but it does not disclose behavior such as what happens if the symbol already exists or whether the data_source must match an existing platform. This is acceptable given the annotations.

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

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

The description is a single, efficient sentence with no filler. The core action and target are front-loaded, making it immediately scannable for an agent. Nothing extraneous is included.

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 mutation tool, the description, combined with the schema, annotations, and presence of an output schema, provides enough context for correct invocation. The annotations cover idempotency and non-destructiveness, the schema fully documents parameters, and the output schema handles return-value expectations, so no critical information is missing.

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

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

The input schema already documents both parameters with clear descriptions and 100% coverage. The tool description adds no additional parameter-level meaning beyond the schema, so the baseline of 3 is appropriate. It does not clarify allowed values for data_source or any relationship between symbol and data_source, but the schema provides adequate 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 specific verb ('Add'), a specific resource ('symbol'), and the target context ('user's watchlist'). This clearly distinguishes it from sibling tools like get_watchlist and remove_from_watchlist, so an agent can identify the correct operation without ambiguity.

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

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

The description implies the use case: use this when the user wants to add a symbol to their watchlist. However, it does not explicitly mention alternatives or when not to use it, such as using remove_from_watchlist for removal or get_watchlist for viewing. Usage context is clear but not explicitly differentiated.

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

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

Annotations already signal that this is not read-only and not idempotent. The description adds valuable behavioral context beyond the annotations by explaining that Ghostfolio currently has no boolean 'excluded' flag on accounts, so agents should not expect to exclude accounts directly through this tool. This is a useful limitation disclosure that helps set expectations.

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 relatively short and front-loads the core purpose in the first sentence. It is slightly redundant because 'Create a new account' appears in both the first and second sentences, but the additional note is well-placed and earns its place by explaining a relevant version-specific limitation.

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 that the tool has an output schema, annotations, and 100% parameter documentation in the schema, the description is mostly complete. It covers purpose, typical use, and an important scope limitation. It does not discuss possible duplicate behavior or error conditions, but that is not critical given the rich structured data already available.

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

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

Schema description coverage is 100%, so every parameter already has a meaningful description. The tool description mentions name, currency, and optional balance, but adds no semantic detail beyond what the schema provides. This meets the baseline but does not elevate the parameter knowledge available to the agent.

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

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

The description clearly states the action and resource ('Create a new account in your portfolio') and mentions the key fields (name, currency, optional balance). While this is specific and unambiguous, it does not explicitly differentiate from the sibling create_account_balance; the distinction relies on the resource name rather than an explicit contrast.

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

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

The description gives a clear purpose ('useful for organizing your investments across different account types or platforms') and adds an explicit limitation: the tool cannot handle the 'excluded' flag because that is done via tagging outside this tool's scope. It stops short of naming alternative tools or when-not-to-use scenarios, but the context is sufficient for typical account-creation 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?

Annotations declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false; the description expands meaningfully on each. It explains the direct write side effect on balance history, the idempotent upsert behavior, the date omission default, and the currency limitation. No contradiction exists.

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

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

Three short, well-organized paragraphs front-load the core purpose, then cover side effects and a currency caveat. There is no filler; each sentence contributes operational knowledge an agent needs.

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 100%-covered schema, existing annotations, and output schema, the description covers the remaining operational essentials: which data it affects, idempotent update behavior, date semantics, and currency constraint. An agent has enough information to select and call this tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the currency context—recorded in the account's own currency with no separate currency accepted—and the semantic of omitting date to set today's balance, supplementing the schema's 'defaults to today.'

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 'Set an account's balance for a specific date in its balance history,' which gives a clear verb and resource. It further differentiates from read siblings by stating it writes directly to the balance-history series consumed by get_account_balances and get_portfolio_holdings, and explicitly says it is 'not the same as the account's summary balance field.'

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 tells the agent this is the write path for balance-history entries and contrasts it with the summary balance field, implying when not to use it. It also gives practical guidance: re-calling with the same account and date updates rather than duplicates, and omitting date targets today. It doesn't name a specific alternative like transfer_account_balance, but the context is sufficient.

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

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

Annotations already indicate readOnlyHint:false, idempotentHint:false, and destructiveHint:false, and the description's 'Create' is consistent with those settings. However, the description adds no additional behavioral context such as validation rules, permission requirements, or side effects on related entities, so it does not exceed the annotations' coverage in a meaningful way.

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 containing the key scoping word 'single' and no filler. It is appropriately minimal given the rich schema underneath.

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

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

The schema and output schema provide strong technical coverage for the 10-parameter create operation, so return-value documentation is unnecessary. However, the description omits usage context, especially when an agent should select create_activity over import_transactions, and does not mention any account-existence or symbol-resolution constraints.

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

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

Schema description coverage is 100%, with each of the 10 parameters already documented by name, type, required status, and default values. The description itself adds no parameter-level detail beyond the word 'transaction/activity', so the schema carries the full burden and the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Create') and resource ('single new transaction/activity'), clearly distinguishing it from read/list, update, and delete tools. It does not directly contrast with the batch-style sibling import_transactions, so it misses a bit of differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives such as import_transactions, nor does it mention any prerequisites or when not to use it. The sibling list implies alternatives exist, but the description itself leaves usage decisions 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?

Beyond the annotations' destructiveHint=true, the description adds meaningful behavioral detail: deleting the account may also delete associated transactions depending on backend rules. This warns the agent about side effects that the structured annotations don't specify.

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 the primary action front-loaded and the critical caveat placed right after. Every sentence earns its place with no redundant filler.

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

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

For a single-parameter destructive tool with an output schema and destructive/read-only annotations, the description covers purpose, target selection, and the key side effect. Nothing essential is missing for an agent to decide to call it.

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

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

Schema description coverage is 100%, with account_id already explained as the ID to delete and given an example. The description adds little beyond restating 'specified by its ID,' so the schema carries the semantic weight; a baseline 3 is appropriate.

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

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

The description clearly states the action and resource: 'Delete an existing account' specified by its ID, from the portfolio. It distinguishes the tool from sibling tools like delete_account_balance and delete_activity by naming the account as the target.

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

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

The description makes the intended use clear—deleting a portfolio account—and adds a caution about cascading transaction deletion. It doesn't explicitly name alternatives or say when not to use the tool, but the resource-specific phrasing and sibling names provide enough context.

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

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

Annotations already declare destructiveHint=true and readOnly=false. The description adds useful context by specifying the deleted object is a single balance-history entry, and the schema warns that the ID must come from get_account_balances rather than the account ID. No contradiction with annotations.

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

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

One focused sentence delivers the verb, object, and scope with no filler. The most important information is front-loaded.

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

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

For a simple one-parameter destructive tool with a well-documented schema, annotations, and output schema, this description is nearly complete. It could briefly mention permanence or explicitly route delete_account elsewhere, but the essential information for a correct call is present.

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

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

Schema coverage is 100%, and the parameter description already explains that balance_id is the ID of the balance-history entry, not the account ID. The tool description itself adds no parameter-level detail beyond what the schema already provides, so the baseline score 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?

States a specific verb ('Delete') and a precise resource ('a single entry from an account's balance history'). This clearly distinguishes it from sibling tools like delete_account, which would delete an entire account.

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

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

The phrase 'a single entry' implies this tool is for removing one balance-history record rather than an account or a batch of records. However, it does not explicitly mention alternatives or provide when-to-use/when-not-to-use guidance, leaving some routing to inference.

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

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

Annotations already communicate destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so the core safety profile is covered. The description adds the scope detail that exactly one activity is deleted, but it does not disclose irreversibility, side effects, or permission requirements beyond what annotations already provide.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes directly to understanding the tool's operation.

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

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

Given one required parameter fully described in the schema, an output schema present, and annotations marking the operation destructive, the description is sufficient for an agent to invoke the tool correctly. No additional invocation details appear necessary.

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

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

Schema description coverage is 100%, and the activity_id parameter is already documented as 'The unique ID of the activity to delete.' The description's phrase 'by its ID' adds no meaningful information beyond the schema, so it remains at the baseline for fully covered 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 uses a specific verb ('Delete'), names the exact resource ('activity/transaction'), and specifies the identification mechanism ('by its ID'). This clearly distinguishes it from sibling tools like delete_account, delete_account_balance, or remove_from_watchlist.

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

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

The description states what the tool does but gives no guidance on when to use it versus alternatives, and names no exclusions or conditions. There is no mention of bulk deletion, related cleanup, or when not to use this tool.

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

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

While annotations already set destructiveHint=true, the description adds important behavioral context: deleting the profile-data record may also delete associated activities and market data 'depending on backend rules'. This is genuinely useful beyond what the structured annotations convey.

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

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

The description is short and front-loads the core action, with a useful warning at the end. The opening sentence 'Delete an asset profile' is largely redundant with the title and with the second sentence, but this is a minor inefficiency.

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

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

For a two-parameter destructive operation with a fully documented schema and an output schema, the description provides sufficient context. It names the target record, the identifying parameters, and the potential cascading effects, making the tool safe to invoke.

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 parameters are already well documented in the input schema. The description only echoes 'given data source and symbol' and adds no new semantic detail about parameter formats or allowed values.

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

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

Description states a specific verb and resource ('Delete an asset profile', 'Removes the profile-data record') and names the exact identifying inputs (data source and symbol). It cleanly distinguishes this as the destructive counterpart to get_asset_profile and upsert_asset_profile.

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

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

The description explains what the tool does but gives no explicit guidance on when to use it versus alternatives such as get_asset_profile or upsert_asset_profile. It also does not state prerequisites or conditions that should be checked before deleting.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds that the output is JSON and that filtering is supported, but it does not reveal additional behavioral details such as pagination, result limits, or whether all matching transactions are returned at once.

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-loaded with the core purpose. The second sentence is slightly redundant with the first ('portfolio transactions' appears twice), but overall it is efficient and easy to parse.

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

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

Given the 100% schema description coverage, an output schema, and safe read-only annotations, the description is mostly sufficient. It clearly conveys the export/retrieval purpose and available filtering. It would benefit from naming alternatives or clarifying the export behavior, but nothing critical is missing for invoking the tool.

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

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

Schema description coverage is 100%, and every parameter already has a clear description in the schema. The description only adds that filters are optional, which is also evident from the default: null values. It does not add meaningful parameter semantics beyond the schema.

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

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

The description states a specific action ('Export portfolio activities/transactions data as JSON') and identifies the resource clearly. However, it does not explicitly differentiate itself from sibling tools like get_investments or get_portfolio_transactions, so it relies on the word 'export' and format emphasis to stand apart.

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

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

The description implies usage: use this when you need portfolio transaction data with optional query filters. But it provides no explicit guidance on when not to use it, nor does it mention alternatives such as get_investments or get_portfolio_details.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds only that balance history is included, but does not reveal additional behavioral details such as authentication requirements, data freshness, or response limitations.

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 mostly front-loaded, but the first sentence essentially repeats the tool name and title. The second sentence repeats 'specific account' while adding the useful balance fields, so the two sentences could be consolidated without loss.

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

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

Given the low complexity, one required parameter, rich annotations, and presence of an output schema, the description is adequate for correct invocation. It doesn't explain balance history semantics in depth, but the output schema likely covers return details.

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

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

Schema coverage is 100% and the only parameter, account_id, is already described as 'Account ID to get balances for.' The description's 'specific account' phrasing adds little beyond the schema, so the description does not carry extra parameter meaning.

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

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

The description clearly identifies a specific verb and resource: get account balances for a specific account. It also lists what is included (current balance, currency, balance history), which distinguishes it from general account listing tools, though it does not explicitly differentiate from get_account_details.

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 should be used when a specific account's balance information is needed. However, it provides no explicit when-not-to-use guidance or alternatives, leaving potential ambiguity with sibling tools like get_account_details.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds only the single-account scope and discloses no additional traits such as auth requirements, pagination, or response size caveats.

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

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

A single sentence with no filler, front-loading the operation. Slightly generic wording means it does not add much structural value beyond the title, but it is nonetheless concise.

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

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

Given the one required parameter, strong annotations, and presence of an output schema, this is mostly complete for invoking the tool. However, it does not disambiguate which 'details' are covered relative to sibling endpoints, so an agent may need to inspect schemas to choose 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 100%, so the input schema fully documents account_id. The description repeats that the account is specific but adds no format, validation, or value semantics beyond the schema.

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

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

The description uses a clear verb ('Get') and resource ('details for a specific account'). It accurately states what the tool does, but it does not explicitly distinguish it from sibling account endpoints such as get_accounts or get_portfolio_details.

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 prefer this tool over alternatives like get_account_balances, get_portfolio_details, or get_accounts. The phrase 'for a specific account' hints at scope, but the description does not state exclusions or decision rules.

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

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

Annotations already communicate readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds a small behavioral detail about the return shape ('Dictionary containing account information including accounts list and total value'), but does not disclose additional behaviors like pagination, rate limits, or authorization requirements.

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 first two sentences are near-duplicates: 'Get all accounts...' and 'Retrieves a list of all accounts...' restate the same scope and fields. Only the Returns line adds meaningful new information (total value). The description could be cut to one efficient sentence without losing substance.

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

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

For a zero-parameter, read-only list operation with an output schema and safety annotations, the description provides sufficient context: it covers what is returned and that it is portfolio-wide. The main gap is lack of explicit sibling differentiation, but that is not critical for invoking this tool correctly.

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

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

The tool has zero parameters and schema description coverage is 100%, so the baseline of 4 applies. There is nothing about parameters the description needs to compensate 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 clearly states a specific action ('Get all accounts') and resource ('your portfolio'), and lists the relevant fields (account types, balances, account-specific information). However, it does not explicitly distinguish itself from the sibling get_account_balances, so some differentiation is left to inference.

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 usage context is implied: use this when you need all accounts and their balances. But there is no explicit guidance about when to prefer get_account_balances or get_account_details instead, and no exclusions or alternative routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds that the tool returns company, sector, industry, and other metadata, which is useful context, but it does not disclose additional behavioral traits beyond what annotations already cover.

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 well-structured, with the core purpose stated early and supporting detail in the second sentence. The first sentence is slightly redundant with the tool name, but overall it is efficient with no unnecessary filler.

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

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

Given the simple two-parameter schema, full schema coverage, presence of an output schema, and read-only annotations, the description is largely sufficient for an agent to invoke the tool correctly. It could be more complete by addressing what happens when no profile exists for the symbol, but that is a minor gap.

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

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

Schema description coverage is 100%, with both 'symbol' and 'data_source' clearly documented and given examples. The description does not add meaningful parameter semantics beyond the schema, 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 states the verb 'Get' and the resource 'asset profile information' for a specific symbol, and elaborates with concrete content examples such as company information, sector, and industry. This distinguishes it from siblings like get_symbol_data, upsert_asset_profile, and delete_asset_profile.

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

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

The description implies usage when needing detailed profile metadata for a specific symbol, but it does not explicitly say when to use this tool over alternatives like get_symbol_data or lookup_symbols, nor does it state exclusions such as 'not for price history'. Guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description does not contradict them. However, the description adds no behavioral context beyond the schema, such as how filters interact, what happens with missing benchmark data, or any calculation nuances.

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 purpose and does not waste words, 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?

The output schema and full parameter descriptions cover the invocation details, and annotations cover safety. However, the description lacks usage differentiation and does not address the many optional filtering parameters or default date_range behavior, leaving the agent with some ambiguity.

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

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

Schema coverage is 100%, so the baseline is 3. The description references 'benchmark symbol' and 'specific date', which map to symbol and start_date, but it does not add any meaning beyond the schema's parameter descriptions.

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

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

The description clearly states a specific action ('Compare portfolio performance') and a specific resource ('benchmark symbol starting from a specific date'). It is distinct enough from sibling tools like get_portfolio_performance and get_benchmarks, though it does not explicitly name those 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?

No guidance is provided about when to use this tool versus sibling tools such as get_portfolio_performance or get_benchmarks. The description implies a benchmark comparison use case, but there are no explicit conditions, exclusions, or alternative routing.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds only that the return is a dictionary containing the benchmark list, which is mild extra context beyond annotations and does not contradict them.

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

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

The description is two short, focused sentences with the core purpose front-loaded and no filler or redundancy.

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

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

For a zero-parameter, read-only getter with an output schema and safety annotations, the description provides enough information to call the tool correctly. No critical behavioral or usage detail is missing for this simple case.

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

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

There are no parameters, so there is nothing for the description to clarify. Schema coverage is trivially 100%, matching the baseline of 4 for zero-parameter tools.

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

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

The description states a clear verb and resource ('Get all configured benchmarks') with scope ('all configured'). It does not explicitly contrast with the sibling get_benchmark_performance, so it stops short of full differentiation.

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

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

No guidance is given about when to use this tool versus alternatives like get_benchmark_performance. The intended use is implied by the name but not stated, and no exclusions or alternative references are provided.

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

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

Annotations already convey read-only, idempotent, non-destructive behavior. The description adds that results are grouped by time period and emphasize payments, yield, and income patterns, but this mostly restates schema semantics rather than revealing deeper behavioral traits like pagination, currency handling, or data sources.

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 but redundant: the second sentence largely paraphrases the first and adds only the vague phrase 'income patterns over time.' It is front-loaded, but not every sentence earns its place.

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

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

The output schema and comprehensive parameter descriptions cover most invocation needs. However, the description lacks guidance for choosing between get_dividends and the closely named sibling get_dividends_for_import, which is a meaningful completeness gap given the sibling 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 coverage is 100%, and both parameters have clear descriptions with defaults and allowed option lists. The description does not add meaningful details beyond the schema, 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 the resource (dividend data), the grouping behavior, and the output dimensions (payments, yield). It is distinct enough from the sibling get_dividends_for_import, though it does not explicitly call out any sibling or differentiation.

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

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

There is no guidance on when to use this tool versus alternatives such as get_dividends_for_import or other data retrieval tools. The description implies a reporting/analytics use case but never states exclusions or selection criteria.

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

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

Annotations already cover the read-only, idempotent safety profile, so the bar for extra behavioral disclosure is lower. The description adds 'historical' and 'formatted for import' as output-context clues, but it does not mention pagination, date-range limits, or data-source-specific 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?

A single sentence that front-loads the operation and its distinguishing output purpose. It contains no filler, no repetition of annotations, 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?

For a two-parameter read-only tool with full schema coverage and an output schema, this description is nearly sufficient. The main missing element is an explicit pointer to get_dividends to prevent selection confusion.

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 both required parameters are already documented. The phrase 'specific symbol' essentially restates the symbol parameter and adds no concrete guidance about symbol formats or data-source values.

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

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

The description clearly states the operation: fetching historical dividend data for a specific symbol, explicitly formatted for import. The 'for import' qualifier distinguishes it from the sibling get_dividends, though it never names that 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?

Usage is implied by the phrase 'for import' and the required symbol/data_source parameters, but the description does not explicitly state when to use this tool over get_dividends or import_transactions, nor does it provide when-not 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds some behavioral context by limiting the lookup to a specific symbol and date, but it does not disclose deeper traits such as the base currency or rate source. No contradiction with annotations exists.

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

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

The description is a single focused sentence with no filler or redundancy. It front-loads the operation and the two key constraints, making it immediately scannable 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 simple, read-only, two-parameter tool with a complete input schema, output schema, and safety annotations, the description is nearly complete. The only minor gap is that the base currency or rate direction is not stated, but the output schema likely resolves this and it does not prevent correct invocation.

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

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

Schema description coverage is 100%, and both 'symbol' and 'date' are fully documented in the input schema. The description only restates the parameters at a high level without adding format, constraints, or examples beyond what the schema already provides, so the baseline 3 applies.

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

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

The description uses a specific verb ('get') and names the resource ('exchange rate') with precise qualifiers: currency symbol and specific date. This clearly separates it from the sibling tools, none of which target exchange-rate retrieval.

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

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

The description implies the tool is used when you need a rate for a currency symbol on a particular date, but it does not explicitly state when to prefer it over sibling tools such as get_market_data or get_historical_data, nor does it mention exclusions. The context is clear but the guidance is not explicit enough for a 4.

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

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

The annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds minimal behavioral context beyond those annotations, such as that it retrieves backend service status and returns a dictionary. No contradictions or additional safety disclosures are 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 short and front-loaded, but the first sentence 'Get system health status.' largely repeats the tool title and the second sentence repeats the same idea ('Retrieves the health status'). Some redundancy means not every sentence fully 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 zero-parameter, read-only health-check tool with an output schema, the description covers what the tool does, why it might be used, and what it returns. It could mention availability or error behavior, but the output schema supplies return details and the annotations cover safety, so no critical information is missing.

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

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

The tool has zero parameters and the schema describes no inputs, so the baseline for this dimension is 4. The description adds no parameter details because none are needed, but it does mention the return shape, which is useful context.

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

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

The description names a specific resource ('health status of the Ghostfolio backend service') and a concrete purpose ('verify if the server is up and running correctly'). This clearly distinguishes it from the sibling tools, which all operate on accounts, orders, portfolio data, etc.

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

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

The description provides clear context for when to call this tool: to verify the server is running. It does not mention exclusions or alternative tools, but no sibling tool appears to offer a comparable health-check function, so the guidance is adequate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds only limited context about returned content ('price and volume information') and nothing about authentication, rate limits, or failure behavior. It does not contradict the annotations.

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

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

The definition is short, but the first and second sentences largely repeat each other. The second sentence adds only the price/volume detail, making the opening sentence redundant. It is acceptable but not tightly written.

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?

Core call requirements are covered by the input schema, output schema, and annotations. Missing are differentiation from close siblings and explicit edge-case guidance, such as historical date range limitations or data-source behavior. The definition is minimally complete but not fully contextual.

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 all three parameters. The description adds little beyond restating 'symbol' and 'date' generically, with no format, constraint, or source-selection guidance beyond the schema. This matches the baseline for high schema coverage.

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

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

The description clearly identifies the operation: 'Get historical data for a specific symbol on a specific date' and adds that it returns price and volume information. This is a specific verb-object pair with clear scope. However, it does not differentiate from similar sibling tools like get_symbol_data or get_market_data_for_asset.

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 text implies a point-in-time historical lookup but gives no explicit guidance on when to use this tool versus alternatives. No sibling tools, exclusions, or preferred contexts are mentioned. An agent would not know whether to choose this over get_symbol_data or get_market_data_for_asset.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds no behavioral context beyond restating the data grouping; it does not mention any side effects, auth requirements, or pagination, but those are less critical given the read-only annotations and output schema.

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

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

The description is short and front-loaded, but the first and second sentences are largely redundant ('showing cash flows and contributions' is restated). It could be tightened to a single sentence without losing information.

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

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

For a read-only, idempotent tool with two optional and well-documented parameters and an output schema, the description is functionally adequate. The main missing element is usage differentiation from closely related portfolio/historical reporting 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?

Both parameters are fully documented in the schema with default values and allowed options, so schema description coverage is 100%. The description only reiterates 'grouped by time period' and adds no parameter-level meaning beyond what the schema already provides.

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

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

The description names a clear verb and resource ('Get investment data') and specifies it is grouped by time period with cash flows and contributions. It is strong enough to distinguish from most siblings like get_watchlist or get_orders, though it does not explicitly differentiate from get_portfolio_performance or get_historical_data.

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

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

The description implies the intended use for retrieving investment activity grouped by time period, but it never states when to choose this over sibling tools such as get_portfolio_performance or get_dividends. There is no explicit when-to-use or when-not-to-use guidance.

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

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

Annotations already establish that this is read-only, idempotent, and non-destructive, so the description does not need to restate safety. It adds useful scope by specifying 'current' market data and naming returned fields, but it does not disclose further behavior such as data-source compatibility or error handling.

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

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

The description is compact and readable, with the substantive details contained in the second sentence. The first sentence is a mild restatement of the title and could be trimmed, but overall there is minimal 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?

With both required parameters fully described in the schema, an output schema present, and annotations covering safety, an agent has enough to invoke this tool correctly. It could be more complete by noting when to choose this over get_symbol_data or by clarifying data_source/symbol compatibility, but the core call context is sufficient.

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

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

Schema description coverage is 100%, with both symbol and data_source already described with concrete examples. The description does not add parameter-level meaning, but it does not need to because the schema fully documents both required 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 uses a specific verb ('Retrieves') and clearly identifies the resource: current market data for a specific symbol, including price, volume, and market cap. It is clear, though it does not explicitly distinguish itself from similarly named siblings like get_symbol_data or get_historical_data.

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

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

No guidance is provided about when to use this tool versus alternatives such as get_symbol_data or get_historical_data. The word 'current' implies it is for present market data rather than historical queries, but no explicit exclusions or alternative recommendations 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description's 'Retrieves a list' is consistent with these and adds no contradiction. It provides the optional filtering behavior, which is a minor extra, but does not disclose anything beyond what annotations imply (e.g., no auth details, rate limits, or side effects). Since annotations cover safety, the description's contribution is adequate but not rich.

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 that essentially repeat the same information: the first says 'Get all activities/orders from your portfolio, optionally filtered by account' and the second says 'Retrieves a list of all buy/sell orders in your portfolio, optionally filtered by a specific account.' This is redundant and could be condensed to a single sentence without losing any 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?

The tool is simple (1 optional parameter, 0 required), has an output schema (not shown), and annotations cover safety. The description covers the core function and the filter option. Given that it has an output schema, it doesn't need to explain return format. It could be more complete regarding sorting or pagination, but these are likely in the output schema. Overall, it is complete for an agent to call it correctly.

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

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

Schema description coverage is 100% for the single parameter account_id, which already fully explains it as 'Optional account ID to filter orders by specific account.' The description repeats this without adding any new semantics, so it adds no value beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool retrieves all portfolio orders, optionally filtered by account. It uses specific verbs ('get', 'retrieves') and a clear resource (orders/activities), and distinguishes itself from sibling tools that handle balances, accounts, watchlists, and other domains. The purpose is unambiguous and not a tautology.

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

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

The description implies when to use the tool (for retrieving orders) but does not explicitly contrast it with alternatives like get_portfolio_holdings or get_investments. It mentions optional filter by account but doesn't state conditions under which one would prefer another tool. It provides basic usage context but no explicit 'when not to use' guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds meaningful context about what the platforms are and their intended use, which enriches the annotation-only information without contradicting it.

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

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

The description is short and front-loaded, but the opening line 'Get available platforms' largely repeats the title and first sentence. The additional explanation and return note are useful and compact, with only minor redundancy.

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

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

For a simple, parameterless, read-only getter with rich annotations and an existing output schema, the description provides sufficient context: what platforms are, examples of platform types, and why they are used. Nothing essential is missing for an agent to invoke this tool correctly.

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

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

The tool has zero parameters and the input schema is fully documented with an empty properties object, so there is no parameter meaning for the description to add. With no parameters, the baseline of 4 applies.

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

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

The description clearly identifies the resource (platforms), specifies they include brokers and exchanges, and states their purpose in tracking accounts or transactions. It is unambiguous and distinct from sibling tools that target accounts, watchlists, orders, or portfolio data, though it does not explicitly compare itself to any 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 provides clear context for when this tool is relevant: retrieving platforms to use when tracking accounts or transactions. It does not explicitly mention alternatives or exclusion criteria, but none of the sibling tools appear to serve this same purpose.

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

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

Annotations already communicate readOnly, idempotent, and non-destructive behavior. The description reinforces 'Retrieves' and mentions a dictionary return value, but adds little beyond that; no auth needs, rate limits, or side-effect context is provided. Since annotations carry the safety profile, this is adequate but not enriched.

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 repeats itself three times: the first sentence, the second sentence, and the 'Returns' block all say essentially the same thing. While the opening is front-loaded, the redundancy means several sentences do not earn their 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 parameters, strongly safety-relevant annotations, and an output schema present, the description needs to do very little beyond identifying the tool's scope. It states the main content areas, so an agent can understand what the call returns. The only real gap is sibling differentiation, already penalized in usage guidelines.

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

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

The tool has zero parameters and schema description coverage is 100%, so there is nothing meaningful for the description to add. It correctly avoids inventing parameter context, meeting the baseline for parameter-free tools.

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

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

The description uses a clear verb-resource structure: 'Get comprehensive portfolio details including accounts, positions, and summary.' The content scope is stated, but it does not explicitly distinguish this aggregate tool from closely related siblings like get_accounts, get_portfolio_holdings, or get_portfolio_performance.

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 alternatives. The phrases 'complete overview' and 'comprehensive portfolio details' imply high-level use, but there are no explicit conditions, exclusions, or references to sibling tools, so an agent gets no selection guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description is not responsible for conveying safety. It adds the 'specified time period' context, which is useful, but it does not mention pagination, response size, or any other behavioral traits beyond that. With annotations covering the main safety profile, the description adds modest value.

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

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

The description has two sentences that are largely redundant: the first states holdings/positions/allocations/asset breakdowns, and the second repeats nearly the same list with slight rephrasing. It is not overly long, but the redundancy wastes space. A single well-structured sentence would have been sufficient.

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

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

For a simple read-only tool with one optional parameter and an output schema, the description covers the essentials. The main gap is the lack of differentiation from sibling tools, which is important given the large set of similar tools. Otherwise, it is reasonably complete for what it does.

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

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

The schema covers the only parameter (date_range) with a complete description and enum-like options (though not formally enumerated). The description merely references 'specified time period' without adding new semantic insight, so it meets the baseline for high schema coverage but does not exceed it.

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

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

The description clearly states the action ('Get portfolio holdings') and the specific data returned (positions, allocations, asset breakdowns). However, it does not differentiate from closely related sibling tools like get_portfolio_details or get_position, so an agent might not know which tool to pick based on this description alone.

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 alternatives. With many sibling tools (e.g., get_portfolio_details, get_portfolio_performance, get_position), the description should specify the distinguishing use case. The description only states what it does, not when it is the right choice.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds a bit of context about the data returned (returns, benchmarks, comparisons) and the time period, but does not disclose any behavioral traits beyond what the annotations and simple read operation already imply.

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 but noticeably redundant: the first and second sentences restate nearly the same list of returns, benchmarks, and performance metrics. It is not bloated, but it does not use every sentence efficiently.

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

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

The tool is simple with one optional parameter and has an output schema, so the description does not need to explain return values. However, given a large sibling list with closely related tools, the lack of any selection guidance leaves the context incomplete for an agent deciding between this and get_benchmark_performance or get_portfolio_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 100%, and the single parameter date_range is fully documented with options and a default. The description adds no additional meaning about the parameter, so the baseline 3 applies.

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

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

The description clearly identifies a get operation on portfolio performance data, listing returns, benchmarks, and performance metrics. It is understandable and distinct in topic, though it does not explicitly differentiate itself from related siblings like get_benchmark_performance or get_portfolio_details.

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 the many related sibling tools such as get_benchmark_performance, get_portfolio_details, or get_portfolio_holdings. It only describes what the tool returns, not the conditions or scenarios that make it the right choice.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds some useful context by listing returned aspects (current value, quantity, performance, market data), but it does not add deeper behavioral details such as error cases, authentication needs, or data-source-specific behavior.

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

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

The description is two sentences with no filler. The main action is front-loaded in the first sentence, and the second sentence provides a concise, useful enumeration of what the result contains.

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

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

For a simple read-only tool with full schema coverage, output schema present, and annotations covering safety, the description is largely complete. It could be stronger by explicitly distinguishing from sibling lookup tools, but nothing essential to invoking it correctly appears to be missing.

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

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

Schema description coverage is 100%, so the schema already documents the symbol and data_source parameters with examples. The description mostly restates the parameter concepts ('specific symbol', 'data source') without adding extra semantic detail beyond the schema.

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

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

The description uses a specific verb ('Get') and a clear resource ('position details for a specific symbol from a data source'). It also distinguishes itself from sibling tools by emphasizing position-level details (value, quantity, performance, market data) rather than generic symbol or account data.

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

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

The phrase 'for a specific symbol' gives clear context that this is for single-position lookups, which implies when to use it. However, it does not explicitly mention alternatives like get_portfolio_holdings or get_symbol_data, or state when not to use this tool, 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.

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only that it returns price, market data, and asset information, which is partly redundant with the output schema and does not disclose extra behavioral traits such as caching, freshness, or data-source limitations.

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-loaded with the core action in the first sentence. The second sentence is somewhat redundant with the first but does add concrete return-content details, so it earns its place mostly.

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

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

For a simple, read-only, two-parameter tool with an output schema, the description covers the basics. However, the large sibling set creates ambiguity — especially with get_market_data_for_asset — and the description does not clarify the distinction, so an agent cannot confidently select it over similar 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 100%, and both parameters already have clear descriptions with examples. The description does not add meaningful constraints, formats, or domain-specific detail beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Get symbol data for a specific asset from a data source,' and the second sentence adds what is included: current price, market data, asset information. It is clear on its own but does not differentiate it from siblings such as get_market_data_for_asset or get_historical_data.

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

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

No guidance is given on when to use this tool versus alternatives like get_market_data_for_asset, lookup_symbols, get_asset_profile, or get_historical_data. The description only restates what the tool does, leaving selection entirely 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds minimal behavioral context beyond stating it retrieves information and returns a dictionary, but it does not contradict the annotations.

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

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

The description is short but repetitive: 'Get user information and settings' and 'Retrieves information about the current user including settings...' cover nearly the same ground. The Returns block is useful but could be trimmed.

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

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

For a zero-parameter read-only tool with an output schema and clear annotations, the description is complete enough. It states what is returned and scopes the operation to the current user, leaving no critical gap for 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?

The tool has zero parameters, so the description carries no parameter-semantics burden. The baseline of 4 applies because there is nothing for the description to explain about inputs.

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 specific operation: retrieving information about the current user, including settings, preferences, and account details. It distinguishes itself from sibling tools like get_account_details by focusing on the current user's aggregate information.

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 'current user' implies when this tool should be used, but no explicit exclusions or alternatives are mentioned. With many sibling tools present, an explicit pointer to when not to use it would have been stronger.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds a minor detail that the return value is a dictionary of watchlist items, but no additional behavioral context such as pagination, limits, or user scoping is 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 short and front-loaded, but the first two sentences are near-duplicates ('Get all items in the user's watchlist' and 'Retrieves list of all watchlisted symbols'). This redundancy means not every sentence earns its place.

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

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

For a zero-parameter, read-only, idempotent getter with an output schema, the description is complete enough for an agent to call it correctly. No hidden prerequisites, inputs, or expected side effects are missing.

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

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

The tool has zero parameters and schema description coverage is 100%, so there are no parameter semantics for the description to clarify. This matches the baseline for a 0-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 clearly identifies the resource ('user's watchlist') and the operation ('Get all items') with a specific verb. It is immediately distinguishable from sibling tools like add_to_watchlist and remove_from_watchlist, which involve mutation rather than retrieval.

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 siblings such as add_to_watchlist or remove_from_watchlist. An agent must infer from the tool name and sibling structure that this is the read operation for the watchlist.

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

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

The description explicitly states it is a write operation, and the annotations already indicate readOnlyHint=false. It adds useful batch-import context beyond the annotations, but does not cover duplicate handling, whether existing transactions are affected, or required permissions. With annotations present, this level is acceptable.

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-loaded, but the second paragraph largely restates the first: both mention importing transactions into the portfolio. 'This is a write operation' also duplicates what readOnlyHint=false already conveys, so not every sentence earns its place.

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

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

The schema carries significant detail and an output schema exists, so the description doesn't need to explain return values. However, it could more explicitly distinguish batch import environment behavior from create_activity and clarify what happens on conflict or re-import. Adequate but with clear gaps.

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

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

The input schema already provides 100% coverage with a detailed description of the expected 'activities' list and required fields. The tool description adds no parameter-level semantics, so the baseline of 3 applies.

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

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

The description clearly states the verb and resource ('Import transactions into your portfolio') and adds that it handles a batch of buy/sell orders. It is not as explicit as naming sibling alternatives, but the batch framing distinguishes it from single-activity tools like create_activity.

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 a clear use case: 'useful for bulk importing historical data or transactions from other platforms.' This signals when the tool is appropriate, though it does not explicitly state when not to use it or name a preferred alternative.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds useful scoping context by noting that market indices are only included when requested, but it does not disclose additional behavior such as matching semantics, result limits, or search coverage.

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-loaded with the primary purpose. The second sentence slightly restates the first, but overall each part earns its place by adding asset-class scope and the optional index behavior.

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

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

For a simple 2-parameter search tool with an output schema and strong read-only annotations, the description is adequately complete. An agent can confidently invoke the tool with a query and understand the optional index behavior; no critical missing information is apparent.

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 both parameters are already documented in the input schema. The description mostly restates the query and optional include_indices behavior without adding meaning beyond what the schema provides; the baseline of 3 is appropriate.

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

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

The description clearly states that the tool searches for financial symbols using a text query, and also identifies the resource types (stocks, ETFs, other assets). It does not explicitly differentiate itself from siblings like get_symbol_data or get_asset_profile, but the verb 'search' plus the query-string input makes the core purpose clear.

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

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

The description implies the tool should be used when an agent needs to resolve a company name, ticker, or partial match into a symbol. It does not explicitly state when to prefer this over sibling lookup tools or mention any exclusions, so usage guidance is present but only implied.

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

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

Annotations already indicate this is destructive and idempotent. The description adds that the destructive action is scoped to removing a symbol from the watchlist, but it does not disclose edge-case behavior such as what happens if the symbol is not present. This is adequate but not rich.

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

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

The description is a single, direct sentence with no filler. It is appropriately sized for the simplicity of the operation.

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, both parameters are fully documented in the schema, annotations cover the destructive and idempotent behavior, and an output schema exists. The description is complete enough for an agent to invoke the tool correctly.

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

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

Schema description coverage is 100%, with both 'symbol' and 'data_source' clearly described in the input schema. The tool description adds no additional parameter semantics, so the schema carries the full burden.

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 ('Remove'), a specific resource ('symbol'), and a clear scope ('user's watchlist'). This clearly distinguishes it from sibling tools like get_watchlist and add_to_watchlist.

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

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

The description makes the tool's purpose obvious, but it does not explicitly state when to use this tool versus alternatives or mention that add_to_watchlist is the inverse operation. Usage guidance is only implied by the tool name and sibling context.

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

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

Annotations already cover readOnly/idempotent/destructive hints, so the description need not restate them. It adds no extra context about side effects beyond 'Transfer' (source decreases, destination increases), and does not warn about duplicate transfers or insufficient funds. This is adequate but not rich.

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 with no redundancy or filler. Every word contributes: the verb, the resource, and the source/destination relationship are all present and front-loaded.

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

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

With a complete input schema and an output schema, the description leaves little ambiguity for a simple two-account transfer. It could additionally state constraints like positive amounts or distinct account IDs, but these are reasonable defaults for a transfer operation.

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

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

The input schema describes all three parameters with 100% coverage, so the description does not need to explain them. It adds no additional parameter-level semantics (e.g., positivity, distinct accounts), keeping it at the baseline for well-covered schemas.

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 ('Transfer'), resource ('cash balances'), and relationship ('between two accounts'), making the tool's function unambiguous. This also differentiates it from siblings like create_account_balance and delete_account_balance, which lack the two-account movement semantics.

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 usage is implied by 'between two accounts' — the tool is for moving cash from one account to another. However, it does not explicitly say when to prefer this over create_account_balance/delete_account_balance or mention prerequisites like verifying balances.

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

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

Goes well beyond the annotations by disclosing that the endpoint replaces the whole record, that unset fields are backfilled via a GET before PUT, and that balance is applied as today's entry in the history series. This is valuable behavioral context not present in readOnlyHint/idempotentHint/destructiveHint.

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 front-loaded with the core purpose, then adds critical behavioral details in a logical order. Every sentence contributes meaningful information, and there is no redundant restatement of the 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?

Given the output schema exists, return values need no explanation. The description covers the tricky replacement semantics, parameter backfilling, balance history behavior, and the key sibling alternative, making the tool fully usable without further 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 coverage is 100%, but the description still adds significant meaning, especially for `balance` (today's history entry, not a stale field) and for `name`/`currency`/`platform_id` (required by the underlying endpoint but backfilled by the wrapper). This resolves ambiguity the schema alone could not.

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 clear verb and resource: updating settings or details of an existing account. The distinction from create/delete/transfer siblings is apparent from the wording 'existing account' and 'settings or details'.

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 explains when to use this tool and provides an alternative: 'Use create_account_balance to set the balance for a specific past date instead of today.' It also clarifies that only changed fields need to be passed, which is essential practical guidance.

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

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

The description goes well beyond the annotations by disclosing the POST-then-PATCH sequence, tolerance of Ghostfolio's HTTP 500 on first-time and duplicate creates, PATCH as the source of truth, the 404 consequence if the POST did not persist, and the same-end-state guarantee across repeated calls. This is rich, accurate behavioral context.

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

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

The description is three sentences long, front-loaded with the core purpose, and packs in essential behavioral details without repeating the schema's parameter descriptions or padding 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?

The tool has unusual error behavior and a two-step write path, and the description covers all of it: idempotency, 500 tolerance, 404 surfacing, and final-state guarantee. The output schema exists, so explaining return values is unnecessary.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds operation-to-parameter mapping: name, currency, asset_class, and asset_sub_class are PATCHed metadata, while the POST concerns the profile-data record. This helps an agent reason about which parameters participate in which step.

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 'Create-or-update an asset profile,' a specific verb+resource statement that clearly differentiates it from get_asset_profile and delete_asset_profile. The two-step POST/PATCH mechanism further removes ambiguity about what the 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 first sentence establishes the exact trigger for using this tool: when an asset profile needs to be created or updated. It does not explicitly name alternatives or exclusion conditions, but the sibling list contains no equivalent create-or-update tool, so the usage context is clear.

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