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 effectively describes key behaviors: it uses device flow authentication, opens a browser for user authorization, and implies it's a prerequisite action. However, it doesn't mention potential side effects like token storage, error handling, or timeouts.

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 in two sentences: the first states the purpose and method, the second provides critical usage guidance. Every sentence adds essential information with zero 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 zero-parameter authentication tool with no annotations or output schema, the description is nearly complete: it explains what the tool does, how it works (device flow with browser), and when to use it. The main gap is lack of information about return values or authentication state persistence.

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 parameters with 100% coverage, so the baseline is 4. The description appropriately doesn't discuss parameters since none exist, maintaining focus on the tool's purpose and 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 specific action ('Authenticate with Citizen platform using device flow') and identifies the resource ('Citizen platform'), making the purpose explicit. It distinguishes this tool from siblings by specifying its unique authentication role versus other deployment and status-checking 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 explicit guidance on when to use this tool ('ALWAYS call this first if check_auth_status shows not authenticated') and names a specific alternative ('check_auth_status'), giving clear context for usage versus other tools in the server.

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 describes the tool's purpose and recommended usage context but doesn't disclose behavioral traits like what authentication statuses might be returned, whether it performs network calls, error conditions, or rate limits. The description is accurate but lacks operational details that would help an agent understand what to expect from the tool's behavior.

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

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

The description is perfectly concise and well-structured in two sentences. The first sentence states the core purpose, and the second provides crucial usage guidance. Every word earns its place with zero redundancy or unnecessary elaboration. The information is front-loaded with the most important detail first.

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 annotations, no output schema), the description provides adequate context for basic usage. However, for an authentication status check tool, it could benefit from mentioning what specific status information is returned or what authentication methods are checked. The description is complete enough for the agent to know when to use it but lacks details about what the check actually entails.

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 schema already fully documents the parameter situation. The description appropriately doesn't discuss parameters since none exist. It earns a baseline 4 because it doesn't need to compensate for any parameter documentation gaps and doesn't waste space discussing non-existent 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's purpose as 'Check current authentication status' with a specific verb ('Check') and resource ('authentication status'). It distinguishes itself from sibling tools like 'authenticate' by focusing on verification rather than establishing authentication. However, it doesn't explicitly differentiate from other status-checking tools like 'get_deployment_status' beyond the authentication focus.

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

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

The description provides explicit usage guidance: 'Call this at the start of any deployment workflow to ensure you are authenticated.' This clearly indicates when to use the tool (beginning of deployment workflows) and why (to verify authentication). It implicitly suggests alternatives like 'authenticate' for establishing authentication rather than checking it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It successfully reveals important behavioral traits: the permission requirement ('requires member+ role'), the asynchronous nature of deployment ('After deployment starts'), and error handling guidance ('If build fails, read logs to understand error'). However, it doesn't mention rate limits, timeouts, or what happens to existing deployments.

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 in three sentences that each serve distinct purposes: stating the tool's purpose, specifying when to use it, and providing post-invocation workflow. There's no wasted language, and the most critical information (the tool's core function) appears first.

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 deployment tool with no annotations and no output schema, the description provides good context about permissions, workflow, and error handling. However, it doesn't explain what the tool returns (success/failure indicators, deployment ID, etc.) or address potential side effects on existing deployments, leaving some gaps in completeness.

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

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

With 100% schema description coverage, the schema already documents all 4 parameters thoroughly. The description adds no parameter-specific information beyond what's in the schema. The baseline score of 3 reflects adequate coverage through the schema alone, though the description doesn't enhance parameter understanding.

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 ('Deploy application') and resource ('from git repository'), distinguishing it from sibling tools like 'deploy_from_local' which handles local deployments. It provides a complete verb+resource+scope combination 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 explicit guidance on when to use this tool ('when user provides a git URL') and includes post-deployment workflow instructions ('ALWAYS monitor with get_deployment_status until completion'). It also distinguishes this from 'deploy_from_local' by specifying the git-based trigger condition.

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 and does well by describing the multi-step process (creates archive, uploads, deploys) and post-deployment monitoring requirement. It doesn't mention rate limits, authentication needs, or error handling beyond build failures, leaving some behavioral aspects uncovered.

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

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

Front-loaded with core purpose, followed by usage guidance and troubleshooting. Every sentence adds value: first states what it does, second when to use it, third mandatory follow-up action, fourth failure handling. No wasted words.

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

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

For a deployment tool with no annotations and no output schema, the description provides good context about the process flow and post-deployment requirements. It could be more complete by mentioning authentication prerequisites or what the tool returns, but it covers the essential deployment workflow well.

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

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

Schema description coverage is 100%, so the baseline is 3. The description doesn't add parameter-specific information beyond what's in the schema, but it does reinforce the local directory context which relates to the 'directory_path' parameter.

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

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

The description clearly states the specific action ('Deploy from local directory') and details the process ('Automatically creates tar.gz, uploads, and deploys'). It distinguishes from sibling 'deploy_from_git' by specifying local deployment 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?

Explicitly states when to use ('when deploying current directory, local files, or when iterating on fixes') and provides clear post-call guidance ('ALWAYS monitor with get_deployment_status after calling'). Also gives troubleshooting advice ('If build fails, analyze logs, fix files locally, and redeploy').

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 retrieves 'detailed information' but doesn't disclose behavioral traits such as whether it requires authentication, has rate limits, returns structured data, or handles errors. The mention of 'current deployment status and configuration' adds some context, but key operational details are missing for a tool with no annotation coverage.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get detailed information about a specific app') and adds specifics ('including current deployment status and configuration') without unnecessary words. Every part earns its place, making it appropriately sized and well-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?

