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

With no annotations provided, the description carries the full burden of behavioral disclosure. While it states this is a creation operation, it doesn't describe what happens on failure, whether the operation is idempotent, what permissions are required, or what side effects might occur. The mention of 'upsert' hints at update behavior but doesn't explain the implications. For a mutation tool with zero annotation coverage, this is insufficient.

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 clear sections (Args, Returns) and uses bullet-like formatting for parameters. Every sentence earns its place, though the opening statement could be slightly more front-loaded with context about ArgoCD. Overall, it's appropriately sized for a tool with many parameters.

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

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

Given the complexity (13 parameters, mutation operation, no annotations, no output schema), the description does well on parameter documentation but lacks crucial behavioral context. It doesn't explain what 'application details' are returned, error conditions, or operational implications. For a creation tool in a deployment system, this leaves significant gaps in understanding how to use it effectively.

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 and 13 parameters, the description provides excellent compensation by documenting every parameter with clear semantics, required status, and default values. It adds substantial meaning beyond what the bare schema provides, transforming a completely undocumented parameter set into a well-explained one.

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 specific action ('Create a new application') and resource ('in ArgoCD'), distinguishing it from siblings like delete_application, update_application, and list_applications. It provides a complete verb+resource+context statement that leaves no ambiguity about what this tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives like update_application (which has an 'upsert' parameter that could overlap) or when creation might fail. There's no mention of prerequisites, dependencies, or typical use cases that would help an agent choose between this and sibling tools.

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

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

With no annotations provided, the description carries full burden but only minimally discloses behavior. It mentions 'cascade' and 'propagation_policy' parameters which hint at deletion behavior, but doesn't explain what 'delete application resources' entails, potential side effects, permissions needed, or error handling. For a destructive tool, this is inadequate.

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

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

The description is appropriately sized and front-loaded with the core purpose. The Args/Returns structure is clear, though the 'Returns' section is vague ('Success message or error details'). No redundant sentences, but could be slightly more concise.

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

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

For a destructive tool with 4 parameters, no annotations, and no output schema, the description is incomplete. It lacks critical context: no warnings about irreversible deletion, no explanation of what 'application resources' are, no error scenarios, and the return value description is too vague. Should provide more behavioral detail.

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 beyond the schema, which has 0% coverage. It explains each parameter's purpose: 'name' as required application identifier, 'cascade' as controlling resource deletion with default, 'propagation_policy' with enum values, and 'namespace' as optional. This compensates well for the schema's lack of descriptions.

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

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

The description clearly states the verb 'Delete' and resource 'application from ArgoCD', making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'create_application' or 'update_application' beyond the obvious difference in action verbs, missing explicit sibling distinction.

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

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

No guidance is provided on when to use this tool versus alternatives like 'sync_application' or 'update_application', nor any prerequisites or warnings about destructive effects. The description merely lists parameters without contextual usage advice.

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 full burden. It mentions that 'refresh' forces application reconciliation, which is useful behavioral context. However, it doesn't disclose other important traits like whether this is a read-only operation (implied by 'get' but not explicit), authentication requirements, rate limits, error conditions, or what happens if the application doesn't exist. The description adds some value but leaves significant gaps.

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 appropriately sized. It starts with a clear purpose statement, then lists parameters with brief explanations, and ends with return information. Every sentence earns its place, with no redundant or verbose content. The bullet-like format for Args and Returns enhances readability without sacrificing 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 4 parameters with 0% schema coverage and no output schema, the description does a decent job explaining parameters but has gaps. It doesn't fully describe the return value ('Application details' is vague), error handling, or behavioral constraints. For a tool with moderate complexity and no annotations/output schema, this is minimally adequate but could be more complete to help the agent understand execution outcomes.

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 provides meaningful explanations for all 4 parameters: 'name' is required for the application, 'project' is an optional filter, 'refresh' controls reconciliation behavior, and 'namespace' filters by namespace. This adds substantial value beyond the bare schema, though it doesn't specify format constraints (e.g., string patterns) or the exact effect of 'refresh' values.

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

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

The description clearly states the verb ('Get details') and resource ('for a specific application'), making the purpose immediately understandable. It distinguishes from siblings like 'list_applications' (which lists multiple) and 'create_application' (which creates new). However, it doesn't explicitly differentiate from 'get_plugins' or 'get_settings' which might also retrieve details about related resources.

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. For example, it doesn't explain when to use 'get_application_details' versus 'list_applications' (e.g., for single vs. multiple applications) or 'sync_application' (e.g., for refreshing state). There's also no mention of prerequisites or dependencies with other 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?

