Boosthis

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

The description adds meaningful behavior beyond the readOnlyHint annotation: verdict values, the meaning and prevalence of cant_tell, refusal vocabulary, and the explicit warning that no assistant score exists or can be derived. This materially helps an agent avoid misusing the output.

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 fairly compact but stylized: phrases like 'Each reads kept, broken or cant_tell' and 'in the promise vocabulary and refused for the same named reasons' are grammatically awkward and opaque. A more direct 'Returns...' structure would be clearer without adding length.

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 no-parameter, read-only tool without an output schema, the description covers what is included, what the reported values mean, and a key limitation about scores. Some domain jargon like 'promise vocabulary' is left unexplained, which prevents a perfect score.

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 zero parameters, so there is no parameter-level semantic burden on the description. The baseline for a parameterless tool is 4, and the description adds contextual meaning without needing to document arguments.

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 conveys that the tool reports outcomes for AI-related changes that passed through Boosthis, classified as kept, broken, or cant_tell. It is clear about the resource and result categories, though it lacks a direct action verb and does not explicitly distinguish itself from sibling list/report 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?

It gives inclusion scope ('only those that passed through it') and a strong exclusion ('No score for any assistant, and none derivable'), so an agent can infer when it is relevant and when it is not. However, it never names alternatives or explicitly says 'use this when...'.

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?

Beyond the readOnlyHint=true and destructiveHint=false annotations, the description adds meaningful behavioral detail: alerts can be in one of five states, the reply includes a match count so trimmed results are not mistaken for the full list, and no credentials are returned. This gives an agent a much richer picture of the tool's runtime 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 three dense sentences, front-loaded with what the tool returns, followed by status semantics, return-count behavior, and read-only reassurance. Every sentence earns its place and there is no filler.

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

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

There is no output schema, so the description carries the burden of explaining return behavior; it covers the alert statuses, mute information, result-count handling, and credential safety. The parameters are fully documented in the schema, and the read-only annotation plus the description's explicit limitations make the tool's behavior clear enough for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the semantics of statuses, particularly that Returned means "marked fixed and then happened again," and it clarifies that Muted is a property of screens or checks. It does not discuss limit or search, but those are already well documented in the schema.

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

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

The description clearly identifies the resource as "this account's Boosthis alerts" and explains the statuses and mute indicator, so an agent can tell what the tool returns. It lacks an explicit verb like "list" or "get," and it does not differentiate itself from sibling tools by name, so it stops short of a 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 implies the tool is for viewing a read-only list of alerts and explicitly says it cannot mark anything fixed, muted, or dismissed, which rules out mutation use. However, it does not state when to prefer this tool over an alternative or mention any sibling tools, so the usage guidance is mostly 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only safety profile is known. The description adds meaningful behavioral context beyond that: the auto-learned baseline comparison, the 'never empty' note when read credentials are missing, and the project_group runtime nuance. No contradiction with annotations.

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

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

The description is three sentences and front-loads the core purpose in the first sentence. The credential fallback and project notes are useful, though the 'More projects: your_projects; a shared project_group...' sentence is somewhat tangential and could confuse without surrounding context. Still, no sentence is wasted.

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

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

With no output schema, the description does a reasonable job of describing what the tool returns: a comparison of older baseline p95 versus recent p95 per screen and which screens regressed. It also covers the no-credentials fallback. It could be more explicit about the exact output shape or when to prefer this tool, but for a simple read-only tool this is fairly complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explaining the behavior when read credentials are absent, which maps to the read_token parameter, and by clarifying project semantics with 'a shared project_group is one project in several runtimes.' This goes beyond the schema's short 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 explains that the tool compares an auto-learned baseline (older p95) against recent p95 per screen and identifies regressed screens. It does not use an explicit verb like 'get' or 'list', but the resource and behavior are specific enough to distinguish it from siblings like boosthis_trend or boosthis_recent_samples.

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

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

The description implies the tool is for reading performance regression information, and provides a useful fallback behavior when read credentials are absent. However, it does not explicitly state when to choose this tool over sibling tools such as boosthis_trend, boosthis_recent_samples, or boosthis_session_summary, nor does it name alternatives or exclusions.

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

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

Beyond the readOnlyHint/destructiveHint annotations, the description adds substantial behavioral detail: the comparison window is chosen by Boosthis rather than the sentence, only a minority of wrong claims are caught, and vague claims are never caught. It also explicitly labels the operation as read-only, reinforcing the safety profile.

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

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

The description is compact and information-dense: four sentences, each carrying distinct value. The core action is front-loaded, followed by outcomes, key behavioral quirks, and practical limitations with no filler.

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

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

