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

With no annotations, the description fully discloses behavior: bulk write via SOAP, partial success, null fields, error types. Covers success/failure handling and warnings. Provides detailed return schema and error classes.

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?

Well-structured with Args, Returns, Raises, Example, Notes. Front-loaded key info. Slightly long but each section earns its place. Could be tightened slightly.

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?

No output schema exists, so description fully covers return values, errors, and partial success behavior. Provides enough context for correct usage, including edge cases like null fields and warnings.

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

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

Schema coverage is 100% but description adds significant value: specifies required fields (Description, FatherKey), optional fields, and provides a concrete example. Options parameter is explained clearly.

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: batch create tasks via SOAP, faster than individual calls. It distinguishes from siblings like create_task and batch_delete_tasks by emphasizing bulk creation and speed.

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 (bulk creation for speed) and when not (Beta MCP cannot create tasks). Provides alternatives like create_task for single creation and read_task for verification. Includes caution about duplicates and external keys.

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

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

No annotations exist, so the description carries full burden. It discloses non-atomicity and per-key success/failure returns, which is valuable. However, it does not describe output format, error conditions, permissions, or rate limits. The behavioral disclosure is adequate but not comprehensive.

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 (3 sentences) and well-structured, starting with operational context, then action, then behavioral note. Every sentence adds value, and it avoids verbosity. Slightly more could be trimmed, but it's effective.

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 1 parameter and no output schema, the description covers purpose and key behavioral aspects (non-atomicity, retry logic). However, it omits response structure, error handling, and prerequisites. The agent likely needs more detail to correctly invoke and interpret results, leaving gaps.

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

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

With 0% schema coverage, the description should compensate but only mentions 'task_keys' as the parameter. The name is self-explanatory, but no format, constraints, or examples are provided. The description adds minimal value beyond the parameter name, leaving the agent to infer semantics.

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

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

The description explicitly states 'Delete multiple tasks in bulk using the SOAP TaskService.' It clearly identifies the action (delete), resource (multiple tasks), and distinguishes from siblings like delete_task (singular) and batch_create_tasks. The note about Beta MCP inability to delete tasks adds operational context.

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

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

The description explains non-atomic behavior and provides retry guidance: callers can safely retry only failed keys. This helps usage decisions. However, it does not explicitly contrast with delete_task for single deletions or state when not to use this tool (e.g., if atomicity is required).

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

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

No annotations are provided, but the description fully compensates. It states it's a write operation, explains default date behavior, and details warning handling ('non-fatal', 'projects are created successfully even with these warnings'). It also describes the return value (created project data with possible warnings). This is comprehensive.

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 with sections (Args, Returns, Example, Notes). It front-loads key context (local write operation). However, there is slight redundancy in warning explanations appearing twice (in Returns and Notes). Overall, it is efficient for the tool's complexity but could be tightened slightly.

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 parameter count (3), one required parameter, nested objects, and no output schema, the description is very complete. It covers input format, defaults, output behavior, warning semantics, and references external Swagger docs. Examples illustrate typical usage. No gaps are apparent.

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

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

The schema covers all three parameters (data, attributes, create_default_tasks). The description adds significant value beyond the schema: it breaks down required vs optional fields for 'data', provides ISO 8601 format examples, explains the effect of 'create_default_tasks', and gives full JSON examples. This greatly aids 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 clearly states the tool creates a new project using the Planview Portfolios API. It distinguishes from sibling tools like update_project or delete_project by specifying 'Create a new project' and detailing the required payload. The verb+resource pairing is specific and unambiguous.

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

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

The description explicitly mentions that Beta MCP is read-only, so this tool is for local write operations. It provides clear instructions on required fields and defaults. However, it lacks explicit guidance on when not to use this tool versus other creation tools (e.g., create_task). The non-fat warning handling is well explained.

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

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

