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 analysis with suggestions but does not disclose whether the operation is read-only, modifies anything, or requires authentication. Behavioral traits beyond the basic return are missing.

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

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

The description is two sentences long, front-loads the main purpose, and contains no superfluous information. Every part is relevant and 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?

With two well-documented parameters and no output schema, the description competently explains the tool's function and return value. However, it could be slightly more detailed about the scope of analysis (e.g., only permission patterns, not general code issues).

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 both parameters described in the schema. The description does not add any extra meaning beyond what the schema already provides, so baseline score 3 applies.

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

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

The description clearly states the tool analyzes permission handling patterns in code for a specific SDK feature. The verb 'Analyze' and resource 'permission handling patterns' are specific, but it does not explicitly distinguish from sibling tools like 'diagnose_issue', which may also analyze code.

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 or when not to use it. The description does not specify prerequisites or exclusions, leaving the agent without context for 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 exist, so the description carries the full disclosure burden. It does add genuinely useful behavioral traits: 'Reversible - executes immediately.' However, it does not say whether a partial payload (only app_id required) will leave other fields untouched or reset them, nor whether privileges are required — both relevant for a mutating tool with no annotation safety net.

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/three compact sentences with zero filler: the core function leads, then behavior, then boundary disambiguation. Every clause earns its place and the most decision-relevant facts are front-loaded.

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

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

In 100% schema coverage, scope and exclusions are clear, and a 4-param flat tool with no output schema achieves most of what an agent needs. Gaps are minor: the return/confirmation shape is unstated, and partial-update semantics (whether unspecified fields stay intact) are left to inference.

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% — every parameter already carries a description, including a detailed prep_mode enum explanation. The description adds only the conceptual grouping ('content fields' vs 'who prepares it'), which is mild value beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Configures an app's content fields (name, base_url) and who prepares it (prep_mode)'), which maps directly to the schema fields. It also pre-empts sibling ambiguity by carving out 'icon is set_icon and webview injection is a dashboard concern,' so an agent can distinguish it from set_icon and other tools without opening their schemas.

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 scopes the tool as 'Content-only, matching the CLI `apps update`,' and name-s the exclusion: icons belong to set_icon and webview injection belongs to a dashboard concern. This gives concrete when-to-use and when-not-to-use directions relative to populated 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, the description discloses important traits: 'Non-destructive' and 'executes immediately', plus an authentication requirement. This adds useful context beyond the plain 'create' purpose, though it doesn't cover return values or error 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 brief and front-loaded, but the mention of 'prep_mode' (not in schema) and the conditional phrasing detracts from clarity. It's not as clean as it could be.

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 5-parameter create tool with no output schema, this description covers authentication and a usage condition but omits return values, error scenarios, and relationship to source code. It's adequate 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 100%, so baseline is 3. The description adds a conditional note about 'prep_mode' which is not in the schema, potentially confusing agents. It doesn't meaningfully elaborate on the schema parameter descriptions.

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

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

The description clearly states the verb ('Creates') and resource ('new app') with a scope ('for the authenticated user'). It distinguishes from sibling tools like configure_app and publish_app by focusing on creation, though it doesn't explicitly name alternatives.

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

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

It provides authentication prerequisites and a conditional note about 'prep_mode', but does not explicitly say when to use this tool versus alternatives (e.g., configure_app). The guidance is implied rather than explicit.

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

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

No annotations provided; description does not disclose if the tool modifies state, requires permissions, or has side effects. Merely states it provides diagnosis, which 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?

Two concise sentences, no unnecessary words, front-loaded with core 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?

Describes what the tool provides (diagnosis, solutions, code fixes) but lacks details on output format. Given no output schema, more context on return structure would be helpful.

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

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

Input schema covers all 4 parameters with descriptions (100% coverage), so description need not add more. The description does not repeat or enhance parameter info 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?

Clearly states it diagnoses Appo SDK integration issues and provides solutions/code fixes. Distinguishes from siblings like check_permissions and generate_component.

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

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