Even without an output schema, the description specifies the exact four possible answers, so an agent knows what to expect. Combined with the fully described parameters and the annotation-provided safety profile, nothing critical is missing for correct 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%, so both parameters are already documented. The description adds no additional parameter-level meaning beyond the general purpose of the tool, which is acceptable but does not push above the baseline.

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: it holds an assistant's sentence against what the running app actually did. It also defines the exact output universe (supported, not supported by measurements, cannot tell yet, outside scope), which fully clarifies what the tool does and distinguishes it from the many sibling tools.

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

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

The phrase 'a sentence an assistant is about to say' makes the intended use clear: use before asserting something about app behavior. It also gives practical caveats about when the tool will not help, such as vague claims never being caught, but it does not explicitly name alternative tools or say when not to use this one.

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

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

Annotations already declare readOnlyHint and non-destructive behavior, and the description adds meaningful behavioral nuance: it does not fetch the kit, version authority differs between hosted MCP and local stdio servers, and there is a fallback GET endpoint with bearer auth. This goes well beyond what annotations provide.

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

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

The core purpose is front-loaded and every sentence carries useful information, including the hosted-vs-local caveat and fallback endpoint. It is a little dense and the opening is a fragment, but there is no filler.

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

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

With no output schema, the description does a good job enumerating return fields and important edge-case behavior. It could be more complete about what triggers a withheld reply and how the project key maps to the local MCP context, but the essential calling information is present.

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

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

Schema description coverage is 100%, so the schema already documents runtime, repair_steps, and installed_version. The description does not add extra parameter-level meaning, so the baseline of 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 that this tool reports whether a newer kit exists without fetching it, and enumerates its main outputs (latest_version, update_available, comparison, changelog, severity, recommendation). It is distinguishable by behavior and output, but it does not explicitly differentiate itself from siblings such as boosthis_release_check, which could plausibly overlap.

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

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

There is no guidance on when to prefer this tool over alternatives, nor any exclusions or preconditions. The only usage-related note is the fallback HTTP endpoint for a withheld reply, which is about an alternate retrieval path rather than tool selection.

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

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

Annotations already declare readOnlyHint=true, and the description reinforces this with 'Read-only'. It adds meaningful behavioral context beyond annotations: it returns no credentials, performs the same check over plain HTTPS with a bearer project key, and distinguishes between an install that never measured anything and one that is simply quiet because the app is running.

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 dense but every clause earns its place: the resource, the endpoint detail, the returned fields, the interpretive nuance, the optional parameter, and the credential safety note. It front-loads the core purpose and avoids filler.

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

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

For a read-only status tool with one optional parameter and no output schema, the description is complete enough: it explains what the response represents, how to interpret states, what repair_steps does, and that no credentials are returned. An agent can select and invoke this tool without needing more 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 single parameter repair_steps is fully documented in the schema, and the description restates its effect ('repair_steps: true adds the step-by-step text') without adding significant new semantic detail. With high schema coverage, 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 tool's subject—what Boosthis knows about an account's installs—and its core question 'is it working?' It lists the information returned (runtime, state, last heard, meaning). It does not explicitly distinguish itself from sibling tools like verify_kit_install or which_kits, so it stops short of a 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 gives a clear context for use: answering 'is it working?' without guessing, and it explains why different quiet states should be interpreted differently. It does not explicitly name alternatives or state when not to use the tool, but the intended use case is clear enough for an agent to select it appropriately.

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?

Beyond the readOnlyHint annotation, the description discloses that signatures are code-derived rather than raw messages, meaning no user value is exposed, and that the result falls back to a note without credentials or before any crash is recorded. It also explains that the output is joined with Stability summary and stabilityRules, giving material behavioral context.

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

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

The description is well-structured and front-loaded with the main resource definition. Every sentence adds useful information, though the closing 'Read-only' is redundant with the readOnlyHint annotation. Overall it is appropriately sized and dense without being bloated.

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 there is no output schema, the description thoroughly explains what the tool returns: crash-class entries with specific fields, the joined Stability summary, and stabilityRules. It also covers edge-case behavior (note without credentials or before crashes are recorded), so an agent has enough context to invoke the tool and interpret the result.

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 both install_id and read_token are already documented in the input schema. The description adds no parameter-specific guidance, which is acceptable given the high schema coverage; 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?

The description clearly identifies the resource: crash classes recorded by the app, with specific categories (uncaught errors, unhandled rejections, caught render near-misses), ordering (newest first), and included fields (error name, redacted top frame, occurrence bucket, relatedRules). This makes it distinguishable from sibling tools like full_stack_trace and recent_samples.

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 the tool is relevant by describing its contents, but it does not explicitly state when to choose it over alternatives such as full_stack_trace or recent_samples. The credential and no-crash fallback note provides some operational context, but no clear when-to-use/when-not-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?