Given the tool's moderate complexity (1 parameter, no output schema, no annotations), the description is minimally adequate. It covers what the tool does but lacks completeness in usage guidelines, behavioral transparency, and output details. Without annotations or an output schema, the description should do more to explain return values or operational context, but it meets a basic threshold.

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 100% description coverage, with 'app_name' documented as 'Application name'. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints. With high schema coverage, the baseline is 3, as the description doesn't compensate but also doesn't detract.

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

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

The description clearly states the verb 'Get' and the resource 'detailed information about a specific app', specifying it includes 'current deployment status and configuration'. This distinguishes it from siblings like 'list_apps' (which lists apps) and 'get_deployment_status' (which focuses only on status). However, it doesn't explicitly contrast with all siblings, such as 'get_instructions', so it's not a perfect 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 to choose 'get_app_info' over 'list_apps' (for listing vs. detailed info) or 'get_deployment_status' (for status-only vs. comprehensive details). There's also no mention of prerequisites like authentication, which is implied by sibling tools like 'authenticate' and 'check_auth_status'.

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 and excels by disclosing critical behavioral traits: it describes a polling pattern (every 5-10 seconds), expected status outcomes ('completed' or 'failed'), and how to handle failures (read ALL logs to identify errors like missing dependencies). This goes beyond basic functionality to include operational guidance.

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: the first sentence states the core purpose, followed by critical usage guidelines. Every sentence adds value, though it could be slightly more concise by integrating the error-handling advice into the polling instruction.

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

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

Given the tool's complexity (involves polling and error analysis), no annotations, and no output schema, the description is highly complete. It explains the tool's purpose, usage context, behavioral expectations, and even hints at output content (status and logs with error types like 'missing dependencies'), compensating for the lack of structured fields.

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

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

Schema description coverage is 100%, with the parameter 'run_id' documented as 'Deployment run ID (returned from deploy_from_git or deploy_from_local)'. The description does not add further meaning beyond this, but the baseline is 3 since the schema adequately covers the single parameter.

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

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

The description clearly states the tool's purpose with specific verbs ('get deployment run status and detailed logs') and distinguishes it from siblings like 'list_deployment_runs' (which likely lists runs without detailed status/logs) and deployment tools ('deploy_from_git', 'deploy_from_local') by focusing on post-deployment monitoring.

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

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

It provides explicit usage instructions: 'After starting any deployment, poll this every 5-10 seconds until status is "completed" or "failed"'. It also distinguishes when to use this tool (for status/logs of a specific run) versus alternatives like 'list_deployment_runs' (for listing runs) or deployment tools (for initiating deployments).

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 effectively communicates critical behavioral traits: this is a prerequisite operation that must be called first, it returns instructional content rather than performing actions, and following its output is mandatory for subsequent operations. However, it doesn't specify response format, error conditions, or authentication requirements.

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

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

The description is appropriately sized and front-loaded with the most critical information ('CRITICAL: Call this FIRST before ANY deployment operation'). Every sentence earns its place by establishing importance, describing the return value, and specifying usage requirements. The structure could be slightly more concise by combining some of the deployment tool references.

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

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

Given the tool's complexity (prerequisite instructional tool) with no annotations and no output schema, the description does well to establish critical context: sequencing requirements, purpose, and relationship to sibling tools. However, without an output schema, it doesn't fully describe what the instructions contain or their format, leaving some ambiguity about the return value.

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 would be 4 even with no parameter information. The description appropriately doesn't discuss parameters since none exist, maintaining focus on the tool's purpose and usage requirements.

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 with specific verbs ('Call this FIRST', 'Returns deployment instructions') and resources ('deployment instructions including polling intervals, error handling guides, and best practices'). It explicitly distinguishes this from sibling tools by naming specific alternatives (deploy_from_git, deploy_from_local, get_deployment_status) that should only be called after this one.

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

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

The description provides explicit usage guidelines: 'Call this FIRST before ANY deployment operation' establishes clear precedence, and 'You MUST read and follow these instructions before calling deploy_from_git, deploy_from_local, or get_deployment_status' names specific sibling tools with explicit sequencing requirements. This gives comprehensive when-to-use guidance with clear 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?

No annotations are provided, so the description carries full burden. It discloses RBAC filtering and permission checking, which are useful behavioral traits. However, it doesn't mention other aspects like pagination, rate limits, or response format, leaving gaps for a tool with no annotation coverage.

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

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

