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 declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the write/non-idempotent profile is covered structurally. The description adds nothing beyond that – no mention that repeated calls create duplicate activities, no validation rules tying fields to the activity type, no permission or account-ownership 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?

A single front-loaded sentence with zero filler. It is efficient, though its brevity is close to under-specification for an 8-required-parameter mutation tool rather than genuine tightness.

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 mutation with 8 required parameters, an output schema, and type-dependent semantics (e.g. how fields apply to DIVIDEND vs BUY vs FEE), the description says nothing about valid field combinations or what a successful creation returns or affects. The structured fields cover definitions but not usage correctness.

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 all 11 parameters including type, symbol, date, and data_source are documented in the schema itself. The description contributes no additional meaning, which is the baseline 3 when the schema carries the full load.

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 and resource: 'Create a single new transaction/activity.' The word 'single' implicitly distinguishes it from bulk paths like import_transactions, but no sibling tool is named to make the distinction explicit.

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 on when to use this versus update_activity (for existing records) or import_transactions (for bulk loads). An agent must infer from sibling names that this is the one-at-a-time creation path.

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 declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds only a sketch of the returned fields, with no mention of pagination, ordering, or whether the list is scoped to a single portfolio — though the presence of an output schema lowers the burden.

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 two sentences say essentially the same thing twice ('including account types and balances' / 'including account types, balances, and account-specific information'), so half the text is redundant rather than adding information. Front-loading the core purpose is done well.

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 zero parameters, full annotation coverage, and an output schema, the description only needs to position the tool against its siblings — and it doesn't. Nothing about return values is required, but the missing routing guidance leaves a real gap in a crowded account-related tool family.

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

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

The tool takes zero parameters, so the baseline applies and there is nothing for the description to disambiguate. The description correctly implies a no-argument, portfolio-wide listing.

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 and resource ('Get all accounts in your portfolio') and names the payload fields (account types, balances). However, it does not distinguish itself from close siblings like get_account_details or get_account_balances, which the 'including ... balances' phrasing partially overlaps with.

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 statement of when to use this tool versus get_account_details, get_account_balances, or get_portfolio_details, all of which sit adjacent in the sibling list. The agent must infer the boundary from names alone.

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

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

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 declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds only that results cover all configured benchmarks (no filtering, no subsetting), which is modest context beyond structured fields. With an output schema present, no further disclosure of return values is required.

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

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

A single short sentence with zero filler, naming the resource and scope up front. Nothing is wasted and nothing needs trimming.

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

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

For a no-parameter, read-only listing with annotations and an output schema, the description covers what an agent needs to invoke it correctly. The remaining gap is not clarifying the boundary with get_benchmark_performance, which matters given how similarly named the siblings are.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline is 4. The phrase 'all configured' appropriately confirms there is no filtering input to supply.

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 ('Get') and resource ('benchmarks') with a scope qualifier ('all configured'), which tells the agent this is an unfiltered listing. It does not distinguish itself from the sibling get_benchmark_performance, which an agent could plausibly confuse it with when looking for benchmark 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?

There is no explicit when-to-use, no prerequisites, and no mention of alternatives such as get_benchmark_performance for actual performance data. The only implied guidance is 'all configured', which hints at a metadata listing rather than a data query, but the agent must infer that.

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?

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds only that this is a backend service check; it says nothing about authentication requirements, rate limiting, or what a degraded vs healthy response implies (though the output schema likely covers the payload).

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

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

Short and front-loaded, with the purpose in the first line. The second sentence ('Retrieves the health status of the Ghostfolio backend service') largely restates the first, adding only the backend-service detail.

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

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

For a zero-parameter read-only probe with annotations and an output schema, the description gives enough to select and call it. Only edge details such as auth requirements or what failure looks like are absent, which is minor here.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline applies. No parameter text is needed and none is missing.

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 and resource ('get system health status') and names the concrete target (Ghostfolio backend service), so intent is unambiguous. It doesn't need to differentiate from siblings since none of them touch health, but it also makes no 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?

