Manawa Terminal

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

The description adds behavioral detail beyond the annotations by explaining that symbol aliases 'CASH' and blank are normalized to '$CASH', and that qty represents cash amount for deposits/withdrawals. It also specifies the date format (YYYY-MM-DD). This provides useful context that annotations don't convey, though it doesn't mention side effects like portfolio balance 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 is compact and front-loaded with the main purpose, followed by a structured Args block. Each line adds necessary information, with no filler or redundancy. It strikes a good balance between completeness and brevity.

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

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

The description is complete for a 6-parameter tool: it covers all required arguments, provides examples and normalization rules, and clarifies the interpretation of qty across transaction types. An output schema exists, so return-value details are not needed. It lacks only minor preconditions (e.g., portfolio existence), which are likely evident.

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

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

With 0% schema description coverage, the description fully compensates by listing all 6 parameters and their meanings. It explains the special symbol handling for cash transactions and distinguishes qty semantics by side (shares vs cash amount). This is exemplary parameter documentation.

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

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

The description opens with a specific verb and resource: 'Add a buy, sell, deposit, or withdrawal transaction to a portfolio.' It clearly identifies the action and object, and the transaction types distinguish it from sibling tools that create other resources (e.g., create_portfolio, create_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?

It doesn't explicitly state when not to use it or name alternatives, but the description provides clear context: it's for adding any of four transaction types to a portfolio. The parameter guidance (e.g., cash handling) reinforces the intended use case. Since there is no competing sibling tool for adding transactions, this 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?

The description goes beyond the minimal annotations by specifying conditional requirements for different alert types (direction/threshold for price alerts, event_types for event alerts) and enumerating all accepted event types. This gives concrete behavioral expectations that annotations do not 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 well-structured docstring with a clear one-line summary followed by a compact parameter list. Each entry is concise, and the whole is scannable without unnecessary prose.

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

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

For a tool with six parameters and conditional logic, the description is thorough: it covers all parameters, their types, required-ness based on alert_type, and the full set of event types. It is complete enough for an agent to invoke the tool correctly without further clarification.

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 zero schema description coverage, the description fully compensates by explaining each parameter's meaning, conditions, and even providing an example for symbol. It also lists all valid event_types, which the schema does not enumerate.

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

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

The description uses the specific verb 'Create' and clearly identifies the resource as a 'price or event alert', which distinguishes it from sibling tools like list_alerts and delete_alert. The expanded scope beyond the title's 'price alert' is still specific and meaningful.

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

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

The description clearly implies when to use this tool: to create a new price or event alert. It does not explicitly name alternatives or exclusions, but the unique purpose and sibling context make the use case obvious, though not as explicit as it could be.

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

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

With annotations already declaring readOnlyHint=false and destructiveHint=false, the description adds useful behavioral context by explaining that the folder can be nested under a parent or created as a root folder. This goes beyond the schema and clarifies the outcome of omitting parent_id, though it does not mention permissions or side effects.

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 exceptionally concise: a one-sentence purpose statement followed by a compact args list. Every word earns its place, and the most critical information (root vs nested) is front-loaded. No fluff or redundancy.

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

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

For a simple create operation with only two parameters and an output schema present, the description is complete. It covers the purpose, parameter semantics, and the critical edge case of root vs nested folders. The tool's low complexity means no further context is needed.

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

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

Despite schema description coverage being 0%, the description compensates by explaining both parameters: 'name' as the folder name and 'parent_id' as a parent folder UUID, explicitly stating that omitting it creates a root folder. This adds significant meaning beyond the raw schema.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Create a library folder'. It also distinguishes from sibling tools by mentioning the 'library' scope and optional nesting, which differentiates it from create_library_item or create_portfolio.

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

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

The description provides context on how to use the parent_id parameter ('omit for a root folder'), which implies when to use it, but it does not explicitly discuss when to use this tool versus alternatives. There is no exclusionary guidance or mention of sibling tools.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the safety profile is clear. The description adds only the create action and markdown resource type, which is more about purpose than behavior. No additional behavioral traits (e.g., permissions, response format) are disclosed, but with annotations present, the bar is lower.

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 front-loaded: one sentence states the purpose, followed by a concise Args list. No redundant or filler content exists; every sentence adds value.

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

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

For a simple create tool with 3 parameters (2 required), an output schema, and clear parameter documentation, the description is adequate. It explains what is created, the required inputs, and the optional folder parameter. It does not mention return values (output schema covers that) or potential errors, but these are not critical gaps for selection and invocation.

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

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

Schema description coverage is 0%, so the Args section in the description carries the semantic burden. It explains each parameter: title as 'Document title', content as 'Markdown body', and folder_id as 'Folder UUID (optional — omit for library root)'. This adds meaning beyond the schema's type/required fields, though it could be more detailed about invariants like folder existence.

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 'Create a new markdown document in the research library' with a specific verb, resource type, and destination. This distinguishes it from sibling tools like create_library_folder, which creates folders, and other create_* tools.

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

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

The description implies usage context ('research library', 'markdown document') but does not explicitly state when to use this tool versus alternatives. No exclusions or alternative recommendations are provided, so it relies on the agent inferring from sibling names and the resource description.

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 a mutation (readOnlyHint=false). The description only restates the schema parameters (name, currency) without adding any extra behavioral details such as idempotency, duplicate handling, or required permissions. It adds no information beyond what annotations and schema 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 extremely concise, leading with a clear purpose sentence and then listing the two parameters. Every sentence earns its place, with no filler or repetition.

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

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

For a simple two-parameter create tool with an output schema present, the description sufficiently covers the required inputs. It does not need to explain return values since the output schema exists. Minor omissions like duplicate name behavior are not essential for basic 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 schema has zero description coverage for its parameters. The description compensates fully by explaining 'name' as the portfolio name and 'currency' as the base currency with a default of USD. This provides clear meaning beyond the raw schema definitions.

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 'Create a portfolio' with a specific verb and resource. This distinguishes it from sibling tools like create_watchlist or create_alert by targeting the portfolio entity.

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

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

The context is clear: use this tool to create a new portfolio. It does not explicitly exclude any scenarios or mention alternatives, but the purpose is evident among the sibling tools. No exclusion is necessary for such a straightforward create operation.

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 only repeats the basic creation action and parameter names, adding no behavioral details such as idempotency, duplicate handling, permissions, or return value behavior. Annotations indicate readOnlyHint=false and destructiveHint=false, but the description offers no extra transparency beyond that minimal signal.

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

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

The description is extremely concise, with a direct opening sentence and minimal parameter explanations. No fluff or repetition; every line serves a clear purpose and is front-loaded with the core action.

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 two straightforward parameters and an output schema exists, so the description covers the essentials. However, it omits behavioral context like what happens on duplicate names or whether the action is reversible, and lacks usage guidance, leaving it adequate but incomplete for an AI agent.

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

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

The schema has no descriptions for parameters, so the description's Args section adds some value. 'symbols' is clarified with an example (['AAPL', 'MSFT']), aiding understanding, while 'name' is tautological ('Watchlist name'). This partially compensates for the 0% schema description coverage but is not deeply informative.

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 creates a watchlist with a given name and ticker symbols, using a specific verb and resource. It distinguishes from siblings like update_watchlist by focusing on the creation action, though it does not explicitly contrast with them.

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

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

The description provides no guidance on when to use this tool versus alternatives such as update_watchlist or list_watchlists. It does not mention scenarios, prerequisites, or exclusions, leaving the agent without context for choosing 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?

The annotations already declare destructiveHint=true and readOnlyHint=false, and the description is consistent. It adds no extra behavioral context beyond 'delete by ID', but the safety profile is already covered.

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

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

The description is extremely concise, front-loaded, and contains no unnecessary words. It earns every sentence.

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

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

For a simple delete operation with annotations and an output schema, the description covers the core action. However, it omits potential caveats like irreversibility or ownership requirements, though these are partially implied by the destructiveHint.

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

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

With 0% schema description coverage, the description partially compensates by specifying alert_id as a UUID. This adds meaning beyond the bare string type, though it lacks additional details.

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

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

The description clearly states the tool deletes an alert by ID, using a specific verb and resource. It distinguishes itself from sibling tools like create_alert and list_alerts.

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

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

No guidance is given on when to use this tool versus alternatives, such as requiring an existing alert_id or confirming permanence. The description only states what it does without context for usage.

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

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

The description adds the key behavioral detail that the folder's contents are also deleted, which goes beyond the annotations' mere destructiveHint flag. It clarifies the cascading nature of the deletion, though it doesn't mention irreversibility (already implied by 'delete').

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 imperative sentence followed by a minimal args list. It is front-loaded and has no filler, earning a high score.

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 delete operation, the description covers the tool's purpose and parameter. The output schema handles return values, and annotations convey the destructive nature. However, it could mention error conditions or necessary permissions, but these are likely assumed for a straightforward delete.

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 only defines folder_id as a required string with no description. The description's Args block states 'The folder UUID', adding format information (UUID) that the schema lacks, which is helpful but minimal; it doesn't explain how to obtain the ID or any validation rules.

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 'Delete a library folder and everything inside it' with a clear verb and resource, and the 'everything inside it' distinguishes it from delete_library_item and other folder operations. This provides specific scope.

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

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

No explicit guidance on when to use this tool over alternatives like move_library_folder or rename_library_folder is provided. The context only implies that deletion is intended for discarding a folder and its contents, but no exclusions or 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?

The annotation already includes destructiveHint:true, so the destructive nature is known. The description adds valuable context that the deletion removes all stored versions, which is a behavioral nuance beyond the annotation. It doesn't mention irreversibility or permissions, but the annotation covers the core destructive trait.

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 concise and front-loaded. The main statement is one sentence, followed by a minimal Args section. Every word contributes value with no redundancy.

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

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

For a single-parameter tool with an output schema and clear annotations, the description fully covers purpose, effect, and parameter semantics. The output schema handles return values, so no additional return info is needed. It is complete for its complexity level.

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

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

The schema provides no description for item_id, so the description's Args section ('The item UUID') fills the gap. This is sufficient to understand the parameter format and purpose, though it is minimal.

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

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

The description clearly states the tool's function with a specific verb ('Delete'), a specific resource ('library document'), and important scope ('all of its stored versions'). This distinguishes it from sibling delete tools like delete_alert and delete_library_folder.

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 tool's purpose is evident from the name and description, so an agent can infer when to use it. However, it does not explicitly mention alternative tools or when not to use it. Since there is likely no alternative for deleting a library item, this is acceptable but not top-tier.

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 and destructiveHint=false. The description adds valuable behavioral context: it returns an inline widget, covers multiple asset classes, and details exclusive modes when Deep Dives exist. It also advises passing the user's question 'without rephrasing.' 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 well-structured and dense with information. It uses bullet points and code formatting for modes and arguments, making it easy to scan. Each sentence contributes value, from the opening summary to the parameter definitions. There is no repetition or filler.

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

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

Given the tool's complexity (5 parameters, exclusive modes) and the absence of an output schema, the description is largely sufficient. It explains the return is 'an answer with an inline widget' but does not specify the widget's structure or behavior on empty results. Minor gaps remain, but overall it provides enough context for an agent to invoke the tool correctly.

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

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

The schema has 0% description coverage, but the description fully compensates with an Args section explaining every parameter. It describes query, symbols, section (with enumerated values), focus (ai|raw|auto|catalog), and source (with examples). This adds far more meaning than the bare schema titles and types.

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

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

The description clearly states the tool's function: 'Search financial data and return an answer with an inline widget.' It specifies the resource (financial data) and scope (stocks, macro, forex, crypto, commodities, earnings, technicals). This distinguishes it from the sibling tool 'search_library', which presumably searches library items, by the type of data queried.

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 explicit workflows: 'To screen a named watchlist or portfolio, call list_watchlists or list_portfolios first, then pass the symbols here...' It also explains when to use focus/section/source modes. However, it does not explicitly mention alternatives like search_library for library searches, so it lacks a full 'when-not-to-use' statement.

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 and destructiveHint=false. Description adds behavioral context: draft IDs are not readable until end-of-day, and valid IDs come from list_journal, which clarifies timing constraints beyond 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?

Brief, front-loaded purpose, followed by essential usage and parameter details. No wasted words; Args block cleanly documents the single parameter.

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

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

For a one-parameter read operation with output schema present, the description covers purpose, eligibility of IDs, and parameter format. Complete and self-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 only defines entry_id as a string with no description. The description's Args section explains entry_id is a journal entry id from list_journal, accepts integer or UUID, providing critical meaning at 0% 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?

Description clearly states 'Get a full generated journal entry by ID from list_journal', specifying verb, resource, and scope. It distinguishes from sibling tools like list_journal and submit_journal_draft.

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

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

Explicitly explains when to use: after end-of-day generation, using list_journal for valid entry IDs, and warns against using draft IDs from submit_journal_draft. This provides clear context and alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that it returns 'metadata and content', which is minimal and partially redundant with the output schema. No further behavioral context like auth or error conditions is given.

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

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

The description is two concise sentences with the purpose front-loaded. The Args section is minimal and directly informative, with no filler.

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

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

For a simple one-parameter getter with an output schema and strong annotations, the description covers purpose and parameters adequately. It lacks only usage differentiation guidance, which is captured in a separate dimension.

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 only provides type string and title 'Item Id'. The description adds 'The item UUID', giving semantic format that the schema lacks. This fully compensates for the 0% schema description coverage on this single parameter.

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 resource ('library document') with scope ('metadata and content'). It clearly identifies this as single-item retrieval, distinguishing it from list_library_items and other siblings.

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

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

No explicit alternatives or when-not guidance. It implies use when you know the item_id, but does not mention list_library_items or search_library as alternatives for discovery.

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 and destructiveHint=false, covering the safety profile. The description adds that notifications are 'triggered alert' and 'recent', but does not disclose ordering, limits, or pagination behavior. With an output schema present, return structure is known, but behavioral details remain sparse.

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 a front-loaded verb and no filler. Every word contributes to clarity.

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

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

For a simple 0-parameter read-only tool with an output schema, the description is adequate. The word 'recent' is somewhat ambiguous regarding time range, but for a notification retrieval tool this is acceptable overhead.

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

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

The tool has zero parameters, so the baseline is 4 per the rubric. Schema description coverage is trivially 100%, and the description implies no input is needed. No additional parameter semantics are required.

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

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

The description uses a specific verb ('Get') and a clearly defined resource ('recent triggered alert notifications'), which distinguishes it from sibling tools like list_alerts (which lists alert configurations, not notifications). The qualifier 'recent' adds useful scope.

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 list_alerts or get_journal_entry. The description simply states what the tool does without any explicit context, exclusions, or alternative references.

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 and destructiveHint=false, and the description ('Get portfolio statistics') is consistent with those. The description adds the data categories (returns, allocation, risk) but does not disclose additional behaviors such as response formatting, pagination, or required permissions. Given the strong annotations, this is acceptable but not exceptional.

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 concise and well-structured. It opens with a clear purpose statement, then lists the single argument in a standard Args block. Every part earns its place, with no redundant or filler content.

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

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

The tool is simple (one parameter) and has an output schema, so the description does not need to detail return values. It conveys the core purpose and parameter semantics adequately. No critical information appears missing for an agent to decide whether and how to invoke 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?

The schema only provides the parameter name and type, but the description explicitly states 'portfolio_id: The portfolio UUID', clarifying that the value is a UUID. This adds meaningful semantic clarity over the bare schema, effectively compensating for the 0% schema description 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 states the verb 'Get' and the resource 'portfolio performance statistics' with specific dimensions (returns, allocation, risk). This distinguishes it from sibling tools like get_positions or list_portfolios, making its purpose unambiguous.

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

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

The description implies usage context: it is for retrieving performance statistics for a specific portfolio. However, it does not explicitly state when to use this tool over alternatives, nor does it mention any exclusions or prerequisites. The user must infer usage from the name and description.

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=true and destructiveHint=false, so the description's read-only nature adds no new safety info. The description does add that it returns 'current holdings' and the specific value fields, which is useful but not rich behavioral context like pagination, auth requirements, or data freshness.

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 front-loaded with the action, followed by a minimal args line. No wasted words; every part earns its place.

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

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

For a simple single-parameter read-only tool with an output schema and safety annotations, the description is largely complete. It lacks usage guidance and any caveats, but the core purpose and parameter meaning are clear. Slight deduction for not mentioning when to prefer this over get_portfolio_statistics.

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 schema description coverage at 0%, the description compensates by explaining portfolio_id as 'The portfolio UUID', providing format and semantic meaning beyond the schema's bare 'Portfolio Id' title. This is sufficient for a single parameter, though it could explicitly state that it's the portfolio whose positions are retrieved.

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 verb and resource: 'Get current holdings' with the exact fields included (quantity, cost basis, market value, unrealized P&L). This distinguishes it from siblings like list_portfolios (which lists portfolios) and get_portfolio_statistics (which likely returns performance metrics).

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. It does not mention exclusions, prerequisites, or point to sibling tools for related tasks. The description only states what it does, leaving the agent to infer usage context.

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

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

The description adds behavioral context beyond the readOnlyHint and destructiveHint annotations by specifying the filters 'active' and 'for the authenticated user,' which inform the user about the subset of alerts returned. No contradictions 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 a single concise sentence that states the verb, resource, and scope without extraneous words.

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

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

Given the tool's simplicity (no params), the presence of an output schema, and annotations that already cover safety, the one-sentence description is sufficient to convey the tool's purpose and behavior.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameters, and the schema is trivially fully covered.

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

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

The description uses the specific verb 'List' and identifies the resource as 'active price and event alerts' scoped to 'the authenticated user.' This clearly distinguishes it from sibling tools like create_alert and delete_alert.

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

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

The description provides clear context for when to use the tool—when the user needs to see their active alerts. It does not explicitly mention alternatives or when not to use it, but the purpose is unambiguous for a simple listing 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=true and destructiveHint=false, so the read-only nature is covered. The description adds valuable behavioral context beyond annotations by explaining the timing of entry availability and the exclusion of drafts, which helps set expectations for the agent.

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

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

The description is two sentences, front-loading the core purpose and ordering, then adding a single clarifying detail about timing. Every sentence earns its place with no redundancy.

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

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

For a zero-parameter read-only list tool with an output schema present, the description is complete. It answers the key questions—what is listed, in what order, and when the data is available—and provides useful contrast with draft submissions.

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 zero parameters and schema coverage of 100% (vacuously), the baseline is 4. The description does not need to explain parameters, and it correctly focuses on behavior rather than parameter syntax.

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 'List generated daily research journal entries (most recent first)' with a specific verb, resource, and ordering. It distinguishes itself from sibling tools like submit_journal_draft and get_journal_entry by clarifying that only generated entries are listed, not drafts.

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

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

The description provides clear timing context: entries appear only after the end-of-day generation run, and drafts are not listed until then. This implicitly advises when to use this tool (after generation) and when not to use it (for viewing drafts), though it does not explicitly name alternative tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so no safety concerns exist. The description adds useful scoping to the 'authenticated user's research library', but it does not describe pagination, ordering, or return behavior. This is acceptable for a simple zero-parameter read-only tool, but not richly transparent.

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

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

The description is a single, well-structured sentence that front-loads the action and resource. Every word earns its place, and there is no redundancy or filler.

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

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

Given that the tool has no parameters, has an output schema, and is covered by supportive annotations, the description is complete enough for an agent to select and invoke the tool successfully. No additional context is needed for this straightforward read-only listing 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 tool has zero parameters, so there are no parameter details to document. The baseline of 4 applies: the description does not need to compensate for any schema gaps because there are no inputs.

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

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

The description uses a specific verb ('List') and a specific resource ('folders in the authenticated user's research library'), making the tool's action and target clear. It naturally distinguishes itself from sibling tools like list_library_items, create_library_folder, or delete_library_folder.

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

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

The description clearly establishes that this tool is for viewing folders in the user's own library, giving immediate context for when it would be appropriate. It does not explicitly name alternatives or state when not to use it, but the sibling tool names and the precise resource make the intended use fairly obvious.

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 and destructiveHint=false, covering safety. The description adds the behavioral nuance that omitting folder_id lists root-level items, which is useful but does not go further (e.g., no pagination or sorting details). This aligns with the 'with annotations' baseline.

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 long, front-loaded with the primary purpose, and includes an 'Args' section for the parameter. Every sentence earns its place with no redundancy or filler.

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

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

Given the tool's simplicity (one optional parameter, no nested objects, and an output schema present), the description is sufficiently complete. It explains the key behavioral distinction (root vs. folder) and does not need to detail return values since the output schema handles that.

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 provides only the property name, type, and default. The description adds meaning by explaining folder_id is a Folder UUID and that omitting it yields root-level items, which is essential for correct use. This compensates well for the lack of parameter descriptions in the schema.

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

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

Clearly states the tool lists documents in a library folder, with an explicit fallback to root-level items. The verb 'List' and resource 'library items' are specific, and it distinguishes from sibling tools like list_library_folders by focusing on documents rather than folders.

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

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

Provides clear context: use this to list documents, optionally within a specified folder, or at root if no folder is given. It does not explicitly name alternatives or exclusions, but the intended usage is unambiguous given the sibling tools and the optional folder_id parameter.

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 and destructiveHint=false, covering the safety profile. The description adds 'newest first' ordering, which is a useful behavioral trait beyond the annotations. It does not mention pagination or limits, but for a simple read-only operation this 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 highly concise, consisting of one sentence stating the purpose and an Args list. Every word earns its place, and the key 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 single-parameter, read-only tool with an output schema available, the description covers the essential purpose, ordering, and parameter format. It does not describe return values, but the output schema handles that responsibility.

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

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

The description defines item_id as 'The item UUID', which adds format meaning beyond the schema's generic string type. With only one parameter, this sufficiently compensates for the 0% schema description 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 states the tool lists version history for a library document, with a specific ordering (newest first). This distinguishes it from sibling tools like list_library_items (which lists all items) and get_library_item (which retrieves a single item).

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 (retrieve version history for a specific library item) but does not explicitly state when to choose it over alternatives or exclude cases where it is not appropriate. There is no mention of when not to use it, such as needing current content rather than history.

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, openWorldHint, and destructiveHint, covering the safety profile. The description adds the 'authenticated user's' scope, providing some behavioral context, but does not disclose details like pagination, sorting, or response shape. This is adequate but not rich, hence a 3.

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

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

The description is a single, concise sentence that immediately states the action and scope. There is no extraneous information, and the structure is optimally 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?

This is a simple list operation with no parameters, an output schema, and annotations covering safety. The description fully covers the tool's purpose and scope; nothing essential is missing for an agent to select and invoke it correctly.

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

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

The tool has zero parameters, so the schema coverage is trivially 100%. Per the rubric, a baseline of 4 applies when there are no parameters, and the description does not need to compensate for missing parameter details.

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

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

The description uses a specific verb ('List') and resource ('portfolios'), clearly distinguishing it from sibling tools like create_portfolio or get_portfolio_statistics. It also specifies the scope as 'the authenticated user's portfolios', making the purpose unambiguous.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention exclusions or situations where another tool (e.g., get_portfolio_statistics, create_portfolio) would be more appropriate, leaving the agent without comparative 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 readOnlyHint=true and destructiveHint=false. The description adds useful context about the scope (authenticated user's) and the return content (symbols), which goes beyond the structured 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, compact sentence. It front-loads the verb and resource, and adds only the essential scope and return 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 simple list operation with no parameters and annotations covering the safety profile, the description is complete. It identifies the scope (authenticated user's) and what is included (symbols), and an output schema exists for further details.

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

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

The tool has zero parameters, so the description carries no parameter explanation burden. Schema coverage is 100% by default, and with no parameters, the baseline rating of 4 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 lists the authenticated user's watchlists and their symbols, using the specific verb 'list' and resource 'watchlists'. This distinguishes it from sibling tools like create_watchlist and update_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 provides clear context: it retrieves the current user's watchlists. It does not explicitly mention alternatives or exclusions, but the purpose is unambiguous enough that an agent can infer when to use it.

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

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

Annotations already declare that this is not read-only and not destructive, so the bar is lower. The description adds that moving to root is possible by omitting parent_id. However, it doesn't mention potential side effects like whether child items move along or if the operation is reversible.

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

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

The description is short, front-loaded with the main purpose, and uses a clear Args block. No unnecessary words or repetition.

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

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

For a simple move operation, the description covers the operation and parameters. It doesn't explain return values, but an output schema exists so that is not needed. It could mention whether the move is recursive or if there are prerequisites, but the essentials are 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 has no parameter descriptions (0% coverage), but the description's Args section fully explains both parameters: folder_id is the UUID to move, and parent_id is the new parent or null for root. This adds significant meaning beyond the schema.

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

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

The description clearly states the action (move), the resource (library folder), and the scope (under a different parent or root). It distinguishes itself from siblings like 'move_library_item' (moving items) and 'rename_library_folder' (renaming).

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 it clear this is for moving library folders, and the sibling names provide context (e.g., move_library_item for items). It doesn't explicitly exclude alternatives, but the scope is unambiguous.

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 the operation is not read-only and not destructive. The description adds the root-destination nuance but does not disclose other potential side effects (e.g., whether the item is removed from its previous folder), which are fairly obvious for a move operation. Given annotation coverage, the description provides adequate but not exceptional transparency.

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

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

The description is a single clear sentence plus a compact Args block that adds value (null behavior). No wasted words or redundancy beyond the schema.

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

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

For a simple two-parameter move operation with an output schema and annotations, the description provides all necessary context. It covers purpose, parameters, and destination semantics completely.

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

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

Schema description coverage is 0%, but the description's Args section fully explains both parameters, including the item_id as UUID and folder_id as destination with null-for-root behavior. This fully compensates for the missing 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 description uses a specific verb ('Move') and resource ('library document'), and clarifies destination options ('different folder' or 'root'). It clearly distinguishes from sibling tools like move_library_folder and delete_library_item.

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

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

The description clearly implies when to use this tool—when moving an item between folders. It does not explicitly exclude alternatives, but the context is sufficient and unambiguous.

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 adds no behavioral context beyond the annotations. Annotations already declare readOnlyHint=false and destructiveHint=false, and the description simply repeats the rename action without mentioning side effects, permissions, reversibility, or effect on folder contents. It provides no additional transparency beyond what 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 extremely concise, with the purpose stated first in a single sentence, followed by a minimal Args section that adds necessary parameter details. Every sentence earns its place, and there is no redundancy or fluff.

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

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

Given the tool's simplicity (two required parameters, an output schema present, and a clear rename operation), the description covers the essential invocation details. It does not mention potential error conditions (e.g., folder not found, duplicate name), but these are not critical for a straightforward rename and are partly handled by the presence of an 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?

With schema description coverage at 0%, the description compensates by defining both parameters: 'folder_id: The folder UUID' and 'name: New folder name'. This adds meaningful semantics beyond the bare schema (which only lists types and titles), clarifying that folder_id is the unique identifier and name is the replacement name.

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

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

The description 'Rename a library folder' clearly specifies the action (rename) and the resource (library folder), distinguishing it from sibling tools like move_library_folder, create_library_folder, and delete_library_folder. It is a specific verb+resource statement, 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?

No explicit when-to-use or alternative guidance is provided. The usage is implied by the tool's name and purpose—it is for renaming an existing library folder—but it does not state when it should be preferred over move or delete, nor any prerequisites like folder existence.

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 reveals key behaviors: it is a write operation (logging a bug), has a daily rate limit, and data goes to the same inbox as the terminal bug button. This adds context beyond the minimal annotations (readOnlyHint=false, destructiveHint=false) and discloses no contradictions.

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 concise and front-loaded with key purpose and usage. However, the parameter list uses a markdown 'Args:' block that is somewhat readable but could be more structured (e.g., bullet points) for easier parsing. Still, no unnecessary sentences.

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 0% schema coverage and no enums, the description covers everything needed: parameter semantics, use case, rate limit, and admins' needs. The output schema exists, so return values need not be explained in the description. The tool is simple and the description is fully adequate.

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

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

Schema description coverage is 0%, so the description fully compensates. Each parameter is explained with context: description's character range (10–2000), ticker as stock symbol, section as tab names, and page_url as optional terminal link. This adds substantial meaning beyond the schema titles.

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 'Log a bug' with a specific verb and resource. It also mentions the rate limit (5 per user per day) and distinguishes itself from sibling tools, none of which relate to bug reporting.

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?

Explicit guidance is provided: use only when the user asks or when a real data/UI error is confirmed, and do not file speculative bugs. It also advises passing ticker/section for admin convenience, giving clear when-to-use and what-to-avoid instructions.

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

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

Annotations already indicate readOnlyHint=false, destructiveHint=false, so the description correctly implies a non-destructive write operation (queuing). It adds crucial behavioral details: it consumes a monthly grant, returns as soon as queued, and does not support polling. The only gap is that it doesn't explicitly state the job's asynchronous nature or what happens if the grant is exhausted, but overall the transparency is high.

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

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

The description is extremely concise: only one paragraph plus an Args section. Every sentence provides critical information—purpose, payment method, plan limits, re-running behavior, and response semantics. No wasted words.

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

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

Given the tool has one parameter, no nested objects, and no output schema visible for the queued result, the description covers the core workflow well. It mentions what the call returns (immediate queuing acknowledgment) but does not explain how to retrieve the analysis results later, which could be a gap for the agent. However, the lack of output schema reduces the need for return value 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 0%, so the description must compensate. It defines the single parameter "ticker" with an example, which adds meaning beyond the schema's type-only definition. A brief explanation of what the parameter represents would be ideal, but the provided example "AAPL" is sufficient for correct usage.

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

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

The description uses the specific verb "Queue" and resource "full DeepDive suite for a stock using a monthly custom-run grant." It clearly identifies the action and distinguishes from sibling tools like finance_search or list_alerts, which are not analyses.

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

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

Explicitly states when to use this tool (queue a DeepDive analysis) and when not to (prepaid search credits cannot pay for this). Provides tiered usage limits, explains that re-running an unlocked ticker does not consume a grant, and warns that the call returns immediately without polling. No alternatives are named, but the context is clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds helpful context about scoping to the authenticated user's library and the max result cap of 50, but it does not detail ranking, pagination, or result shape beyond what the output schema provides.

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 concise, with a clear front-loaded purpose sentence followed by a compact Args block. Every sentence adds information, and there is no redundancy with the schema beyond necessary clarification.

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 an output schema present, the description does not need to explain return values. It adequately covers the tool's purpose, user scope, and parameter behavior, and annotations cover safety. A minor gap is lack of mention of result sorting or that it searches document content vs metadata, but overall it is complete for a simple search 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 0%, so the description must compensate. It defines query as 'Search terms' and limit as 'Max results (default 20, capped at 50),' adding the cap information that is not present in the schema. This is sufficient for both parameters, though 'Search terms' is somewhat generic.

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: 'Full-text search across the authenticated user's library documents.' It identifies the resource (library documents) and scope (authenticated user's), and distinguishes itself from sibling finance_search by specifying 'library documents' rather than financial 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 usage for full-text searching within the user's library, but it does not explicitly state when to use this tool over alternatives like list_library_items or finance_search, nor does it mention exclusions. The context is clear but lacks direct 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 only indicate non-readonly and non-destructive. The description adds critical behavioral detail: the draft is accepted immediately, the readable entry is generated at end of day, and the draft id cannot be used with list_journal/get_journal_entry until then. This is beyond what 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 compact and front-loaded with the primary action, followed by essential caveats. The Args section is clearly structured. Every sentence adds value without redundancy.

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

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

For a tool with two-phase behavior and an id mismatch, the description covers all key points: same-day resubmissions, immediate acceptance, automatic generation, appearance in list_journal, and the temporary id discrepancy. It is complete despite the lack of parameter details in the 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 0%, but the description provides an Args section explaining entry_date as 'Day the draft is for (YYYY-MM-DD)' and content as 'Draft text.' This compensates for the schema's bare property names and gives format 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 opens with 'Submit a journal draft for a day,' a specific verb+resource+scope statement. It further distinguishes itself from siblings like list_journal and get_journal_entry by clarifying that the returned draft id is not the same as the entry id until the end of day.

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

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

The description provides clear context for use: same-day resubmissions are retained as separate drafts, and the entry appears in list_journal only after end-of-day processing. It doesn't explicitly name alternatives or when-not-to-use, but the context is sufficient for an agent to select this tool for draft submission.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the description adds value by disclosing that content edits create a new version, a key behavioral nuance not captured in annotations. It does not discuss auth requirements or error conditions, but the versioning detail significantly enhances transparency beyond the structured data.

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

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

The description is concise and well-structured: a single sentence summarizing the action and versioning effect, followed by a clean Args list. Every sentence contributes meaning, with no redundant or filler content.

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

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

The description covers the essential behavior (update title/content, versioning on content edits) and the output schema exists, so return values are documented elsewhere. However, it is ambiguous whether title-only changes also create a new version, and it does not mention how to view old versions (sibling list_library_item_versions) or target a specific version. This leaves some contextual gaps, but overall the tool is adequately defined for a straightforward update 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?

With schema description coverage at 0%, the description compensates by listing all three parameters with brief but meaningful explanations: item_id is 'the item UUID', title is 'New title (optional)', and content is 'New markdown body (optional)'. This adds clarity beyond the bare schema, though it does not explore edge cases like null vs omitted or validation rules.

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

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

The description clearly states the tool's purpose: 'Update a library document's title and/or content' with the additional detail that content edits create a new version. This distinguishes it from sibling tools like create_library_item, delete_library_item, and list_library_item_versions.

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 modifying an existing library item, which is clear from the context. However, it does not explicitly state when to use this tool over alternatives or mention any exclusions or prerequisites beyond versioning behavior. The versioning note is helpful but does not fully clarify usage boundaries.

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 states it updates a watchlist but does not disclose whether the symbol list is replaced entirely or merged, or what happens if name or symbols are null. Annotations indicate it's a write (readOnlyHint=false) but not destructive (destructiveHint=false), yet the description adds no further behavioral context.

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

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

The description is concise with a one-sentence summary followed by an Args list. It is front-loaded and free of fluff, but the Args block partially duplicates schema information and could be streamlined.

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 update tool, the description should clarify that symbols replaces the entire list and note any permissions or existence requirements. The output schema may cover return values, but key behavioral details are missing, making the description incomplete for a mutation 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 description adds brief semantic labels: 'The watchlist UUID' for watchlist_id, 'New name (optional)' for name, and 'Updated list of symbols (optional)' for symbols. This goes beyond the raw schema but lacks detail on symbol format, replacement behavior, or validation rules.

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 updates a watchlist's name and/or symbols, identifying the specific action and resource. This distinguishes it from sibling tools like create_watchlist and list_watchlists, though it does not explicitly name an alternative.

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

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

There is no guidance on when to use this tool versus alternatives, such as creating a new watchlist or deleting one. The description does not mention any prerequisites or conditions for updating, leaving the decision context unspecified.

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