No annotations are provided, so the description carries the full burden. It states the tool returns a list of plugins but doesn't disclose behavioral traits such as authentication requirements, rate limits, error handling, or whether it's read-only (implied by 'Get' but not explicit). It lacks details on response format, pagination, 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 appropriately sized with three sentences: it states the action, clarifies the endpoint, and notes the return value. It's front-loaded with the core purpose. However, the first sentence is slightly redundant ('Get returns'), and the 'Returns:' section could be integrated more smoothly.

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 (0 parameters, no output schema, no annotations), the description is minimally adequate. It covers what the tool does and the return type but lacks context on usage, behavior, or integration with siblings. For a read-only tool with no params, it's passable but could benefit from more guidance or transparency.

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 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add param info, but with no params, this is acceptable. It implies no filtering or input is required, which aligns with the empty 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 purpose: 'Get returns Argo CD plugins using api/v1/settings/plugins' and 'This endpoint returns information about available plugins in ArgoCD.' It specifies the verb ('Get'), resource ('Argo CD plugins'), and endpoint, though it doesn't explicitly differentiate from siblings like 'get_settings' or 'get_user_info' beyond the resource type.

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

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

No guidance is provided on when to use this tool versus alternatives. The description mentions the endpoint but doesn't explain its context relative to sibling tools (e.g., 'get_settings' might include plugin info, or 'list_applications' could relate). There's no mention of prerequisites, timing, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get') and describes what the endpoint returns, which is helpful. However, it doesn't mention authentication requirements, rate limits, error conditions, or whether the data is cached/live. For a read-only tool with zero annotation coverage, this provides basic but incomplete 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 appropriately concise with three sentences that each add value: stating the action, detailing what's returned, and summarizing the return value. It's front-loaded with the core purpose. Minor deduction for slightly redundant phrasing ('Returns:' section could be integrated more smoothly).

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 this is a read operation with no parameters and no output schema, the description provides adequate coverage of what the tool does and what it returns. However, without annotations or output schema, it should ideally mention more about the response format, authentication needs, or error handling. The description is complete enough for basic use but lacks depth for a production 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?

The tool has 0 parameters with 100% schema description coverage, so the baseline for a parameterless tool is 4. The description appropriately doesn't waste space discussing nonexistent parameters. It focuses on what the tool does rather than 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 clearly states the tool's purpose: 'Get returns Argo CD settings using api/v1/settings' - this specifies the verb ('Get'), resource ('Argo CD settings'), and endpoint. It distinguishes from siblings by focusing on server settings rather than applications, plugins, or user info. However, it doesn't explicitly contrast with all siblings, keeping it at 4 rather than 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this tool is appropriate versus other settings-related tools (if any exist) or when to use it versus other configuration-fetching tools. There's no context about prerequisites, timing, or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the endpoint returns 'information about the currently logged-in user, including permissions and groups' and specifies 'User information from ArgoCD', which gives some context about the source and data scope. However, it lacks critical details: authentication requirements, rate limits, error conditions, or whether this is a read-only operation (though 'Get' implies it). For a tool with zero annotation coverage, this is insufficient.

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

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

The description is appropriately concise with three sentences that each add value: stating the action, detailing what's returned, and specifying the data source. It's front-loaded with the core purpose. Minor room for improvement in flow, but overall efficient.

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 (0 parameters, no output schema, no annotations), the description is reasonably complete for a basic read operation. It explains what data is returned and the source. However, without annotations or output schema, it should ideally cover more behavioral aspects like authentication needs or response format, leaving some gaps 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 tool has 0 parameters with 100% schema description coverage (empty schema). The description appropriately doesn't discuss parameters since none exist. This meets the baseline for tools with no parameters, as there's nothing to document beyond what the schema already indicates.

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: 'Get the current user's info via session/userinfo' - a specific verb ('Get') and resource ('current user's info'). It distinguishes from siblings like get_application_details or get_settings by focusing on user information rather than application or system data. However, it doesn't explicitly contrast with all sibling tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. While it's clear this retrieves user information, there's no mention of when this is needed versus other user-related operations (though none exist in the sibling list), nor any prerequisites or context for usage. The agent must infer usage from the purpose alone.

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

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

With no annotations provided, the description carries full burden. It clearly indicates this is a read-only operation that returns version details, which is adequate for a simple metadata endpoint. However, it doesn't mention potential behavioral aspects like authentication requirements, rate limits, error conditions, or whether this endpoint is always available. The description adds some value but lacks comprehensive 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 reasonably concise with three sentences that each add value: states the purpose, details what's returned, and summarizes the return. There's minimal redundancy, though the third sentence ('Returns: Version information...') slightly repeats the first. The structure is logical and front-loaded with the core functionality.

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 this is a simple, parameterless read operation with no annotations and no output schema, the description is minimally adequate. It explains what the tool does and what information it returns, which covers the basics. However, for a tool without structured output documentation, it could better describe the return format (e.g., JSON structure) or provide example output. The description meets minimum requirements but leaves gaps.

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

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