Two sentences with zero waste: the first states the purpose and scope, the second provides critical usage guidance. It is front-loaded with essential information and appropriately sized for the tool's 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 annotations, no output schema, and 0 parameters, the description provides good context on purpose, usage, and RBAC behavior. However, it lacks details on output format or error handling, which could be helpful for a list operation with no structured 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?

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description adds no parameter-specific information, but this is appropriate given no parameters exist, meeting the baseline for 0 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 specific action ('List all applications') and resource ('applications you have access to'), with explicit RBAC filtering context. It distinguishes from siblings like 'get_app_info' (detailed info on one app) and 'list_servers' (different 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?

Explicitly states when to use ('ALWAYS call this before deploying to understand which apps exist and which you have permission to deploy'), providing clear context and purpose relative to deployment workflows. It distinguishes from deployment tools like 'deploy_from_git' by positioning this as a prerequisite.

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 of behavioral disclosure. It mentions 'List recent deployment runs' but doesn't specify what 'recent' means (e.g., time range, limit), whether it's paginated, or what the output format includes beyond status. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is two sentences, front-loaded with the core purpose and followed by a usage tip. Every sentence adds value: the first defines the tool's function, and the second provides practical context. There is no wasted verbiage, making it highly 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 low complexity (single parameter, no output schema, no annotations), the description is adequate but incomplete. It covers purpose and usage but lacks details on behavioral aspects like output format or limitations. For a simple list tool, this is minimally viable, but it could benefit from more context to fully inform 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 input schema has 100% description coverage, with the 'app_name' parameter documented as 'Application name'. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints. Since schema coverage is high, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't need to.

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 ('deployment runs for an app'), specifying the purpose as retrieving deployment runs with their status. It distinguishes this from sibling tools like 'get_deployment_status' (which likely gets status for a specific deployment) and 'list_apps' (which lists apps rather than runs). However, it doesn't explicitly differentiate from all siblings, such as 'get_app_info', which might also relate to app details.

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

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

The description provides clear context for usage: 'Useful for debugging when user mentions "my last deployment failed"', which implicitly suggests this tool is for investigating deployment issues. It doesn't explicitly state when not to use it or name alternatives, but the context is sufficient to guide usage in common scenarios.

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 mentions the tool 'discovers available deployment targets,' which implies a read-only, non-destructive operation, but doesn't explicitly state permissions needed, rate limits, or what the output looks like. It adds some behavioral context but lacks completeness for a tool with no annotation coverage.

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

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

The description is two sentences, front-loaded with the core purpose and followed by usage guidance. Every sentence adds value without redundancy, making it efficient and well-structured for an AI agent.

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

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

Given the tool has no parameters, no annotations, and no output schema, the description provides good context on what the tool does and when to use it. However, it doesn't specify the output format or any behavioral constraints like error handling, leaving some gaps for a tool with zero structured metadata.

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 schema already fully documents the inputs. The description doesn't need to add parameter details, and it appropriately focuses on usage context. A baseline of 4 is applied as it compensates adequately for the lack of parameters by explaining the tool's role.

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 ('List all Citizen servers') and resource ('in your organization'), distinguishing it from siblings like 'list_apps' by specifying it's for discovering deployment targets. It provides a concrete purpose beyond just restating the name.

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 states when to use this tool ('Call this before list_apps to see which servers are available'), providing clear context and sequencing guidance relative to a sibling tool. It helps the agent understand the tool's role in a workflow.

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 of behavioral disclosure. It states that it 'Opens the default browser just like device authentication flow,' which adds useful context about the browser behavior and compares it to a known flow. However, it doesn't mention potential side effects (e.g., browser pop-ups, system focus changes), error handling, or what happens if the app isn't accessible, leaving some gaps for a tool with no annotation coverage.

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

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

The description is appropriately sized and front-loaded: the first sentence states the core purpose, the second provides usage context, and the third adds behavioral context. Every sentence earns its place with no wasted words, making it efficient and easy to parse.

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

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

Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is reasonably complete. It covers purpose, usage context, and some behavioral traits. However, for a tool that interacts with the system browser, it could benefit from mentioning potential platform dependencies or user confirmation requirements, but it's largely adequate for the given 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?

The input schema has 100% description coverage, with the parameter 'app_name' documented as 'Application name to open in browser.' The description doesn't add any additional meaning beyond what the schema provides—it doesn't explain what format 'app_name' should be in, whether it's case-sensitive, or how it maps to URLs. With high schema coverage, the baseline is 3, and the description doesn't compensate with extra insights.

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: 'Open app URL in system browser (not Cursor browser).' It specifies the verb ('Open'), resource ('app URL'), and target ('system browser'), distinguishing it from browser-based tools. However, it doesn't explicitly differentiate from potential sibling tools that might also open URLs, though it's reasonably clear in 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 clear context for when to use this tool: 'Use this after successful deployment to verify the app is working.' This gives a specific scenario (post-deployment verification) and implies it's for testing/validation purposes. It doesn't explicitly state when not to use it or name alternatives, but the context is well-defined.

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