Annotations already declare read-only, and the description reinforces it while adding material behavior beyond the annotations: waterfall nesting, relative timings, code-defined labels, criticalHop semantics, and token-based install vs whole-chain visibility. No contradictions.

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

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

Two dense sentences, front-loaded with the core output shape, then constraints and scope. Every clause carries information, with no filler.

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

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

With no output schema, the description carries the return-format burden and satisfies it: span fields, nesting rule, criticalHop naming, relative timings, label origin, and auth scoping are all disclosed. The tool is simple enough that nothing else is needed for correct 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 covers all three parameters, so baseline is 3. The description adds useful semantics: trace_id is optional and defaults to latest, and read_token scopes visibility to one install instead of the whole account chain. This goes beyond the schema's field-level help.

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 precisely defines the resource: one user action displayed as a nested waterfall of spans, with explicit span fields and the criticalHop extension. It is clearly distinguishable from sibling tools like session_summary or trend even without naming them.

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

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

The intended use case is implied by 'one user action across the stack,' but there is no explicit statement of when to choose this tool over related siblings or exclusions for cases like multiple actions or aggregate views. No alternatives are named.

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 readOnlyHint=true and destructiveHint=false, the safety profile is already declared, so the bar is lower; the description clears it easily. It adds non-obvious behavior: no upload, a key-less single-use address, a bearer-token fallback endpoint, the exact response payload (file_list with path+sha256, version, kit_download_once_url), and a critical semantic clarification that writing files is not the install (wiring, reporting, and checked-in confirmation). This is valuable contextual disclosure well beyond the annotations.

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

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

The description is economically short — six sentences with high information density — and the core purpose is front-loaded. However, the telegraphic phrasing hurts: 'Withheld reply?', 'include_files no shell', and 'same key' are cryptic fragments that demand inference or prior domain knowledge. It is compressed, not genuinely 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 six parameters, no output schema, and read-only annotations, the description covers a lot: purpose, no-upload constraint, auth fallback, return payload shape, and the install-vs-write distinction. It compensates well for the absent output schema. Remaining gaps are minor: how 'THIS project' is bound, what 'typed commands' concretely are, and how the flow ties into verify_kit_install.

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 reinforces relationships among parameters ('runtime picks the kit', 'install_command adds typed commands', 'include_files no shell') but adds no meaning that the schema's own rich parameter descriptions lack. It usefully weaves parameters into the overall flow without compensating for any coverage gap, since none exists.

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 opening sentence names the deliverable ('A Boosthis kit for THIS project') and immediately distinguishes it from an upload flow ('no upload'), while 'runtime picks the kit; see its enum' and 'One kit per runtime' specify the selection model. It differentiates from siblings like get_removal_kit by scope (integration kit for the current project). Slight deduction: the retrieval action itself is never literally stated — 'get' comes from the title, and the GET fallback endpoint implies the fetch.

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 offers a concrete alternative path for a withheld reply ('Same kit at GET https://www.boosthis.com/api/kit/<runtime>') and conditions on include_files ('no shell') and install_command. The final sentence warns that writing files is not installation, which steers an agent away from treating this as a setup action. However, there is no explicit when-to-use versus sibling tools such as boosthis_verify_kit_install or boosthis_get_removal_kit.

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?

Despite readOnlyHint=true, the description reveals a critical behavioral warning: the removal sequence is load-bearing, and deleting the config before calling forget() strands server data because the forget request only reaches the server while the key is still present. This adds meaningful context beyond the annotations without contradicting them.

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 earn their place: the first defines scope with a concrete list, and the second delivers a high-value ordering warning. The main purpose is front-loaded and there is no filler.

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

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

For a read-only retrieval tool with one optional, fully documented parameter and no output schema, the description tells an agent what is included, why order matters, and what the danger is. No critical calling information is missing.

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

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

The tool description adds no parameter-level detail, but the input schema already documents project_code thoroughly, including the 8-character format and when it is needed. With 100% schema description coverage, 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 title supplies the verb 'Get' and the description names a specific resource: the complete removal kit for Boosthis, enumerating the sequence, files, package entries, config, calls to strip, and AI-tool config entries. This makes it easy to distinguish from siblings like get_integration_kit, which covers the opposite operation.

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

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

The description clearly frames the tool's context: it is for removing Boosthis from a project, which routes an agent away from integration/verification siblings. It does not explicitly state when not to use it or name alternatives, so it stops short of a 5.

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

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