No explicit guidance on when to use this tool versus alternatives. While the context is implied, no when-not-to-use or alternative tool mentions.

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 must disclose behavioral traits. It states it generates and returns a React component, but lacks details on side effects (e.g., file creation), authorization needs, or any limitations. For a code generation tool, more transparency is needed.

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, front-loaded with the main purpose. No wasted words, efficient and clear.

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 complex task of generating SDK-integrated components and no output schema, the description should provide more context about the output format, defaults, or constraints. It is too brief to fully guide an 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?

Schema coverage is 100%, with each parameter well-described in the schema. The description adds no additional meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the verb 'generate' and resource 'UI component', specifies it uses @appolabs/appo SDK features, and returns a complete React component with SDK integration. This differentiates it from siblings like generate_hook or scaffold_feature.

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 does not mention when not to use it, prerequisites, or contrast with sibling tools like check_permissions or diagnose_issue.

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; description carries full burden. It discloses that the tool returns TypeScript code with types, error handling, and loading states, but does not mention side effects, permissions, or any destructive actions. 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 a single sentence that gets straight to the point. It could benefit from structural separation (e.g., when to use), but it is concise and front-loaded with the essential 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 no output schema and 4 parameters (1 required), the description adequately covers the tool's behavior and output. It explains the return value, which compensates for missing output schema. Lacks only minor usage context.

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

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

Schema coverage is 100%, and each parameter is well-described in the schema. The description adds no additional parameter-level meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states 'Generate a custom React hook for an @appolabs/appo SDK feature' with a specific verb and resource. It distinguishes from siblings like generate_component by focusing on hooks and mentions return value.

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 does not explicitly state when to use this tool versus alternatives like generate_component or scaffold_feature. The usage is implied by the hook-specific output, but no guidance on exclusions or when not to use.

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 disclosing behavior. It mentions the outputs and that hosting instructions are included, but it does not clarify whether files are returned directly, saved, or sent via email, nor does it note any limitations (e.g., no domain validation). This is adequate but not rich.

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

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

The description is a single sentence that clearly conveys the core action and outputs. It is front-loaded with the main purpose and includes all essential information without fluff. Every word 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?

Despite having no output schema, the description does a good job of indicating what the tool returns (the two files) and that instructions are included. It is complete for a simple generation tool, though it could benefit from explaining the exact format of the response (e.g., JSON payload, file contents). This is a minor gap.

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

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

Schema coverage is 100%, so the schema already documents each parameter. The description adds context by explaining the output includes hosting instructions and that the domain is optional (used in examples), which aligns with the schema. Since the description does not introduce contradictions and the schema is comprehensive, a 4 is justified for the minor additional 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 tool's purpose: generating configuration files for iOS Universal Links and Android App Links, specifically naming the output files (apple-app-site-association and assetlinks.json). This distinguishes it from sibling tools like generate_hook or generate_component, which are for code generation, not configuration.

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

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

The description implies when to use this tool (when setting up Universal/App Links), but it does not explicitly state when not to use it or mention any alternatives. It lacks guidance on prerequisites like having a domain and associated apps, which would be important for an agent to know.

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 the duty to disclose behavioral traits. It does reveal a key behavior: the single-app default when app_id is omitted, which is useful. However, it does not disclose other potential traits such as whether the call is read-only or if it might perform side effects, though the nature of the tool suggests it's safe. This is a minor gap; the description is transparent about its main quirky behavior but lacks explicit safety confirmation.

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, exactly two sentences, with the key information front-loaded: the purpose is stated first, followed by a practical usage hint. There is no redundancy or extraneous information, making it highly efficient for an agent to process quickly.

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

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