'Useful to verify if the server is up and running correctly' gives a clear but generic use case. There are no exclusions, prerequisites, or mentions of when a different diagnostic tool would be preferred.

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 disclose that the tool is read-only, idempotent, and non-destructive, so the description does not need to repeat safety behavior. The description adds that it returns 'all available platforms' and gives examples of platform types, but it does not discuss pagination, authentication requirements, or other behavioral details. With strong annotations and an output schema, 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 short and front-loaded, stating the action first and then elaborating on what platforms are. There is minor redundancy between 'Get available platforms' and 'Retrieves a list of all available platforms,' but no significant waste.

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 listing tool with annotations and an output schema, the description gives enough context to understand what the tool does and when it might be useful. It could be slightly more complete by naming related tools or prerequisites, but nothing essential is missing for correct invocation.

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

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

The tool has zero parameters, so parameter semantics are not a concern. The schema is empty and the description correctly does not introduce any parameter-related details. Baseline 4 applies for a no-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 states a specific verb and resource: 'Get available platforms' and clarifies that these are 'brokers, exchanges, etc.' used when tracking accounts or transactions. It is clear what the tool returns, but it does not explicitly distinguish itself from sibling tools such as get_accounts, get_benchmarks, or lookup_symbols.

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 'that can be used when tracking accounts or transactions' gives implied usage context, but there is no explicit guidance on when to call this tool versus alternatives. No exclusions, prerequisites, or sibling alternatives are mentioned.

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 safety profile (readOnly, idempotent, non-destructive), and the description adds nothing beyond them: no auth requirements, no mention of scope (all accounts vs. one), no statement of how large the response may be or whether it is expensive to call. The second sentence largely restates the first rather than disclosing 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?

Front-loaded with the useful sentence, but the second sentence repeats the same content ('complete overview ... account information, current positions, performance summary, portfolio metrics') without adding information. It is short overall, yet roughly half of it does not earn its place.

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

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

Given zero parameters, an output schema, and full annotation coverage, this is a simple read tool requiring little more than a purpose statement. The description says what the payload contains, which is sufficient; only the missing sibling disambiguation keeps it from being fully complete.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate. It does not need to explain parameter syntax, and the enumeration of returned content is supplementary rather than required.

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

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

States a specific verb and resource ('Get comprehensive portfolio details') and enumerates contents: accounts, positions, performance summary, metrics. It does not, however, distinguish itself from siblings such as get_portfolio_holdings, get_portfolio_performance, or get_investments, so an agent must infer the overlap.

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

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

No when-to-use guidance, no prerequisites, and no named alternatives despite a crowded sibling set with several portfolio-reading tools. The word 'complete overview' hints at broad-scope usage but never says to prefer the narrower siblings when only one aspect is needed.

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?

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds scope of returned data (settings, preferences, account details) but nothing about breadth, sensitivity of the data, or whether it reflects the authenticated principal only — modest added value given a read-only, zero-argument call.

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?

Very short and front-loaded with the action. The second sentence largely restates the first ('user information and settings' vs 'settings, preferences, and account details'), so one of the two sentences is close to redundant, but nothing is padded or buried.

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 zero parameters, an output schema documenting the return shape, and annotations covering safety, the description only needs to establish who and what. It does that, though 'settings' stays vague and no sibling routing is offered in a 39-tool namespace where several get_* tools could plausibly be chosen.

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

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

The tool takes no parameters, and the schema is fully described, so there is no parameter semantics burden to discharge. Baseline 4 applies.

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

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

It states a specific verb and resource ('Get/Retrieves information about the current user') and scopes the payload to settings, preferences, and account details, which distinguishes it from account-scoped siblings like get_account_details. It stops short of naming any sibling explicitly, so the differentiation is inferred rather than stated.

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 when-to-use guidance, no prerequisite, and no mention of alternatives such as get_accounts or get_account_details. The only implicit signal is 'current user', and the agent must guess that this is the profile/self-lookup tool rather than an account-lookup 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?

Annotations already declare readOnlyHint, idempotentHint and non-destructive, so the safety profile is fully covered. The description's only added behavioral fact is the word 'all', implying no filtering or pagination options. It says nothing about ordering or what an empty watchlist yields.

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

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

Two short sentences with the intent front-loaded, but the second sentence largely restates the first ('items in the watchlist' vs 'watchlisted symbols') rather than adding 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?

A zero-parameter read tool with an output schema and exhaustive annotations needs very little prose. The description covers the what and scope sufficiently; only caller-facing behavior for an empty list or ordering is left unstated.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. The schema is trivially complete at 100% 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?