With no annotations, the description compensates fully by detailing behavioral traits: write operation, SOAP API null field behavior, suggestion to use read_task for verification, non-fatal warnings, field sorting, and auto-filtering of None values. It also lists error types.

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 lengthy but well-structured with clear sections (Args, Options, Returns, etc.) and front-loaded with key purpose. Some redundancy exists (e.g., repeating 'creates a task' in multiple sentences), but overall efficient for the complexity.

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 no output schema, the description thoroughly documents return values, error types, and notable behaviors (null fields, warnings). It covers the complex nested parameters and provides real-world usage context, making the tool fully understandable.

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 extensive meaning beyond the input schema: it lists all fields within task_data (required and optional), specifies formats (PascalCase, ISO 8601), provides examples, and notes about sorting and filtering. Schema coverage is 100% but description enriches it significantly.

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 it creates a task using the SOAP TaskService, specifying it is a write operation. This distinguishes it from sibling tools like read_task, batch_create_tasks, and delete_task.

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 includes usage context such as 'LOCAL — write operation' and that Beta MCP cannot create tasks, and provides examples and notes on preventing duplicates. However, it lacks explicit guidance on when to use this tool versus alternatives like batch_create_tasks.

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

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

No annotations are provided, so the description carries the full burden. It warns that the operation deletes child data and lists specific exceptions, adding valuable behavioral context beyond the schema.

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

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

The description is structured but contains redundancy (e.g., 'Delete a project by ID.' appears twice). It could be more concise while retaining 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?

With no annotations or output schema, the description covers purpose, parameter, return value, and errors. It is fairly complete for a simple delete 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?

Schema coverage is 100%, and the schema already describes the parameter. The description repeats the parameter info without adding new semantic insight 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 it deletes a project by ID and emphasizes the destructive nature. It distinguishes itself from sibling tools like create_project and update_project.

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

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

The description notes that Beta MCP is read-only and cannot delete projects, providing context for when the tool is usable. It includes a warning about destructive behavior but does not explicitly mention 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?

The description discloses that deleting a task will also delete all its child tasks, and lists possible error types. With no annotations provided, these behavioral details are important and adequately 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 short and front-loaded with the main action, but it contains slight redundancy (two similar sentences about using SOAP). The Args/Returns/Raises structure is well-organized.

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 (single parameter, no output schema), the description adequately covers side effects (child deletion), parameter format, error conditions, and return type. It does not fully explain the return dict structure, but this is acceptable without 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?

Despite the schema having 0% coverage, the description's Args section adds significant meaning: it specifies the parameter format (key://, search://, or ekey:// URIs) and describes its role beyond the schema's type 'string'.

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 explicitly states 'Delete a task using SOAP TaskService.' It clearly identifies the action (delete) and resource (task), and distinguishes itself from siblings like batch_delete_tasks and delete_project.

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 includes a note that Beta MCP cannot delete tasks, which implies when not to use it. However, it lacks explicit guidance on when to use this tool over alternatives like batch_delete_tasks or delete_project, and does not provide context for prerequisites.

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

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

With no annotations, the description must disclose all behavioral traits. It does so by explaining fallback behavior, optimization paths, config data usage, and return types. However, it does not explicitly state that the tool is read-only or if there are side effects, though it is implied.

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 with paragraphs, parameter list, returns, and example. It is front-loaded with purpose. It is somewhat long but each sentence adds value, and the organization aids readability.

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 complexity (7 parameters, no output schema, no annotations), the description is remarkably complete: it covers behavior, parameter details, return values, and provides multiple examples. An agent would have sufficient context to use the tool correctly.

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

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

Schema description coverage is 0%, but the description compensates by thoroughly explaining each parameter in the Args section, including defaults, behavior, and examples. This adds significant value over the bare 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 purpose: 'Discover financial plan information with smart fallback.' It explains the fallback mechanism and distinguishes from siblings like read_financial_plan and load_financial_plan_from_reference by highlighting the smart fallback and configuration data optimization.

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 detailed usage guidance: when to use the fast path (skip_target_read=True for new projects) and standard path, and how to reduce payload (include_entries=False). Examples are given. However, it does not explicitly contrast with sibling tools or state when not to use this tool.

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

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

No annotations provided, so description carries full burden. It describes a read operation but does not disclose safety, authentication needs, or rate limits. The example provides some return transparency, but more detail on error cases or pagination would improve score.

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?

Concise and well-structured: includes a header, a clear one-sentence purpose, parameter specification, return description, and an example. No unnecessary 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 (one required param, no output schema), the description fully covers what an agent needs: parameter meaning, return format via example, and purpose. No gaps.

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

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