Annotations already declare the operation safe and read-only, and the description adds meaningful behavioral nuance: fix_template depends on project registration, fix_available: false means no fix text is served, and counterparts/also_applies_here explain how related rules surface. No contradiction with annotations.

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

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

The description is compact and front-loaded, with the core purpose stated first and supporting field semantics following in clear, purposeful sentences. Every sentence adds value: the first defines the tool, the second clarifies fix availability, and the third explains how related rules and counts should be interpreted.

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

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

With no output schema present, the description compensates well by naming the key result fields and their conditional meanings. It could be slightly more explicit about the shape of the response or how the skip parameter affects results, but the combination of description and schema gives an agent enough context to call the tool correctly.

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

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

Schema description coverage is 100%, with id, skip, route_label, and skip_decided_by all explained in the schema itself. The tool description focuses on output fields rather than input parameters, so it adds little beyond the schema, but the schema already carries the full burden.

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

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

The description opens with 'Full detail for one rule' and enumerates the exact content returned (title, when_to_apply, evidence, fix_template, etc.), making the operation specific and unambiguous. It clearly distinguishes itself from list-oriented siblings like boosthis_list_rules by focusing on a single rule's full detail.

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

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

The description makes the use case clear: retrieve comprehensive detail for one rule, including related applicability across languages and projects. It doesn't explicitly name alternatives or state when not to use the tool, but the 'for one rule' framing and sibling context provide a solid contextual guide.

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?

Beyond the readOnlyHint and destructiveHint annotations, the description adds meaningful behavioral detail: it defines the 'app unheard' state as not blaming the job, clarifies that arguments/data are never collected, and states Boosthis never executes or schedules jobs. This gives an agent an accurate mental model of what the tool does and does not do.

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 dense but well organized: job states come first, then the carried fields, then the data-scope caveat and read-only note. It earns its length because the state definitions are genuinely informative. The final 'Read-only' is slightly redundant with the preceding sentence and annotations, so it is not perfectly lean.

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?

There is no output schema, so the description carries the burden of explaining what the agent will receive; it does this thoroughly by listing the states and fields. The two required parameters are simple and documented in the schema, and safety traits are already exposed via annotations. No essential operational detail is missing for correct 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?

Both parameters are fully described in the schema (install_id as install id, read_token as read-only token), so schema coverage is 100%. The description adds no parameter-level details, which is acceptable under the high-coverage baseline. There is no reason to upgrade or penalize beyond baseline.

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 identifies the resource (scheduled jobs) and explains the tool's output, including the possible states and per-job fields. It is specific about scope, noting that only names and timings are collected and that Boosthis never runs or schedules jobs. However, it lacks an explicit operative verb like 'List' or 'Get' and does not reference sibling tools by name, so it stops short of full sibling differentiation.

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 implied use is job-health inspection: the description says each job carries rhythm, lateness, completion, and duration data. It also rules out action uses by saying it never runs or schedules a job. But it never explicitly tells an agent when to select this tool over a sibling or names an alternative, so the routing guidance is only 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?

The annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context by stating that the result includes every rule available to this runtime and that it returns only ids and titles, which is useful beyond the annotations.

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

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

The description is two short sentences with no filler. The primary capability and output format are front-loaded, and the second sentence adds valuable context about its relationship to boosthis_get_rule.

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

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

For a zero-parameter, read-only listing tool, the description is complete: it states what is returned (ids and titles), the scope (all rules available to this runtime), and how the tool relates to a sibling. No output schema exists, but the description sufficiently covers expected return content.

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?

This tool has zero parameters and the schema is fully described (100% coverage of an empty schema), so there are no parameter semantics to clarify. Per the baseline for zero-parameter tools, a score of 4 is appropriate.

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

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

The description uses a specific verb ('list') and resource ('Boosthis performance rules') and specifies the output shape ('as ids and titles'). It also distinguishes itself from sibling boosthis_get_rule by explicitly framing this tool as the index for that tool.

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

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

The description makes its usage context clear: it enumerates all performance rules available to the current runtime. The phrase 'The index for boosthis_get_rule' implies the intended workflow of listing first, then retrieving a specific rule, though it does not explicitly mention alternatives or exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'Read-only'. It adds genuine beyond-annotation context: the null-reporing behavior for projects with too few fixed issues ('reports null rather than a made-up ratio') and a security note ('returns no credentials'). These prevent misinterpreting null results and set auth expectations, going well beyond what the annotations convey.

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

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

Four information-dense sentences in which every sentence earns its place: metric formula first, then the window parameter, then the null edge case, then the read-only/credential note. The most decision-relevant content is front-loaded and nothing is redundant with the schema or annotations.

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

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