The tool has zero parameters, and schema description coverage is 100% (empty schema). The description appropriately doesn't discuss parameters since none exist. It focuses instead on what the tool returns, which is correct for a parameterless endpoint. The baseline for zero parameters with full schema coverage would be 4, and the description meets this expectation.

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: 'returns version information of the API server' with specific details about what's included (Git commit, version, build date, compiler information). It distinguishes from siblings by focusing on server metadata rather than application operations, though it doesn't explicitly name alternatives. The verb 'returns' is appropriate for this read-only operation.

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

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

The description provides no guidance on when to use this tool versus alternatives. While it's obvious this is for checking server version information, there's no mention of when this would be needed (e.g., troubleshooting, compatibility checks) or how it differs from other metadata tools like get_settings or get_plugins. The agent must infer usage context from the tool name alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions pagination in returns, which is useful, but lacks critical details: whether this is a read-only operation, what permissions are required, how filtering logic works (AND/OR), error handling, or rate limits. The refresh parameter's effect is noted but not fully explained (e.g., consequences of forcing reconciliation).

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 efficiently structured with a clear purpose statement followed by organized 'Args' and 'Returns' sections. Every sentence adds value: the first sets context, and the bullet points concisely explain parameters and output without redundancy. It's appropriately sized and front-loaded for quick understanding.

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 5 parameters, 0% schema coverage, no annotations, and no output schema, the description does a decent job covering basics (purpose, parameters, pagination). However, it lacks details on behavioral aspects like error handling, authentication needs, and filtering logic, making it incomplete for safe and effective use by an AI agent without additional context.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It successfully documents all 5 parameters with brief semantics (e.g., 'Filter applications by project name'), adding clear value beyond the schema. However, it doesn't specify format constraints (e.g., regex for names) or default behaviors when parameters are omitted, leaving some gaps.

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

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

The description clearly states the verb ('List') and resource ('applications in ArgoCD'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this listing tool from its sibling 'get_application_details', which provides detailed information about a single application, leaving room for potential confusion about when to use each.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_application_details' for single applications or other filtering methods. It mentions filtering options but doesn't explain when specific filters are appropriate or what happens without them, offering minimal usage context.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'sync' implies a mutation operation, the description doesn't explain what 'sync' actually does in ArgoCD (e.g., deploying manifests, reconciling state), what permissions are required, whether it's idempotent, or potential side effects like resource pruning. The parameter descriptions add some behavioral context but not enough 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 well-structured with clear sections for Args and Returns. Each parameter gets exactly one line of explanation. While efficient, the opening sentence could be more informative about what 'sync' means in ArgoCD context. No wasted words, but room for more front-loaded context.

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

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

For a mutation tool with 7 parameters, no annotations, and no output schema, the description is minimally adequate. It covers parameters well but lacks crucial behavioral context about what 'sync' actually does, error conditions, permissions needed, or what the 'Sync result details' return contains. The sibling context suggests this is part of a GitOps workflow, but the description doesn't leverage this context.

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

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

With 0% schema description coverage, the description compensates well by documenting all 7 parameters with clear semantics: required/optional status, defaults, and brief explanations of what each parameter controls. The description adds significant value beyond the bare schema, though it could provide more context about parameter interactions (e.g., how 'resources' interacts with 'prune').

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 ('sync') and resource ('an application in ArgoCD'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this from sibling tools like 'update_application' or 'create_application', which might have overlapping functionality in a GitOps 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 provides no guidance on when to use this tool versus alternatives like 'update_application' or 'create_application'. There's no mention of prerequisites, typical use cases, or scenarios where sync might be preferred over other operations in the ArgoCD context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While it mentions the tool updates an existing application and returns details, it doesn't describe important behaviors like whether changes are immediate or require sync, what happens if validation fails, or if there are rate limits or side effects. This leaves significant 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 well-structured with clear sections (Args, Returns) and uses bullet points effectively. It's appropriately sized for an 11-parameter tool, though the opening sentence could be more front-loaded with key usage information rather than just stating the basic 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?

Given the complexity (11 parameters, mutation operation, no annotations, no output schema), the description does a decent job but has significant gaps. It thoroughly documents parameters but lacks behavioral context, error handling information, and doesn't explain what 'updated application details' actually contains. For a mutation tool with this complexity, more completeness would be expected.

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 provides excellent parameter semantics, listing all 11 parameters with clear explanations of what each represents (e.g., 'New Git repository URL', 'Enable/disable automated sync'). This adds substantial value beyond the input schema, which has 0% description coverage and only provides titles like 'Dest Server' without context.

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

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

The description clearly states the verb ('Update') and resource ('an existing application in ArgoCD'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from its sibling 'create_application' or 'sync_application' in terms of when to use each, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'create_application' or 'sync_application'. It also lacks information about prerequisites (e.g., whether the application must exist) or constraints (e.g., permissions needed).

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