Schema has one required integer parameter 'objective_id' with 0% coverage. The description adds 'The ID of the objective' in Args, which provides semantic meaning beyond the schema type.

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', the resource 'key results', and the context 'for a specific objective'. It distinguishes from sibling tools like list_all_objectives_with_key_results and list_objectives.

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

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

No guidance on when to use this tool versus alternatives. The description mentions no Beta MCP equivalent but does not provide explicit when-to-use or when-not-to-use context relative to siblings.

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

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

No annotations are provided, so the description carries the full burden. It indicates a read operation ('read by ID'), which is clear. However, it does not mention potential error cases, response format, or any side effects, but given the simplicity of the tool, this is adequate.

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 very concise, containing only two sentences. The first sentence provides usage guidance and disambiguation, the second states the core purpose. Every word 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 simple read tool with two fully described parameters and no output schema, the description is complete. It covers what the tool does, when to use it (with ID), and when to use alternatives. No additional information is necessary for effective tool invocation.

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

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

Schema description coverage is 100%, so baseline is 3. The tool description does not add any additional meaning beyond the schema's parameter descriptions, which are minimal ('Project id.' and description of attributes). No elaboration or usage context is provided for the parameters.

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

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

The description clearly states it gets a single project by ID, using specific verb+resource (Get a single project by id). The bracketed note explicitly distinguishes from listing/searching siblings, referencing listProjectsByPortfolioId and searchProjectByName. This makes the tool's scope unambiguous.

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

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

The description explicitly says when to use this tool (for a single project read by ID) and when not to (listing/searching across a portfolio, pointing to alternative Beta MCP tools). This provides clear guidance on tool selection.

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

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

No annotations are provided, so the description carries the full burden. It implies a simple listing operation with no side effects, but does not explicitly state that it is read-only or describe any other behavioral traits.

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 two sentences, front-loading the key action and providing immediate usage guidance without any 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?

For a simple list tool with no output schema, the description is complete: it identifies the resource, the action, and directs users to an alternative for different needs.

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

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

The tool has zero parameters, and schema coverage is 100%. The description adds no parameter info, but none is needed; baseline for 0 params is 4.

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 project attributes ('List available project attributes') and distinguishes it from searchAttributes for natural-language search, providing a specific verb and resource.

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 explicitly tells when to use this tool (raw list) versus the alternative searchAttributes tool for natural-language search, but does not address potential confusion with get_work_attributes among siblings.

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

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

No annotations are provided, so the description carries the full burden. It explains internal behavior (calling list_work and rebuilding tree) and lists output fields, but does not disclose safety (read-only), rate limits, or potential side effects. For a read operation, this is adequate but not fully 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 well-structured with a note, purpose, implementation detail, and output shape. It is succinct without unnecessary repetition. The local/alternative note adds context but is slightly extraneous.

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 no output schema, the description provides a detailed node shape and explains the tree reconstruction logic. Missing details like pagination or error handling, but for a tree-building tool, it covers key aspects adequately.

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 low (33%), but the description adds meaning for project_id by showing its usage in the query. max_depth has schema description. include_milestones is mentioned only in schema with a default; the description does not clarify its effect. Overall, partial compensation.

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

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

The description clearly states the tool retrieves a project's WBS as a nested, lean tree, differentiating it from a flat hierarchy alternative. It specifies it calls list_work and rebuilds parent/child structure, 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 a clear alternative (Beta MCP's getWorkHierarchy) for flat views, implying this tool is for nested views. However, it does not explicitly compare with sibling tools like list_work or get_work, leaving some guidance implicit.

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

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

No annotations are present, so the description must fully convey behavioral traits. It only states 'read' but omits permissions, side effects, or return format. Basic safety is implied but insufficiently 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 short, using two sentences. However, the second sentence ('Get a single work item by id') is redundant with the first, slightly reducing conciseness.

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

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

Given no output schema, the description should explain what the tool returns. It fails to do so, leaving the agent uncertain about response structure. Adequate for a simple tool but incomplete.

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

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

Schema coverage is 50% with only 'attributes' described. The description adds no extra meaning beyond 'by ID' for work_id. It does not clarify the format or constraints of parameters.

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

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