With no output schema, the description carries the burden of explaining results, and it covers the null case and the metric meaning well. However, it does not state the exact return shape (a single ratio vs an object with counts), what threshold counts as 'too few fixed issues', or error behaviors beyond 'returns no credentials'. For a two-parameter metric tool this is close but leaves a few gaps an agent must guess at.

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 and the schema already documents both parameters. The description restates window_days semantics and adds the 'all's string alias, which is a small extra beyond the schema ('0 o 'all' = all time'), though it also creates a mild inconsistency since the schema types window_days as number. Net value over the schema is marginal.

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 precisely defines the metric: 'of the issues a project actually fixed, how many were fixed before users felt them ... versus after a crash or a poor rating.' This is a specific verb-plus-resource definition that clearly distinguishes the tool from analytic siblings like crash_risk or trend by stating its unique ratio. The title 'Maintenance Mix' is expanded into an unambiguous formula, leaving no ambiguity about what the tool computes.

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

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

The description implies usage context — it is a read-only diagnostic for assessing whether fixes happened proactively or reactively — but never states when to choose this tool over alternatives among the many analytic siblings (crash_risk, trend, vigilance, session_summary). It provides no explicit when-to-use/when-not-to-use guidance or named alternatatives, so an agent must infer selection from the metric definition alone.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds meaningful behavioral context: results are heuristic ('ranked guesses from a text match, not findings'), there is an 8-candidate cap, and each rule's when_to_apply must settle real applicability. This goes beyond the annotations.

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

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

Two sentences with no wasted words. The first sentence front-loads the action and method, the second clarifies interpretation. Every sentence earns its place.

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

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

For a single-input read-only tool, the description covers what it does, what it returns (up to 8 ranked candidates), and how to interpret results. It does not describe the exact fields of each candidate, but with no output schema and a simple scope, this is a reasonable level of 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?

The schema only defines 'code' as a required string with no description (0% coverage). The description compensates by identifying it as the code snippet to match against, which is the sole parameter and is sufficiently disambiguated, even though no format or size details are given.

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 ('ranks') and resource ('Boosthis rules against a code snippet'), and clarifies the output is ranked guesses rather than definitive findings. This distinguishes it from sibling tools like list_rules or get_rule, which would not do text-based ranking against 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?

The description implies usage when you need to match rules to a code snippet and then confirm applicability via when_to_apply, but it does not explicitly name alternatives or state when not to use this tool. The guidance about results being guesses is useful but not a full when-to-use vs. 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?

Annotations already mark the tool as read-only and non-destructive, and the description reinforces this with 'Read-only.' Beyond annotations, it adds useful behavioral detail: promises survive sessions, and each item is either 'watched' (measurable against a specific line) or 'remembered only' (a standing instruction without measurement). This meaningfully explains the tool's data model.

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: it immediately defines the resource, then explains persistence and the measurement distinction. Every sentence adds meaning, and the final 'Read-only' clearly states safety. No filler or redundant schema repetition.

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

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

For a read-only, no-parameter tool, the description covers the essential conceptual ground: what promises are, why they matter, and the watched/remembered-only distinction. It does not specify the exact response shape, but the description gives enough for an agent to understand the tool's purpose and likely return semantics.

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

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

The tool has zero parameters, so there is no parameter burden. The description is not required to explain input semantics, and it instead explains the semantic content of the returned promises, which is valuable given there is no output 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 identifies the resource: standing promises recorded by the project's developer, what they mean, and that they persist across sessions. It also explains the two measurement states ('watched' and 'remembered only'), giving an agent a concrete idea of what the tool returns and how it differs from ordinary notes or tasks.

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 context for when to use the tool: when an agent needs to know the developer's standing promises or standing instructions that survive earlier sessions. It does not explicitly name alternatives or exclusions, but the resource is distinct enough that usage context is apparent.

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?

Beyond the readOnlyHint annotation, the description discloses a key behavioral constraint: the hosted connection only receives aggregate snapshots, not raw sample streams, and the tool will never return a list. It also explains the output shape is a fact and a pointer, which is essential for setting agent expectations.

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 front-loaded with the most important behavioral fact and is reasonably dense with useful guidance. Some phrasing is cryptic, such as 'your_projects' and the project_group note, but there is no wasted filler.

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

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

Given the lack of an output schema, the description adequately explains that the response is a fact and a pointer rather than sample data, and names the relevant alternatives. It could be more explicit about the exact return format, but for a simple read-only routing tool it is largely complete.

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

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

Schema description coverage is high at 80%, so the baseline is 3. The description adds meaningful context about project selection, noting that a shared project_group is one project in several runtimes and referencing your_projects, which supplements the schema's project parameter description.

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

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