States a specific verb ('Get') and resource ('items in the user's watchlist') and the second sentence clarifies that the items are watchlisted symbols. It doesn't explicitly name add_to_watchlist / remove_from_watchlist as the alternatives, but the read-only retrieval intent is unmistakable.

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 on when to use this versus the sibling mutation tools, no mention that it requires no arguments, and no indication of prerequisites. Usage is only inferable from the sibling naming.

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 (which only declare non-read-only, idempotent, destructive) by explaining the PUT-replaces-whole-record semantics, the pre-PUT GET backfill, the failure mode when name/currency can't be backfilled, and where the balance lands in the history series. This directly de-fangs the destructiveHint=true concern.

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?

Front-loads the purpose, then layers mechanism and the balance/date distinction. Dense but every sentence carries operational value; slightly long for a single tool.

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

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

For a destructive-replacing mutation with an output schema present, the description covers required-field quirks, backfill behavior, failure handling, and balance-history semantics — nothing an agent needs is missing.

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

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

Schema coverage is 100%, so baseline is 3; the description adds real meaning by clarifying that name/currency/platform_id are required server-side yet optional client-side due to backfill, and that balance means today's entry rather than a stale field.

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 and resource ('Update settings or details of an existing account') and implicitly separates it from create_account, delete_account, and create_account_balance, which the description later names explicitly.

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

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

Gives clear routing guidance: 'Use create_account_balance to set the balance for a specific past date instead of today,' and reassures that unset fields are backfilled so callers need only pass changed fields. No explicit when-not-to-use for the whole tool, hence 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 mark this as destructive and idempotent, but the description adds substantial hidden behavior: the PUT replaces the whole record, unset fields are backfilled with a GET first, restricted views redact quantity/fee/comment, comments are cleared unless supplied, asset changes require symbol/data_source/currency together, and concurrent edits can be overwritten. These are exactly the beyond-annotation behaviors an agent needs to avoid incorrect updates.

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 front-loads the action and then spends each sentence on a non-obvious constraint such as replacement semantics, backfill behavior, restricted-view redaction, and ignored asset changes. The length is justified by 12 parameters and the tool's complex update behavior, with no filler.

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

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

With annotations, full parameter descriptions, and an output schema already present, the description covers the behavioral gaps an agent needs in order to call this tool correctly. Return-value details are appropriately left to the output schema.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds important cross-parameter meaning: unchanged required fields must still be passed or backfilled, tags/account_id/comment default to current state, comment may be required in restricted views, and symbol/data_source/currency must be changed together. This goes well beyond the individual schema 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 states a specific verb ('Update') and resource ('an existing activity/transaction'), which clearly distinguishes it from create_activity and delete_activity siblings. The replacement semantics are additional detail, but the core purpose is unambiguous.

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

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

It gives clear context for updating an existing activity and explicitly says to delete and re-create instead when an asset change would be silently ignored for FEE, INTEREST, LIABILITY, or MANUAL BUY activities. However, it does not provide broad routing guidance versus create_activity or delete_activity, so it stops short of a full 5.

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

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

Beyond annotations, the description discloses concrete error tolerance (HTTP 400 when already exists, HTTP 500 on some first-time paths while still persisting), the POST-then-PATCH flow, and that PATCH is the source of truth. This level of detail prevents an agent from misinterpreting non-standard idempotency 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 appropriately dense for the complexity of an idempotent upsert with non-standard HTTP behavior. Every sentence carries information: purpose, POST behavior, PATCH source-of-truth, and end-state guarantee. No filler or redundant schema repetition.

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

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

For an 8-paramt tool with a 100%-covered schema, annotations, and an output schema, the description covers the only real gaps: the two-step operation, edge-case error handling, and idempotency guarantees. Nothing an agent needs to correctly invoke this tool is missing.

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

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

Input schema coverage is 100%, so baseline is 3. The description adds meaningful flow context by stating that the POST creates an empty profile and the PATCH applies metadata parameters, and that PATCH errors surface if the POST did not persist. This goes beyond simply echoing parameter names.

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

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

The description opens with a specific verb+resource ('Create-or-update an asset profile') and clarifies the two-step POST/PATCH mechanism. This clearly distinguishes it from the sibling get_asset_profile and delete_asset_profile tools.

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

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

The 'Create-or-update' framing gives a clear context for when to call it, and the idempotent behavior explains repeated-invocation safety. It does not explicitly name alternatives or exclusions, but the sibling names and the verb make the intended use unambiguous.

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