The description clearly states the tool reads a single work hierarchy node by ID, including portfolio-level nodes. It distinguishes from a sibling tool (listProjectsByPortfolioId) for listing projects, providing specific verb and resource.

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 explicit usage guidance by directing users to an alternative tool for listing projects. However, lacks further context on when to prefer this over other siblings like get_project or list_work.

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

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

No annotations are provided, so the description carries the full burden. It reveals no behavioral details such as permissions required, rate limits, or whether the list is static or dynamic. The phrase 'raw work attribute list' is vague.

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 two short sentences, front-loaded with the main action. No unnecessary 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 no parameters and no output schema, the description provides minimal context. It does not explain the return format or intended use beyond 'get attributes'. For a simple list tool, it is adequate but not complete.

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

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

With 0 parameters and 100% schema coverage (empty schema), the description adds no parameter information, but baseline is 4 for zero-parameter tools. No additional meaning is needed.

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

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

The description clearly states the tool gets available work attributes, distinguishing it from sibling tools like get_project_attributes. The mention of 'raw work attribute list' specifies the output type, but does not detail what attributes are covered (e.g., custom vs system).

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

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

The description explicitly provides an alternative for natural-language attribute search using Beta MCP's searchAttributes, guiding when not to use this tool. This is an excellent usage guideline.

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

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

No annotations are provided, so the description bears full responsibility. It discloses that the tool fetches all objectives, optionally includes key results, and supports pagination with a limit parameter. It does not mention destructive actions (none), rate limits, or authentication, but for a read-only list tool, the disclosure is adequate.

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 with a concise main sentence followed by clear Args and Returns sections. It is not overly verbose, though the docstring format adds some extra length. Every sentence serves a purpose.

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

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

With no output schema, the description includes a sample return value showing structure and field names. It covers parameter effects and pagination. For a simple list tool, the description is complete and self-contained.

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

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

The input schema has 0% description coverage, but the description fully explains both parameters: limit (default 500, max 500, min 1) and include_key_results (default True, effect on response). This adds substantial 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 it lists all objectives with their key results. It distinguishes from sibling tools like 'list_objectives' (which likely does not include key results) and 'get_key_results_for_objective' (which gets key results for a single objective). The verb 'list' and resource 'objectives with key results' are specific.

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

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

The description explains it's a convenience function, implying it's for retrieving both objectives and key results in one call. It does not explicitly state when to use this vs. alternatives like 'list_objectives' or 'get_key_results_for_objective', but the intent is clear from context. Slight room for more explicit guidance.

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

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

No annotations provided, but the description discloses the output is organized by category with optional filtering, and that fields are writable. Does not detail return structure beyond categories, but adequate for a listing tool.

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

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

Five sentences, front-loaded with purpose and local context. No wasted words; every sentence adds information (local hint, sibling reference, parameter details, categories list).

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 no output schema, the description explains the return is categorized and lists all categories. Parameter is fully documented. Ties into sibling write tools, making it self-contained for the 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 description adds significant value over the schema by listing all valid category values (e.g., core_identity, dates), which the schema does not provide. Schema coverage is 100%, but description enriches usage clarity.

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 available writable project fields for write operations, distinguishing from read-side attribute discovery via sibling tool reference.

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 says to use this for discovering field IDs for write operations (update_project, create_project) and directs read-side usage to Beta MCP's searchAttributes instead.

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

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

With no annotations, the description carries full burden. It discloses that it's a read operation (no destructive behavior), covers pagination and filtering behavior, and specifies the return format. However, it does not mention authentication needs or rate limits.

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 one-line purpose, followed by Args, Returns, and an Example. Every part adds value without unnecessary verbosity.

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 no output schema, the description provides a return type and example, making it fairly complete for a list tool with pagination. It lacks error handling or authentication details, but those are not critical for basic usage.

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 low (33%), but the description adds meaning for all parameters: clarifies 'ids' as comma-separated, specifies default/max for 'limit', and default for 'offset'. The example output further clarifies 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 clearly states the action ('List all objectives') and the resource ('from the OKRs API'). It also mentions filtering and pagination, distinguishing it from siblings like 'list_all_objectives_with_key_results'.

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 listing objectives but does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives. The mention of 'No Beta MCP equivalent' provides context but not actionable direction.

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

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