The description clearly communicates that this tool does not provide per-screen sample lists, and that the answer is a fact plus a pointer. It distinguishes this from boosthis_session_summary and the dashboard's Recent measurements page, though it states the purpose somewhat indirectly through negation rather than a direct 'returns X' statement.

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

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

It explicitly tells the agent when not to use this tool for individual samples, and routes to boosthis_session_summary for per-screen aggregates and to the dashboard for individual measurements. This provides clear when-to-use and when-not-to-use guidance relative to alternatives.

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

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

Annotations already declare read-only and non-destructive behavior. The description adds useful behavioral detail beyond that: there is no combined score, each answer carries its own numbers and window, and parts lacking evidence state that explicitly. This sets expectations for output shape without repeating the annotation.

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 dense and front-loads the core subject, but the phrasing is somewhat repetitive and poetic ('held up', 'witnessed', 'when it could answer'). The listing of the six answers earns its place, but a more compact phrasing would improve clarity.

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

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

With no output schema, the description carries the burden of explaining return semantics, and it does so reasonably: six individually answered questions, each with numbers and a window, no aggregate score, and explicit handling of insufficient evidence. It could be tighter about the exact response envelope, but the core expectations are covered.

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 is only one optional parameter, runtime, and the schema already fully describes it with examples and fallback behavior. The description adds no parameter-specific meaning, so the high schema coverage keeps this at 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 identifies what is being evaluated — how the last release held up after shipping — and distinguishes it by naming the six specific release-health questions it answers. This is specific enough to separate it from siblings like check_for_update or crash_risk.

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 conveys the context of use ('last release', 'after it shipped', 'running app') and the fact that it compares against the project's own reported measurements. However, it does not explicitly state when to prefer this tool over alternatives or when not to use it.

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

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

Rich behavioral disclosure beyond the annotations: 'Restating one replaces it, not duplicates it' gives concrete meaning to idempotentHint=true; 'nothing counts as measured until the developer confirms it on their project page' reveals the eventual-consistency/confirmation flow; and the secret-refusal policy ('nothing is stored') is critical safety context. All statements align with readOnlyHint=false and idempotentHint=true, with no contradiction.

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?

Four dense sentences, front-loaded with purpose and every sentence earning its place: purpose, idempotency semantics, confirmation flow, security boundary, and sibling disambiguation. It could be more skimmable with separation, and the examples in sentence one add length, but there is no waste.

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 only two well-documented parameters and annotations covering idempotency plus the read/write profile, the description is nearly complete: it covers purpose, replacement behavior, post-call flow, and security constraints. The only gap is the return value format (no output schema exists, and the description explains the confirmation flow but not the actual response shape), which keeps this from a 5.

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 schema already documents both parameters, including the 240-character limit and the 'Connect AI once' card origin for account_token. The description adds modest value by framing promise content as 'the developer's own plain words' and by implying a content-validity constraint via the secret-refusal statement, but it does not substantially deepen parameter meaning.

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

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

The description opens with a specific verb and resource ('Saves something the developer wants kept true... as a promise on the project'), grounded by concrete examples (fast screen, problem not returning, rhythm holding). It differentiates from siblings like boosthis_promises and boosthis_list_rules with the closing signal 'This one writes,' making the read/write split 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?

Clear context for when to use it: to persist a standing requirement in the developer's own words across sessions and assistants. It provides a when-not boundary ('Passwords, keys and personal details are refused') and explains restatement semantics, but never names a sibling alternative explicitly (e.g., 'list existing promises with boosthis_promises'), so it stops short of a 5.

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?

Goes beyond the annotations by disclosing the worst-first ordering, conditional metric availability ('where the server has them'), and the degraded-mode fallback ('Without read credentials: a note pointing at the dashboard, never empty'). The 'Read-only' sentence merely repeats readOnlyHint=true and earns no credit. The fallback note's contents are underspecified, but the disclosed traits are genuinely useful.

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?

Three dense sentences, front-loaded with the output spec and ordering, with no background or marketing prose. The only real waste is the redundant 'Read-only' clause, and the project_group note is slightly tangential though useful.

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 three optional parameters and no output schema, the description covers output content, ordering, degraded mode, and ambiguous project grouping. Remaining gaps — the response shape and units, and what 'worst rating' means — are minor, though the absent output schema raises the bar slightly.

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 adds value above it by tying read_token to a concrete behavior (the dashboard-note fallback) and by clarifying project-group semantics for the project parameter. These are additions, not repetitions of 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 specifies the exact output content: per-screen p50/p75/p95, worst rating, worst screens first, with p99, spike ratio and stdev spread where the server has them. This specificity distinguishes it from siblings like boosthis_trend, boosthis_recent_samples and boosthis_snapshot. The verb is implicit (nothing literally says 'returns' or 'summarizes'), which keeps it just below a 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?