For a simple tool with only one optional parameter and no output schema, the description is quite complete: it explains the primary purpose, the entry-point role, and the default behavior. It could potentially mention what kind of metadata or publication state is included, but since the tool is straightforward and the schema is fully documented, this is a minor omission. The absence of an output schema is fine as the description doesn't need to explain return values.

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 already covers 100% of the parameter with a clear description of app_id (optional, single-app default applies). The tool description adds minimal extra value beyond the schema, except for reinforcing the default behavior context. Given perfect schema coverage, baseline 3 is appropriate; the description does not add significant new semantics beyond what's already stated.

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 returning three specific types of information (configuration, publication state, metadata) in a single call, using an actionable verb ('Returns') and specifying the resource ('app'). It also distinguishes itself from siblings like 'get_build_status' and 'get_rejection' by emphasizing the 'one call' overview nature, and the phrase 'Start here' reinforces its role as an entry point.

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 on when to use it: it's a starting point for app information ('Start here'), and it explains the default behavior when app_id is omitted. However, it does not explicitly state when not to use it or mention alternatives like 'get_build_status' or 'get_rejection', but given it's an overview tool, the guidance is adequate.

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 says 'Non-destructive', which is valuable given the lack of annotations. It doesn't add context about authentication, rate limits, or the shape of the returned status object; and no output schema exists, so the agent cannot predict return data.

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

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

Single run-on sentence with semicolons. It is reasonably concise but contains a minor malformed phrase 'reaches ready (then publish) or failed.'

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?

Without JSDoc or output schema, it is not exposed to describe what a build status object contains, what fields, what possible values; the description assumes one read cmd but not detailed semantics; no contexts.

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

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

Input schema has two required params with brief descriptions ('app_id', 'build_id'), but the descriptions are minimal and no extraneous meaning such as formats/constraints is added. Schema coverage is complete, hence baseline 3.

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

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

The description uses a specific verb 'Returns' with resource 'status of a build by id', and adds scope ('by id'), and lifecycle behavior (polling until ready or failed). It distinguishes this as a read/poll operation. However, the sentence structure is slightly awkward.

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 specifies when to use it (polling until status is ready or failed) and clarifies the action. It doesn't mention alternatives, but this use case is clearly implied by 'poll until ready (then publish)'.

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?

States 'Non-destructive' which is a key behavioral trait. However, with no annotations, it doesn't disclose authentication, rate limits, or what happens if there's no current rejection. Minimal but present.

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 concise sentences, front-loaded with purposecars. No fluff.

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

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

For a simple tool with one param and no output schema, the description is adequate but could clarify what 'current rejection' refers to and whether any prerequisites exist. It lacks explanation of the recipe structure, but that may be acceptable.

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 description doesn't add any parameter meaning beyond what the schema already provides. Baseline 3.

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 returns 'code-free Appo remediation recipes for the current rejection', specifying the verb (returns), resource (recipes), and scope (current rejection). This distinguishes it from siblings like get_rejection and diagnose_issue.

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

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

The phrase 'for the current rejection' implies usage context, but there's no explicit guidance about when to choose this over get_rejection or diagnose_issue. Alternatives aren't mentioned, but the context is somewhat 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?

With no annotations provided, the description carries the safety disclosure burden. It explicitly states 'Non-destructive' and adds a meaningful privacy boundary with 'Never exposes raw reviewer text'. It does not cover auth/error behavior, but is sufficient for a simple read-only 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 two short sentences with no filler. It front-loads the core purpose and packs in safety and privacy constraints without redundancy.

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

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

Given the tool has one parameter and no output schema, the description adequately covers what is returned (publication status and curated action) and key behaviors (non-destructive, no raw reviewer text). It could add a bit more on expected output shape, but overall it is complete enough for this simple tool.

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

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

Schema description coverage is 100%: the only parameter, app_id, is already documented in the schema as 'The app ID'. The description adds no extra semantic detail about the parameter, so it meets the baseline but does not exceed it.

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

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

Description uses a specific verb ('Returns') and identifies the resource as 'Appo publication status and the curated required action for a rejected app'. This clearly distinguishes it from siblings like publish_app or get_build_status by focusing on rejected apps and the curated action.

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

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

Usage context is implied: the tool is for rejected apps needing status/action. However, it does not explicitly state when to use this tool over alternatives like get_fix_recipe or get_app_overview, nor does it mention any exclusions beyond not exposing reviewer text.

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 burden of disclosing behavior. It includes the non-destructive nature ('Non-destructive'), which is useful. However, it does not mention authentication requirements, pagination, or the structure of the returned list. Given the lack of an output schema, this leaves some ambiguity, but the statement is truthful and adds some value, warranting a 3.

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

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