No annotations provided, so description carries full burden. Discloses 'limited filtering support' but lacks details on pagination, rate limits, or potential side effects. Does not contradict annotations since none exist.

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?

Relatively short (two sentences plus a bracket note). The note in brackets is slightly confusing but overall efficient. Could be more structured.

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?

No output schema, no annotations. Description covers filter and fields well but ignores attributes. Lacks specification of response format or pagination. Moderate completeness for a list tool with three parameters.

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

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

Schema coverage is 100%, baseline 3. Description adds value with an example for filter and explains that fields trims payload. Attributes parameter is not mentioned in description, so not fully leveraged.

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 'List work items using a filter string' with a specific verb and resource. Distinguishes from sibling by mentioning 'For portfolio-scoped project lists, use Beta MCP's listProjectsByPortfolioId instead.'

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 provides when to use ('LOCAL — query work items with filter') and when not to use ('limited filtering support, alternative for portfolio-scoped'). Gives examples and notes on field trimming.

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

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

With no annotations, the description discloses the copy behavior, default dry-run mode, and heavy-operation warning. It does not detail side effects (e.g., overwrite behavior) or error handling, leaving some gaps for a mutation tool.

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

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

The description is short and structured, front-loading the purpose. The internal developer note about local/Beta could be trimmed, but overall it's efficient and earns its place.

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

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

Given 5 parameters, no output schema, and no annotations, the description covers the main functional flow but lacks detail on return values, parameter ranges, and edge cases. It is minimally viable but not fully complete for a complex copy 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?

Only the 'confirm' parameter gets partial explanation beyond the schema. Other critical parameters like 'version_key' and 'scale_factor' are unexplained, and schema coverage is only 20%, so the description fails to compensate adequately.

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 (load) and resource (financial plan) with a specific action (copying from reference project). It distinguishes from siblings like 'discover_financial_plan_info' and 'read_financial_plan' by focusing on copying.

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

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

The description explicitly mentions the dry-run default and warns that it's a heavy operation, advising to preview first. However, it does not specify when not to use this tool or compare with alternatives like 'upsert_financial_plan'.

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 indicates the tool is a read-only health check, but does not explicitly state safety (e.g., non-destructive). With no annotations, the agent must infer that 'ping' is safe. Additional details about rate limits or side effects would improve transparency.

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

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

Two sentences, both front-loaded with the key context '[LOCAL — auth health check]' and the action 'Call secured ping.' No unnecessary 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?

For a simple ping tool with no parameters and no output schema, the description provides sufficient context to understand its purpose and use. It could briefly mention the expected response (e.g., success/failure), but is otherwise 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?

There are no parameters; the input schema is empty with 100% coverage. The description adds no parameter details, which is acceptable as there is nothing to add 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 it is an 'auth health check' and instructs to 'Call secured ping to verify credentials.' This distinguishes it from sibling tools, which are all CRUD operations on tasks, projects, etc.

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

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

The description explicitly marks it as LOCAL and for auth health checking, implying it is used to verify the server's connection credentials. While no alternatives are mentioned, the context is clear given that no sibling tool serves a similar function.

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

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

No annotations exist, so description carries full burden. It openly describes it uses SOAP service, reads structure, returns specific data, and lists possible exceptions. No hidden side effects are relevant for a read operation.

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

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

Well-structured with summary, args, returns, raises, and example. Every sentence adds value. No redundancy, and the length is appropriate for the complexity.

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?

Covers return values in detail despite no output schema, and explains errors. Minor ambiguity about interaction between fields and summary parameters, but overall complete.

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

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

Schema coverage is only 20%, but description provides detailed explanations for all 5 parameters, including examples for keys and behavior of boolean flags like include_entries and summary.

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 it reads a financial plan for a project, specifying the resource and action. It explicitly distinguishes itself from the sibling tool upsert_financial_plan by advising to use this to discover available accounts before adding lines.

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 guidance: use to discover accounts before upserting. Includes example usage. Lacks explicit when-not scenarios, but the workflow is well-implied.

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

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

Without annotations, the description fully discloses the behavior: it uses SOAP API, reads by key, returns a TaskDto2 dict, and raises specific errors (PlanviewValidationError, PlanviewNotFoundError, etc.). No destructive action implied.

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?