Usage context is implied rather than stated: the metric list tells an agent what kind of data to expect, but there is no explicit when-to-use guidance, no exclusions, and no alternative routing to a named sibling. The one sibling mentioned, `your_projects`, appears only for project semantics ('a shared project_group is one project in several runtimes'), not as a preference rule for other cases.

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 readOnlyHint=true and destructiveHint=false already supplied, the description goes beyond annotations by disclosing the fallback behavior when credentials are missing or no upload exists, confirming that a read token cannot delete anything, and clarifying that only the latest upload is covered. No contradiction with annotations.

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

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

The description is front-loaded with the core purpose and uses compact, information-dense phrasing. Each sentence adds either output content, credential/fallback behavior, or project nuance, though the domain jargon (boot ladder, axes) makes it slightly dense for an 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 no output schema, the description compensates by itemizing the returned data sections and the failure fallback. It covers credential behavior and project grouping, but it relies on the agent to infer the relationship to the many specialized sibling tools, so a small completeness gap remains.

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

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

Schema coverage is 100%, and the schema already explains project, install_id, and read_token. The description adds context about credential-less behavior and project_group handling, but it does not materially redefine or enrich the parameter formats beyond what the schema provides, 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?

The description opens with 'The whole Boosthis bubble for one install - the latest upload' and enumerates the contained sections (boot ladder, frame meters, axes, per-route rows, per-screen diagnosis, session summary, budgets), making the tool's purpose as a comprehensive per-install snapshot clear. It does not explicitly contrast itself with sibling tools like boosthis_session_summary or boosthis_alerts, so it stops short of the strongest sibling differentiation.

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 is implied through the 'whole bubble... latest upload' framing: use it when you need the full current state for one install. The description gives useful conditions (note pointing at the dashboard when no read credentials or no upload yet) and points to `your_projects` for more projects, but it never states when to choose this over a sibling tool such as boosthis_recent_samples or boosthis_session_summary.

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

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

The description goes beyond annotations by explaining edge-case behavior: no-data days are marked no_data and are never treated as zero or healthy, and insufficient measurements yield not-enough-data rather than a guess. It also states read-only and 'returns no credentials', which aligns with and extends the readOnlyHint annotation.

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 dense but well organized, front-loading the scope and output fields before covering edge cases and safety. Every sentence adds useful information, and there is no filler or repetition.

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

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

With no output schema, the description still tells the agent what metrics to expect, how missing days are represented, and what the comparison verdict provides. For a read-only trend tool with only two simple parameters, this is complete enough to support correct invocation and interpretation.

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

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

Schema coverage is 100%, and the schema already documents install_id and read_token with brief descriptions. The main description does not add new parameter-specific meaning, so it does not need to compensate for missing schema details; the baseline score 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 defines what the tool returns: per-day metrics for a single project over the last 30 days, including typical and worst-case screen time, poor ratings, crashes, and alerts, plus a plain-English 7-day comparison verdict. It is specific and scoped, though it does not explicitly distinguish itself from overlapping sibling tools such as boosthis_alerts or boosthis_crash_risk.

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 intended use case is clear from the context: use this for a single project's last-30-day trend with a comparison of the last 7 days against the 7 before. It does not name alternatives or state when not to use it, but the scenario is specific enough that an agent can infer when it applies.

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?

Beyond the annotations (readOnlyHint, destructiveHint), the description adds substantial behavioral detail: it discloses the read-only nature, states that no credentials are returned, explains exactly what the verdict reports (missing, modified, unexpected paths with expected sha256), and cautions about the limits of a passing result. This goes well beyond what annotations alone provide and helps set accurate expectations.

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 dense but not bloated; it front-loads the core purpose and then provides parameter semantics, output verdict details, and a safety note. The HTTPS endpoint mention is slightly extraneous but earns its place by indicating this is the same check already available over plain HTTP. Every sentence contributes useful information, though the description is a bit long.

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

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