The description is extremely concise: two short sentences that convey the purpose and non-destructive nature. There is zero wasted verbiage, and the important information is front-loaded. This is an ideal example of 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 the tool's simplicity (no parameters, no output schema), the description is largely complete. It states the action and scope, and adds the non-destructive trait. While it could mention the return format or authentication, these are reasonable gaps for a simple list operation. The sibling tools suggest this is a read operation, and the context is sufficient for an agent to decide when to use it.

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

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

There are zero parameters, and the schema description coverage is 100% (trivially, since there are no properties). According to the scoring rules, a 0-parameter tool receives a baseline of 4. The description does not need to add parameter details, and it doesn't, so a 4 is appropriate.

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

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

The description clearly states the tool's purpose: 'Lists all apps owned by the authenticated user.' It uses a specific verb ('lists') and resource ('apps') with a scope ('owned by the authenticated user'). This distinguishes it from sibling tools like create_app or configure_app, which imply different operations.

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

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

The description implies usage context by specifying ownership by the authenticated user, but it does not explicitly mention when to use it versus alternatives. It lacks guidance on when not to use it or mention of similar tools like get_app_overview. However, the purpose is clear enough for an agent, so it earns a 4.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It notably states 'Non-destructive — executes immediately,' which communicates safety and execution semantics. However, it does not describe possible failure modes, permission requirements, or what 'per-platform readiness' technically means, so it earns a 4 rather than 5.

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

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

The description is two short sentences, front-loaded with the primary purpose and output. Every word earns its place: it lists all key output fields and adds a vital safety note. There is zero filler or redundancy.

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

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

For a simple one-parameter tool with no output schema, the description provides a good overview of the returned payload and safety trait. It is mostly sufficient, but 'open-on-device payload' could be slightly ambiguous and 'readiness' is undefined. Still, it covers the core needed 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 full description coverage (app_id: 'The app ID'), so the baseline is 3. The description does not add any additional meaning or usage examples for app_id. It references the payload but not in a way that clarifies parameter usage beyond what the schema already says.

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

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

The description uses a specific verb ('Returns the open-on-device payload') and lists concrete resources: iOS TestFlight URL, Android deeplink, QR target URL, and per-platform readiness. This clearly differentiates it from sibling tools like create_app, configure_app, or get_build_status, which involve creation, configuration, or status checks.

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 it should be used when the agent needs a preview payload, but it never explicitly states when to prefer this over alternatives. There are no exclusion criteria or alternative tool mentions. The 'Non-destructive — executes immediately' hint provides some context but not clear usage boundaries.

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

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

The description explicitly labels the tool as 'Destructive' and explains the confirm flag's role in executing vs. previewing. Since no annotations are provided, the description carries the full burden, and it does so well by warning about the destructive nature and the need for confirmation. It could add more detail about irreversible consequences, but it covers the key behavioral trait.

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

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

The description is two sentences, front-loaded with the primary purpose, and every word earns its place. It efficiently conveys the destructive nature, the confirm flag's function, and the preview behavior without any fluff.

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

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

Given the tool's complexity (destructive action, confirmation flag, preview mode) and the lack of annotations or output schema, the description is quite complete. It explains the critical behavior (preview vs. execution) and the required confirmation. It could mention what happens after publication (e.g., build status) but that is not essential for safe invocation.

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

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

The schema already provides 100% coverage with descriptions for all three parameters. The description adds context about the 'confirm' parameter's role in execution vs. preview, which is valuable, but it doesn't add much beyond what the schema already states. The baseline for high schema coverage is 3, and the description meets that without significantly exceeding it.

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

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