Description is front-loaded with context and alternatives, then explains usage and errors. While thorough, it is slightly verbose with the full error list and example block; could be tightened slightly but still effective.

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

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

For a simple read tool with one parameter and no output schema, the description covers purpose, usage guidelines, parameter semantics, error handling, and return type. Nothing essential is missing.

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

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

Schema coverage is 100% with one parameter (task_key). The description adds significant value by providing the exact formats (key://, search://, ekey://) and concrete examples, going beyond the schema's minimal description.

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

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

The description clearly states it reads a task by key using SOAP API, with a specific verb ('read') and resource ('task'). It distinguishes itself from siblings by noting that for richer queries with custom attributes, other tools should be used.

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 provides when to use this tool (reading by key) and when to use alternatives (getTasksByProjectIds or getTasksByTaskIds for custom attributes). Also notes the SOAP nature and key formats.

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

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

No annotations provided, so description carries full burden. Discloses write operation, partial updates, case sensitivity, business rule overrides, duration calculation, lifecycle constraints, StructureCode format, and PPL-only fields. Comprehensive for a mutation tool.

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

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

The description is detailed but well-structured with bullet points for important constraints. Front-loaded with purpose. Every sentence adds value, though slightly verbose. Good organization aids readability.

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 tool complexity (3 params, nested objects, many constraints) and no output schema, the description covers numerous behavioral aspects and constraints. Lacks explanation of return value, but otherwise thorough.

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

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

Schema description coverage is 67%. The description adds significant value for the 'updates' parameter: field ID case sensitivity, duration calculation, lifecycle constraints, StructureCode format, and reference to list_field_reference(). For 'project_id' and 'attributes', minimal extra info, but overall adds meaning beyond 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 'Update an existing project (partial payload)', with a specific verb and resource. It distinguishes from sibling tools like create_project, delete_project, and multiple read-only 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?

Provides guidance on when to use (partial updates), constraints (case-sensitive fields, business rules), and suggests list_field_reference() for writable fields. Does not explicitly contrast with all siblings but gives clear 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?

Without annotations, the description partially fulfills the burden by noting it is a write operation, uses PATCH for partial updates, and may fail with HTTP 405. But it lacks details on side effects, permissions, or idempotency.

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, front-loaded with critical context (LOCAL, write), and efficiently covers purpose, usage, and a caveat. 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?

Given no output schema and 3 parameters, the description explains the operation and potential failure but does not describe the successful response format. It could be more complete for a mutation 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 coverage is 67%, so baseline is 3. The description adds an example field (ExecType) but does not augment parameter descriptions beyond what the schema provides for 'updates' and 'attributes'.

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 'Update' and the resource 'work item', and specifies it handles partial payloads via PATCH. It distinguishes from sibling tools like update_project by focusing on work items.

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 important context: the tool is a local write operation, not available in Beta MCP. It also notes that some instances reject PATCH and that the tool returns a clear error. However, no explicit alternatives or when-not-to-use guidance is given.

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

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

With no annotations, the description fully discloses behaviors: SOAP API may return empty Lines array but data is persisted, warnings are non-fatal, field names must be PascalCase, and lists known SOAP API behaviors. 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 very thorough but excessively long (~800 words). While well-structured with sections, it could be more concise. The core message is front-loaded, but the length may hinder quick parsing.

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 complex tool with nested objects and no output schema, the description covers all aspects: parameters, return values, errors, examples, common errors with solutions, and known SOAP behaviors. It is complete and self-contained.

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

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

The schema only describes 'plan_data' as an object, but the description adds extensive semantic detail: required fields, optional fields, examples for minimal usage and Key-based usage, notes on PascalCase, and detailed structure for FinancialPlanLineDto and EntryDto.

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 name and description clearly state 'upsert (create or update) a financial plan' using SOAP FinancialPlanService. It distinguishes itself from siblings like read_financial_plan and discover_financial_plan_info by explicitly mentioning verification and key discovery.

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 explicit guidance on when to use alternatives: 'Use read_financial_plan() to verify' and 'Use discover_financial_plan_info() to find valid keys.' Includes common errors and solutions, and states that for new projects, the tool creates the plan if it doesn't exist.

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