With no output schema, the description properly explains what the verdict returns: exact missing, modified, and unexpected paths with expected sha256 values. It also covers the required parameter behavior, the runtime enum convention, and the read-only/no-credentials guarantee. For a 4-parameter verification tool, this is a complete and self-sufficient description.

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 semantics for the two key parameters: files[] is 'for every kit file written' and runtime must be 'named, never guessed.' This clarifies the agent's responsibility when constructing inputs. repair_steps and installed_version are not elaborated in the description, but their schema descriptions are adequate.

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+resource: 'Check a Boosthis kit's FILES ON DISK are byte-perfect.' It also differentiates this from related tools by emphasizing file verification on disk and by adding the important caveat that 'a pass proves the files, never that anything is measured yet.' Among the sibling tools, this clearly stands out as the installation-integrity verifier.

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 contextual guidance: use this to verify that kit files on disk match expected byte-perfect hashes. It also provides an implicit exclusion with 'never that anything is measured yet,' warning agents not to use it as evidence of runtime behavior. It does not name sibling alternatives explicitly, but the context is sufficient for an agent to select it appropriately.

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

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

Annotations already mark the tool read-only and non-destructive, and the description adds meaningful behavioral context: it returns no credentials, does not count as an AI read, reports unknowns with reasons, and explicitly says it gives no score or grade. It also discloses the categories of missing coverage. This goes noticeably beyond the annotations without contradicting them.

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 efficient sentences with no filler, front-loading the core result and then the important limitations. The first sentence is dense and list-heavy, but every clause adds information that helps an agent understand what to expect.

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

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

With no output schema, the description sufficiently explains what the tool returns: the verdict, individual watches, evidence dimensions, and reasons for unmonitorable areas. It omits exact response shape and edge-case behavior, but the tool is simple enough that the description is actionable for invocation.

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

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

Schema description coverage is 100%, so install_id and read_token are already documented in the input schema. The description does not add new parameter-level semantics; it only reinforces that the token is read-only, which is also captured by the annotations.

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 defines a specific resource and result: a project's standing Vigilance verdict, the watches behind it in worst-first order, evidence details, and limitation reasons. It does not use an action verb like 'get' or 'retrieve,' but the output scope is unmistakable. The 'No score, no grade' line also helps distinguish it from assessment/scoring tools, though it does not explicitly differentiate from siblings by 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?

There is no explicit when-to-use or when-not-to-use guidance, and no alternative sibling tool is named. The wording implies this is a read-only diagnostic for one project's vigilance status, but an agent is not told how to choose it over nearby tools like boosthis_crash_risk or boosthis_what_should_i_look_at_next.

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

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

The description adds meaningful behavior beyond the annotations: it explains the unauthenticated case ('never empty'), the triage ordering rule, and the project_group semantics. The annotations already declare read-only/non-destructive, and the description reinforces and augments that without contradicting it.

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?

Three compact sentences, each delivering distinct information: core output format, edge-case behavior, and project semantics. No filler or repetition, and the most important usage detail is front-loaded.

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

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

The description covers what the tool returns, how it behaves without credentials, and important project semantics. There is no output schema, but the return shape is adequately described as an ordered list with reasons. Minor gaps like explicit error behavior or examples are not critical for this tool.

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

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

Schema coverage is 75%, so the schema already describes most parameters. The description adds extra semantic value for the project parameter by clarifying shared project_group behavior and the no-credentials case, which goes beyond the schema's 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 defines the tool's purpose: it returns a triage ordering of screens ranked by worst rating and slowness, each with a one-line reason. This is specific enough to distinguish it from most siblings like alerts or crash_risk, though it does not explicitly name an alternative for contrast.

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 useful usage context: the no-credentials fallback behavior, the meaning of a shared project_group, and a pointer to `your_projects` for more projects. It lacks an explicit 'use this instead of X when...' statement, but the context is clear enough for an agent to decide.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds important non-obvious behavior: 'nothing is downloaded or executed'. It also discloses the output signal table, the surfaces returned, and the fact that no arguments still returns the signal table.

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

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

The description is compact and front-loaded with the core purpose. A few clauses are dense and could be clearer, but every sentence contributes useful information and there is no filler.

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

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

For a read-only inventory tool with one optional parameter and no output schema, the description is nearly complete. It explains what will be returned at a high level (signal table, kit names, registered surfaces, runtime-deciding files), though the exact signal table format is not specified.

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

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

Schema coverage is 100% and the schema already explains files as optional manifest objects with path and dependencies. The description adds useful meaning by highlighting that no arguments returns the signal table and that the files' contents decide a runtime, going slightly beyond the raw schema.

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

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

The description opens with a specific verb and resource: it 'Names which Boosthis kits this project needs' from visible manifest files. It clearly differentiates itself from boosthis_get_integration_kit by positioning itself as the inventory step, so an agent can distinguish the two without inspecting 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?

It explicitly states when to use this tool: 'The inventory step before boosthis_get_integration_kit'. It also clarifies the alternative never guesses, implying this tool is the source of exact kit/runtime names. This is strong routing guidance.

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