The description clearly states the tool's purpose: 'Starts publication to the chosen stores.' It uses a specific verb ('Starts publication') and resource ('chosen stores'), and distinguishes itself from siblings like 'unpublish_app' and 'preview_app' by explicitly mentioning the destructive nature and the preview behavior.

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: it states that calling without 'confirm:true' returns a preview and performs no write, and implies that to actually publish, one must set 'confirm:true'. This clearly differentiates the execution mode from the preview mode, which is essential for safe usage.

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

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

With no annotations, the description must convey behavioral traits. It mentions returning multiple files with instructions, but does not disclose potential side effects like file creation or overwriting, or any 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 concise with two sentences, each serving a purpose: stating the action and the outcome. No wasted words, though it could be slightly 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?

Given the tool's three parameters and lack of output schema or annotations, the description covers the main functionality but omits details like the includeTests parameter and the exact nature of returned files. Adequate but not 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 coverage is 100%, and the description does not add meaningful detail beyond the parameter descriptions. Baseline score of 3 is appropriate as the description adds little to 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 tool's purpose: to scaffold a complete feature integration including hook, component, and types. This distinguishes it from sibling tools like generate_component and generate_hook which handle individual parts.

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

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

The description implies usage for full feature scaffolding but does not explicitly state when to use this tool versus alternatives. No guidance on prerequisites or conditions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly warns 'Destructive' and explains the confirm‑gated behavior (preview vs send). This goes beyond the simple action, adding crucial safety context that is not present in the schema (except in confirm's description, but the word 'Destructive' is new 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 two short sentences: the first states the action, the second gives the critical destructive/confirm nuance. Every word earns its place; no filler or repetition of schema details. It front-loads the purpose and then the essential behavioral caveat.

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 (7 params, 3 required, no output schema, no annotations), the description conveys the essential behavioral difference between preview and send, which is the only unusual aspect. It does not explicitly state return values after sending, but this is not necessarily required given schema richness and lack of output schema. It is reasonably complete for its purpose.

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

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

The input schema already provides complete coverage (100%) for all 7 parameters, including descriptions that specify behavior (e.g., confirm's effect). The description does not add new semantics beyond what the schema already defines—it mainly restates the confirm logic. Baseline of 3 applies as schema carries the heavy lifting.

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

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

The description states the tool's purpose clearly: 'Sends a push to the app's devices.' It uses a specific verb and resource and is distinct from any sibling tool (none of which relate to push notifications). It doesn't explicitly distinguish from siblings, but none of the listed siblings perform push actions, so this suffices.

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

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

The description provides clear context for use: it is for sending pushes, with an important conditional—confirm:true triggers sending, otherwise it previews. However, it doesn't explicitly mention when NOT to use or alternate tools. It offers a logical safety gate (confirm) that guides correct invocation.

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. It discloses that the server fetches, validates, and stores the image, states that execution is immediate, and notes reversibility. This gives a reasonable picture of behavior, though it does not mention failure handling or whether the existing icon is overwritten.

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

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

The description is two concise sentences with no fluff. The primary action is front-loaded, followed by crucial behavioral details. Every sentence contributes new information.

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

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

For a simple two-parameter tool with no output schema, the description covers the essential aspects: the action, URL constraints, server-side process, execution timing, and reversibility. It lacks details on return values or error conditions, but these are not critical for such a straightforward update operation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful context beyond the schema by specifying that the icon URL must be publicly reachable and https, and that the server validates the image. This reinforces and enriches the schema definitions for both 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 function: "Sets an app's icon from a publicly reachable https URL." This identifies the exact action and resource, and the additional detail about server-side fetching and validation further clarifies scope. It is easily distinguished from sibling tools like configure_app or set_permissions.

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

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

The description implies usage context (e.g., when you need to update an app icon from a URL) but does not explicitly state when to prefer this tool over alternatives or mention any exclusions or prerequisites. The reversibility note is useful but not a substitute for explicit when-to-use guidance.

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

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

Without annotations, the description compensates by disclosing key behaviors: it updates only the included keys, preserves the rest and usage messages, and is reversible and immediate. This gives a clear picture of the operation's side effects and reversibility.

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

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

The description is exceptionally concise, packing all essential information—function, parameters, behavior, and a best practice—into a few short sentences. There is no redundancy or fluff.

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

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

It covers the operation's core behavior, reversibility, and a store-review best practice. It omits potential error scenarios or prerequisites, but for a straightforward set operation, the description is sufficiently complete.

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

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

The schema descriptions cover the parameters, but the description adds valuable meaning by explaining the object's keys and the partial-update semantics (only included keys change). This enriches the schema beyond basic type information.

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

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

The description clearly states that the tool sets an app's native permissions, enumerating the specific permission keys (tracking, camera, microphone, nfc). The verb 'sets' distinguishes it from read-only tools like check_permissions, and the resource is explicitly identified.

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 some usage guidance, such as requesting only permissions the app actually uses and noting the operation is reversible and immediate. However, it does not explicitly differentiate when to use this tool versus alternatives like check_permissions, leaving the comparison 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?

With no annotations, the description carries the full burden. It clearly labels the tool as 'Destructive' and explains the preview-vs-execute behavior, which is essential for safe use. It could mention side effects beyond execution, but the confirm requirement is well-disclosed.

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 fluff. The first sentence states the purpose, the second covers safety and prerequisites. Front-loaded and 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?

For a tool with no output schema, the description explains the preview behavior without confirm and the need for a specific credential. It could describe what the preview contains or post-execution results, but given the tool's simplicity, this level is adequate and not missing critical information.

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% (both parameters described), so baseline is 3. The description adds clarity around the confirm parameter's dual role (preview vs execute) and the auth requirement, going beyond schema descriptions.

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

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

The description clearly states the verb 'Resubmits' and the resource 'a rejected app for review', distinguishing it from sibling tools like publish_app or preview_app. It 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?

It explains the critical usage pattern (call with confirm:true to execute, otherwise preview) and states a prerequisite (customer-owned Apple credential). It does not explicitly compare to alternatives, but the context of 'rejected app' makes the intended use clear.

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

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

No annotations are provided, so the description carries the full burden. It clearly discloses that the tool is destructive, requires explicit confirmation, and performs no write without confirm:true. This is strong behavioral disclosure.

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 concise sentences front-load the core action, then add the safety-critical destructive/confirmation behavior. There is no fluff or repetition of schema details.

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

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

Given the tool's moderate complexity, no annotations, and no output schema, the description covers the essential behavior: what is removed, which stores are targeted, the destructive nature, and the preview-vs-execute distinction. This is complete enough for correct tool selection and invocation.

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

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

Schema description coverage is 100%, and the schema already explains app_id, confirm, and app_stores. The description only restates the store targeting and confirmation behavior, adding little beyond the structured schema definitions.

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

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

The description states a specific verb and resource: 'Removes an app from the chosen stores.' It clearly distinguishes the tool from siblings like publish_app and preview_app by describing the unpublishing action and the store scope.

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

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

The description gives clear usage context: without confirm it returns a preview, with confirm:true it executes the destructive action. It implies a safe preview-first workflow, but it does not explicitly mention alternatives or when not to use the 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 are provided, so the description must fully disclose behavioral traits. It does not state whether the operation is read-only, requires any permissions, or has side effects. The term 'validate' implies inspection, but this is not explicit.

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

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

The description is a single, concise sentence that front-loads the core purpose. It is not verbose, but it could benefit from slightly more detail without becoming lengthy.

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 or annotations, the description is too sparse. It does not explain the format of validation results (e.g., boolean, list of issues) or any return value, leaving the agent uncertain about what to expect.

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, so the schema already documents each parameter. The description adds minimal context beyond 'optionally checks import patterns' for sampleCode, but this does not significantly enhance understanding over the schema.

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

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

The description clearly states the tool validates the @appolabs/appo SDK installation and configuration, specifying it analyzes package.json and optionally checks import patterns. This distinguishes it from sibling tools like check_permissions or generate_component.

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

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

The description implies the tool is used for validating SDK setup, but it does not explicitly state when to use it vs. alternatives (e.g., diagnose_issue). It lacks guidance on exclusions or prerequisites.

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