Layero

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description adds useful context by clarifying that the tool does not actually modify state; instead, it returns a recipe that the agent executes itself (terminal commands, file edits, relay deployment). This goes beyond the annotations and helps the agent understand the actual workflow without 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?

The description is two sentences: the first states the purpose, the second explains the behavioral model. It is concise, front-loaded, and contains no fluff. Every sentence carries meaning.

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 1-parameter tool with full schema coverage, annotations, and an output schema, the description adequately covers the purpose and the execution model. The agent has all necessary information to decide when to call it and 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 only parameter 'kind' has a complete schema description (100% coverage) explaining each enum value. The description itself does not add any additional parameter-level meaning, so it relies on the schema. 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 the tool's action: 'Wire form submissions into a destination.' It also specifies the output type ('Returns the integration recipe'), which aligns with the name and title. The schema's 'kind' enum further distinguishes this from sibling tools like connect_analytics or connect_domain.

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 usage context (when you need to direct form submissions to a destination) and is clear about the tool's role. However, it does not explicitly mention alternative tools or when NOT to use it, which would merit a 5. Still, the context is clear enough for the 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 provide only openWorldHint=true (no read/destructive hints). The description adds valuable behavioral context by clarifying that the live site address is unaffected and retains the previous version — a key safety reassurance. However, it doesn't disclose what happens to partial artifacts, whether cancel is reversible, or any timeout/permission requirements. For a mutating operation with only openWorldHint, 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 exceptionally compact — two short sentences. The first states the core action, and the second provides the most important safety distinction. Zero filler, front-loaded 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?

For a 2-param tool with an output schema and 100% schema coverage, the description covers the key behavioral nuance (live address unchanged). The openWorldHint provides context. It's slightly short on details around cancellation semantics (e.g., what happens if build already finished), but is near-complete for the tool's simplicity.

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 description mentions the default behavior ('Без него берётся самая свежая' — without it the most recent is taken) for the deploy param, which adds value beyond the schema. However, the project param instructions are exclusively in the schema, and the description doesn't add cross-tool guidance about slug extraction, so it roughly meets 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 clearly states 'Остановить сборку, которая ещё идёт' (stop a build that is still running) with a specific verb+resource combination. It further differentiates by explaining the live address remains unchanged, which distinguishes it from publish/rollback/sibling 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 for in-progress builds and clarifies the non-destructive effect on the live address. However, it doesn't explicitly contrast with retry_deploy or diagnose_deploy siblings or state conditions for when cancellation isn't possible (e.g., already completed builds), though the 'ещё идёт' phrasing implicitly excludes those.

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?

Although annotations already state readOnlyHint and idempotentHint, the description adds significant behavioral context: it is deterministic code ('один и тот же текст даёт один и тот же список находок'), not model judgment, which is a key trait beyond mere idempotency. It also describes the output behavior—each finding carries a ready replacement—and warns against rewriting fragments manually, thus disclosing how the tool behaves and how users should react.

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

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

The description is well-structured with a clear header, a deterministic claim, a concrete list of caught errors, a guidance note on using replacements, and an explicit 'what's not here' section. Every sentence adds value: it covers purpose, behavior, usage limits, and alternative direction without fluff. The length is justified by the needed nuance, and key information 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?

Given the tool's moderate complexity (multiple modes of input, deterministic behavior, scope boundaries) and the presence of a full output schema and annotations, the description is complete. It covers the return behavior (findings with location and replacement), the exact scope of errors, the exclusion of editorial judgments, and the alternative resource, leaving no critical gap for an agent to select and invoke 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% (per context), and the schema already explains the parameters clearly (path default, text or project mutual exclusivity). The tool description does not add new parameter semantics beyond what is in the schema; it repeats some of it (e.g., 'Либо это, либо project — что-то одно'). Therefore, the baseline of 3 is appropriate since the schema carries the 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 clearly states the tool's purpose: 'Механические ошибки русской типографики — с точным местом и заменой.' It specifies the resource (Russian typography errors), the action (proofreading), and the outcome (exact location and replacement), and it distinguishes itself from editorial judgment tools by explicitly stating it is code, not model opinion.

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 when-to-use and when-not-to-use guidance. It says what the tool does NOT cover (инфостиль, длина фраз, канцелярит, нейрослоп) and directs the agent to an alternative resource 'layero://editorial/ru' when the request is to 'make text better' instead of 'fix typography.' It also clarifies the mutually exclusive use of text vs. project parameters.

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 adds useful context: it initiates an immediate DNS check and describes expected behavior when records are not yet propagated. This goes beyond the annotation 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?

The description is concise: two short sentences, the first stating purpose and the second detailing immediate execution and expected propagation behavior. Every word earns its place, with 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?

For a simple read-only tool with full schema coverage and an output schema, the description provides sufficient context: what it checks, when to use it, and what behavior to expect. It is complete and self-contained.

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

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

Both parameters (domain and project) have full descriptions in the schema (100% coverage), so the schema already carries the parameter semantics. The description does not add extra parameter details, which is acceptable given the high schema coverage.

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 checks whether a connected domain has started working, using a specific verb and resource. This distinguishes it from sibling tools like site_status or check_performance by focusing on DNS propagation of a connected domain.

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

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

The description explains that this tool runs the DNS check immediately instead of waiting for a background re-check, giving a clear reason for using it. It also advises that if records have not propagated, that's normal and suggests coming back later, but it does not explicitly name alternative tools 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 only provide readOnlyHint=true. The description adds substantial behavioral context: the verdict is based on a score, not raw timings; repeated runs vary by at most one point while LCP/TTFB swing 37-40%; a 3-point difference is meaningful; run duration is tens of seconds; wait=true behavior and queue effects are disclosed. This goes far beyond 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 four sentences, front-loaded with the core purpose. Every sentence provides necessary information: the noise threshold, run duration, wait behavior, and parallel warning. No 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 performance measurement tool with an output schema, the description fully covers the key contextual aspects: why the score matters over timings, what constitutes a meaningful regression, how long a run takes, and how wait/parallel behavior works. The output schema likely documents return values, so no need to repeat them here. This is a complete and self-contained 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 both parameters are already documented with descriptions. The description reinforces the wait semantics and mentions deriving project slug from my_projects, but this largely duplicates the schema. It adds the queue caveat, which is more behavioral than parameter-specific, so the marginal added value is limited.

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: 'Measure a site's speed and say whether it got worse after a deploy.' This is a specific verb+resource combination that distinguishes it from sibling tools like site_status (status) and diagnose_deploy (diagnose). The deploy-regression context is explicit.

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

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

The description provides a clear usage context: after a deploy, to detect regressions. It also gives an important usage constraint: do not start a second measurement in parallel because it will occupy the queue. It does not explicitly name alternatives, but the deploy-specific framing implies when to use it versus other tools.

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

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

The openWorldHint=true annotation declares the tool opens external dialogs, and the description reinforces this by explaining the native quiz dialogs in the IDE. It adds value beyond the annotation by describing what the dialogs collect (skills, palette, design system, submissions, slug) and what the return value (ComposeResult) contains. It's not a pure read/write tool, so the annotation covers the 'opens world' aspect and the description adds the flow 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 with a bolded main intent, clear instruction, and a numbered breakdown of the three quiz steps. The final paragraph explains the output and follow-up. A bit longer than strictly necessary but every sentence contributes value; the structure makes it scannable. Slight verbosity in listing all quiz contents, but it's useful for the agent.

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

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

Given the output schema exists (ComposeResult), the description appropriately references it without re-explaining return fields. The tool has only one param, an openWorld hint annotation, and the description covers the flow, prerequisites (call immediately, don't ask questions), and post-conditions (write files, proceed to integration). This is complete for an orchestration/entry-point tool.

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

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

The single parameter user_message is the only one, with 100% schema coverage in the schema description itself ('verbatim — do not paraphrase'). The tool description adds crucial context: the message is 'used to pre-fill quiz defaults and inform matching,' which explains why verbatim preservation matters. For a single-param tool, this is strong semantic guidance.

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 drives a 3-step quiz flow and produces a complete landing. It explicitly declares itself as 'the main entry point' and details the three quiz steps (Motivation, Look & feel, Final picks). This distinguishes it clearly from siblings like publish_landing, read_site, or refactor_site which are post-composition 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?

Excellent guidance: explicitly says DON'T ask questions in chat before calling, states the tool opens native quiz dialogs in the IDE, says to 'call this immediately when the user describes what they want.' It also explains the follow-up workflow (write files via IDE filesystem tool, then proceed to integration/deploy), which maps well against sibling tools like add_integration and publish_landing.

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 annotation provides only openWorldHint=true, which the description doesn't address. The description does add one useful behavioral detail: that assembly uses the same function as the post-quiz path, meaning results are client-independent. However, it doesn't disclose whether this mutates state, requires auth, or what side-effects (if any) occur — though the open-world nature of the tool and its bridge-triggered design give reasonable transparency.

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

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

The description is brief and front-loaded with the core statement, then adds essential usage disambiguation. The line about 'not for the model' is critical context that earns its place. Slightly more verbose than necessary (line breaks could be tightened), but every sentence contributes value.

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

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

Given the output schema exists (so return format needs no explanation), the annotation is minimal, and this is a straightforward landing-composition tool with a critical usage caveat (not model-callable), the description sufficiently covers the essential aspects. It could mention what makes this different from `compose_landing` beyond callers, but given the sibling relationship is clearly flagged and the tool is internally invoked, this is adequate.

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

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

Schema description coverage is 100%, so the schema already documents all 8 parameters (topic, design_system required; goal, tone, palette, audience, integration, project_name with defaults). The description adds no parameter-specific detail beyond 'by answers from the form,' which is implicit given the tool name. Per the baseline rule, with full schema coverage, a 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 what the tool does ('Собрать лендинг по ответам из формы' — assemble a landing from form answers) and explicitly distinguishes it from its primary sibling `compose_landing`. While the verb+resource is clear, it doesn't fully describe the broader scope of what the landing output entails, but the core purpose is well-communicated.

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

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

The description explicitly states WHO should use this tool ('Это НЕ инструмент для модели: его вызывает сама форма через мост хоста') and precisely names the alternative for the model (`compose_landing`). It also notes that the build uses the same function as after a quiz, ensuring consistent behavior. This is explicit when/when-not guidance with a named alternative.

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 openWorldHint annotation, the description reveals critical behavioral details: authorization happens in the browser, the agent cannot perform that step, the tool returns a link for the user, and polling is discouraged. It also warns that the user may take time, providing a realistic interaction pattern. This is excellent disclosure of side effects and edge cases.

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

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

The description is concise and front-loaded with the core purpose, followed by an IMPORTANT callout for the user-authorization flow. Every sentence adds value: the action, the browser requirement, the link-handling instruction, and the polling/checking caution. No wasted words.

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

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

Given the external auth complexity, the description covers the full flow: the tool returns a link, the user must open it, how to check later, and an alternative tool. Combined with a rich schema and an openWorldHint annotation, the description is complete enough for an agent to handle the process correctly without further clarification.

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 both parameters fully. The description adds a small nuance that checking status later should omit the `branch` argument, but this is a minor usage hint rather than substantive parameter semantics. 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 opens with a specific verb+resource: 'Connect Yandex Metrika to a site.' This clearly states what the tool does and distinguishes it from siblings like site_analytics (presumably for viewing analytics) and add_integration (for other integrations).

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 context: it tells the agent to show the returned link to the user, not to poll, and to check later through the same tool without the `branch` argument or via `site_analytics`. It doesn't explicitly list exclusions (e.g., when NOT to use), but the guidance is clear enough for correct 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?

The description goes well beyond the openWorldHint annotation by revealing the human-mediated DNS process, propagation timing, and the platform's independent re-checking. However, it contains a factual contradiction: it claims the platform reduces a full URL like `https://shop.example.com/page` to `shop.example.com`, while the schema explicitly states a scheme will result in a 422 error. This inconsistency undermines the transparency.

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

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

The description is concise and well-structured: a one-sentence purpose, a highlighted behavioral callout with actionable instructions, and a short note on input handling. Every sentence adds necessary context without 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?

The description covers the entire workflow: what the call yields (DNS records), what to do with them, what not to do (wait), and how to follow up (via `check_domain`). This is highly complete for a human-in-the-loop operation. The minor deduction stems from the conflicting URL-handling statement, which leaves the agent unsure about accepted input formats.

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 both parameters clearly. The description's only additional parameter note—that the address can be passed as-is and is normalized—contradicts the schema's 422-on-scheme rule, providing confusing rather than helpful semantics. Thus the description adds no positive value beyond the schema and even introduces a discrepancy.

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 immediately states 'Connect a custom domain to a site' with a specific verb and resource. It also differentiates from siblings by referencing `check_domain` for later verification and `my_projects` for project slug resolution, positioning this as the initiating 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?

The description provides explicit guidance: show DNS records to the user, do not wait for readiness because the platform re-checks automatically, and use `check_domain` afterward. It also tells the agent to obtain a slug from `my_projects` when needed, making the usage context clear and actionable.

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?

Discloses that only a tail is returned, that truncation is visible via the 'truncated' field, and warns not to present the tail as the full log. This adds meaningful behavioral context beyond 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?

Description is compact and front-loaded with the core purpose, followed by usage guidance and return-behavior note. Every sentence contributes value; no 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?

Given the presence of a complete output schema and rich parameter descriptions, the description covers the essential context: when to use, what it returns, and a critical caveat about tail truncation. Sibling tools and annotations further complete the picture.

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 all four parameters (kind, tail, deploy, project) individually described in the schema. The description adds no additional parameter-level semantics 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?

Description clearly states the tool returns raw log lines ('Сырые строки лога') for build and app, and explicitly distinguishes it from diagnose_deploy, which provides parsed cause and context. The purpose is specific and non-tautological.

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 instructs to start with diagnose_deploy and tells when to use this tool: when the cause is unclear or when interested in app behavior rather than failure. Names the alternative tool and provides clear when/when-not 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?

The description adds meaningful behavioral details beyond the readOnlyHint annotation: it explains the output is not a raw log but a parsed cause, the response contains a verdict and summary, and the default behavior when no deploy id is provided. This provides useful context without contradicting 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 concise and front-loaded with the core purpose. Each sentence contributes useful information (what it does, default behavior, response shape, workflow), with no fluff 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?

Given the presence of an output schema and the readOnlyHint annotation, the description covers the essential behavioral aspects: purpose, response nature, and default behavior. It could briefly mention potential edge cases or errors, but overall it is sufficiently complete for an agent to understand and invoke the tool.

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

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

The input schema already covers both parameters with descriptions, but the tool description enriches the `deploy` parameter by explaining the default (latest build) and the effect of passing an id. It also clarifies how to reference a project via slug or id. This adds value beyond the schema.

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

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

The description clearly states the tool's purpose: to explain why a deploy failed with a parsed cause, not a raw log. It distinguishes itself from sibling tools like deploy_logs by emphasizing the parsed output and the 'neighborhood of the fatal line' rather than a full log.

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 a deploy id it uses the latest build, and to examine an older build you pass its id. It also frames the workflow (read verdict, fix, deploy again). However, it does not explicitly name alternative tools or state when not to use this tool.

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

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

The description goes well beyond the annotations (destructiveHint=true) by explaining a critical behavioral rule: values are never read back, by the agent or platform, to avoid embedding secrets in conversation history. It also clarifies that `set` preserves other variables and `unset` only affects named ones, plus the build-time pickup requiring a new deploy. This is rich, actionable context that the annotations alone do not 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 description is longer than average, but every sentence carries important information for safe and correct usage. It is front-loaded with the primary purpose, followed by the crucial security warning and deployment caveat. The structure is logical, though slightly verbose; the length is justified by the sensitive nature of environment variables.

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 (multiple actions, security implications, deployment behavior) and the presence of an output schema, the description is thorough. It covers return behavior (names/lengths only), the partial update semantics, and the need for redeploy. Combined with a complete input schema and destructive hint annotation, an agent has everything needed to invoke the tool correctly and set user expectations.

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?

Although the input schema already describes each parameter (100% coverage), the description adds semantic depth: it clarifies that `values` for `set` are a partial map (other vars persist) and that `keys` for `unset` are the specific ones to remove. It also reiterates that `list` only returns names and lengths, reinforcing the `action` enum behavior. This adds value over the schema's bare 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 opens with 'Project environment variables: list names, set them, remove them.' This clearly states the tool's function and scope. It covers all three actions (list, set, unset) and is distinct from sibling tools, which focus on domains, analytics, deploy, and other project ops. The verb+resource combination is specific and unambiguous.

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

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

The description provides useful usage context: `set` does not require knowing other variables, `unset` removes only the named ones, and changes require a new deploy. This helps an agent know when to use the tool and what to expect. It does not explicitly mention alternatives or exclusions, but since no sibling overlaps with env vars, this is acceptable. The guidance is clear enough for 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?

The readOnlyHint and idempotentHint annotations already establish the safety profile. The description adds useful context on what the output conveys (build results and which is live), and notes relative cost versus site_status. Since annotations carry the safety burden, a 4 is justified; it doesn't detail pagination but the output schema presumably covers return shape.

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 short sentences, zero waste. Front-loaded with the core purpose, then a practical use case, then a cost-saving tip. 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?

The tool is read-only with idempotent hints, has a full output schema, and only 2 params documented at 100% coverage. The description covers purpose, use case, and alternatives. Could mention limit/default behavior, but the schema handles that. Adequate for the tool's low complexity.

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 both parameters are fully documented in the schema. The description doesn't add param-specific detail beyond the schema, but the schema itself explains the project param well (with the slug-vs-id guidance and fallback via my_projects). Baseline 3 is appropriate when the schema does 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 title 'История сборок проекта' (Project build history) and the description state the purpose specifically: list recent builds, what each ended with, and which one is currently live. It distinguishes itself clearly from sibling tools like site_status, rollback, and diagnose_deploy by naming them and explaining its role as the prerequisite for those.

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 is explicit about when to use it ('выбрать цель для rollback или diagnose_deploy') and gives a clear when-not-to-use: for 'what's wrong with the site right now', site_status is cheaper. It names specific sibling alternatives, which is ideal usage 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 readOnlyHint and idempotentHint. The description adds the scope that it returns only design systems that ship with Layero, which is useful context. However, it does not disclose any other behavioral traits such as result ordering, pagination, or whether the catalogue is static or dynamic.

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, well-structured sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and easy to parse.

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

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

The tool is very simple with no parameters, strong annotations, and an output schema. The description provides sufficient context about the return value and scope. No additional details are required.

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 the schema covers everything. Per the rubric, a baseline of 4 applies. The description adds no parameter-specific information, but none is needed.

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

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

The description clearly states the tool returns the catalogue of design systems that ship with Layero. The verb 'Return' plus the resource 'catalogue of design systems' with the scope 'Layero ships with' is specific and distinguishes it from sibling tools like list_domains and list_structures.

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 implicitly indicates use when you need to see built-in design systems, but provides no explicit guidance on when not to use it or alternatives. No exclusions or comparisons to sibling list tools are mentioned, so usage context is only 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description only needs to add non-obvious behavior. It adds that the tool returns domain state, but does not mention filtering, pagination, or how 'own domains' differs from connected domains.

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, front-loaded sentence that states the resource and the returned information with no filler or redundant details. It is appropriately sized for the tool's simplicity.

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 presence of an output schema, read-only annotations, and a fully documented single parameter, the description is almost complete. It could be slightly stronger by explicitly saying 'list' the domains, but overall it covers the essential context for a simple list 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?

The single required parameter 'project' is fully documented in the schema with 100% coverage, including slug/id format and how to derive a slug from my_projects. The description adds no additional parameter semantics, 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 conveys the resource (project's own domains) and the data returned (their state), and the tool name 'list_domains' supplies the verb. It implicitly distinguishes this from sibling tools like connect_domain and check_domain, though it could be more explicit about the listing 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?

There is no guidance on when to use this tool versus alternatives such as check_domain or connect_domain. No exclusions, prerequisites, or alternative references are provided, leaving the agent to infer usage from the tool name and sibling names.

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 idempotentHint; the description adds minimal context that the catalogue is pre-shipped by Layero ('ships with'), but doesn't detail structure shape or output 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?

A single sentence with no redundant words, placing the verb and object upfront. 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?

With zero parameters, an existing output schema (not shown but present), and read-only/idempotent annotations, the description is sufficient for a simple catalogue listing; nothing critical 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 has zero parameters, so the schema fully covers parameter semantics; the description adds nothing needed for this dimension.

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 the explicit verb 'Return' and specifies the resource as 'catalogue of landing structures Layero ships with,' distinguishing it from sibling list tools like list_design_systems and list_domains.

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

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

No guidance on when to use this tool versus alternatives is provided; usage is implied by the name and simple read-only nature, but there are no exclusions or alternative references.

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 idempotentHint. The description adds the default behavior (thirty most recent) and a warning about context size, which is useful behavioral context beyond the schema.

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

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

Two short sentences that front-load the purpose and add one crucial behavioral note. No wasted words.

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

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

For a simple read-only list with a single optional parameter, the description covers purpose, default behavior, and a context-risk warning. The output schema and annotations fill in the rest, making it sufficient.

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% coverage with a detailed Russian description of the limit parameter. The tool description reinforces the default but adds no new technical details, matching baseline for high schema coverage.

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 states 'The user's sites on Layero' — clear resource and scope. It doesn't explicitly use a verb like 'list' or 'fetch', but the tool name and title make the action evident. No explicit differentiation from siblings like list_structures, but the resource is distinct.

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

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

Provides guidance on the default limit and warns against fetching the full list to avoid context flooding, but does not mention when to prefer this tool over siblings or any exclusions. The usage context 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?

The description is rich in behavioral caveats beyond the minimal `openWorldHint` annotation. It discloses that binary files sent as text are silently corrupted, the server does not remember the bundle between calls, and retrying a still-building deployment starts a second build. It also explains the early-return behavior with `status` and `deploy_id`, and advises following `next_action`.

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 long but every sentence carries essential information. It is front-loaded with the core purpose, then progresses logically through requirements, exclusions, state behavior, project mapping, and return semantics. No filler or redundancy; each paragraph earns its place.

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

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

Given the tool's complexity, the description is remarkably complete. It covers file limits and constraints, encoding pitfalls, build-step exclusions, statelessness, project handling, and asynchronous return behavior. The presence of an output schema does not reduce the need for this behavioral detail, and the description fully satisfies that need.

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?

Even though the schema already covers all parameters (100%), the description adds critical semantics: `project` determines whether to create or reuse a project, `files` must contain actual current file contents because the server has no memory, and the encoding requirements for binary files are reinforced. This goes well beyond the baseline 3 for full schema coverage.

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 clear, specific statement: 'Publish a site to Layero — from here, with no terminal.' It further clarifies that it accepts any ready static bundle, not just generated landings, and explicitly positions it as the answer to 'deploy my site', distinguishing it from sibling tools like compose_landing or diagnose_deploy.

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 explicit when-to-use and when-not-to-use guidance. It states that projects requiring a build step (Vite, Next, Astro) do NOT belong here, and directs users to publish the build output or use `npx layero@latest deploy` instead. It also explains when to pass `project` (republishing the same landing) versus when to omit 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?

Annotations declare readOnlyHint and openWorldHint, but the description adds substantial context: it returns a structured representation (not raw HTML) to conserve context, discloses that the full source is available on the user's disk, and explains the served_fallback edge case where a 200 response actually indicates a missing page. This goes well beyond 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 concisely structured: the first sentence states the core purpose, followed by usage timing, then a brief rationale for returning structure, and finally a warning about the fallback flag. Every sentence contributes meaningful 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?

Given the presence of an output schema and readOnly annotations, the description fully complements the structured data by explaining the return format, the reason for the structured representation, the fallback semantics, and the alternative of getting raw HTML. This is complete for a read 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% for both parameters (project and path). The description adds little para-specific detail beyond the schema, except implicitly reinforcing that the path is a page path, not a file. Baseline 3 is appropriate as the schema carries the parameter documentation 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 'Что на самом деле опубликовано' (what is actually published), clearly identifying the tool's scope as the live-served page, not the local disk. It lists specific content types (headings, texts, forms, meta, links) and distinguishes itself from sibling tools by focusing on the published structure.

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 instructs to call this tool BEFORE editing and AFTER publishing to verify changes. It contrasts with reading the raw source from the user's disk, explains the risk of blind editing, and warns about the served_fallback=true case, providing clear when-to-use and 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 readOnlyHint=true and idempotentHint=true. The description reinforces idempotency ('repeat calls change nothing and honestly answer changed=false') and adds valuable context: empty change list is a valid response, the tool publishes nothing, and it discloses the excluded work domains. It adds meaningful behavioral 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?

The description is structured with clear sections (verdict, safety note, idempotency, exclusions, measurement protocol). It front-loads the core function in the first sentence. It is somewhat verbose and uses heavy formatting (⚠️, ALL-CAPS emphasis) which carries important warnings but could be trimmed. Every sentence serves a purpose — 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 transformation tool with two well-documented parameters, a good safety model (non-publishing), output schema present, and idempotency annotations, the description is thorough: it covers return semantics (changed=false), the workflow contract (human approval before publish), exclusion boundaries (site_issues), and measurement guidance (check_performance threshold). Given the annotations and schema richness, this is 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% with both parameters documented. The description's main added value is the global scope note (tool is non-publishing, idempotent) rather than per-parameter detail. The fix enum values are well described in the schema; the description reinforces contextually. Slight deduction since the description doesn't add per-parameter meaning beyond the schema, though the fix semantics are already rich there.

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: 'apply one named transformation to markup with a predictable result.' It clearly distinguishes from siblings by explicitly stating it returns modified HTML rather than publishing, naming publish_landing as the separate publishing step. The distinction from site_issues (which reports problems it doesn't fix) is explicit.

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?

One transformation (rendering) produces HTML instead of publishing; the description explicitly tells the agent to show it to a human, get consent, and call publish_landing. It clearly states when NOT to use it: fonts from third-party hosts, webp conversion, and inline-style parsing are excluded and belong to site_issues. It also specifies when to use it — measuring wins via check_performance before/after, with noise threshold of three points.

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 provide only openWorldHint=true, so the description carries the safety burden. It does an excellent job: it discloses that the platform will reject non-failed builds as a protective measure, and explains the semantics of retry (when meaningful vs futile). It also explains the `deploy` parameter default behavior. The warning about retry being pointless for code failures is valuable behavioral context beyond the schema.

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

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

The description is well-structured with clear paragraphs: purpose statement, explicit state constraints with a warning, and a usage decision guide. It's somewhat longer than the TDQS high example but every sentence earns its place — the state constraint, protection note, and retry semantics are all essential. No 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 state-sensitive mutation tool with only openWorldHint annotation and an output schema present, the description is remarkably complete. It covers: valid input conditions (failed state), platform rejection behavior, the decision framework (external vs code failure), the recommended workflow order (diagnose → fix → retry), and the sibling tool used in that workflow. This is comprehensive for a two-parameter 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 100% — both `project` and `deploy` have descriptions. The description adds marginal value: it restates that `deploy` defaults to the latest build when omitted (which the schema's default=null partially conveys). The description doesn't add syntax details 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 the verb+resource+condition: 'Поставить упавшую сборку в очередь заново' (requeue a failed build). It specifies the state constraint (only `failed` builds). This distinguishes it from siblings like `cancel_deploy`, `deploy_logs`, and `rollback` which have different purposes.

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 is exceptionally explicit about when to use this tool: ONLY for builds in `failed` state, and it explicitly warns that queued/building builds will be rejected by the platform (a protection, not an error). It also provides decision guidance: retry only makes sense for external causes (network, registry, timeout); for code failures it gives a full workflow: diagnose_deploy → fix → then retry. This explicitly names the alternative `diagnose_deploy`.

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 declare destructiveHint=true and openWorldHint=true, establishing this is a mutating, user-visible action. The description adds meaningful context beyond these: it explicitly warns that it visibly changes what visitors see, discloses reversibility limits (the time window with the wrong live version is irrecoverable), and candidly notes frequent failure for app platforms. This transparency meaningfully exceeds what the annotation booleans convey, though without output schema or return details it doesn't reach 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 compact: a purpose line, a highlighted behavioral warning, and a platform-specific proviso. Every sentence earns its place, the most critical user-impact warning is bolded and front-loaded, and no filler or redundancy exists. Excellent structure for a high-risk mutation tool.

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 output schema exists (so return format is documented elsewhere) and annotations flag destructive/open-world behavior, the description is appropriately complete. It covers purpose, safety framing, user-consent requirement, platform limitations, and failure-handling guidance. The only minor gap is not stating prerequisites (e.g., whether a prior successful deploy is required), but the schema note about 'ближайшую пригодную' partially covers this. Strong overall 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?

Schema description coverage is 100%, so both parameters (project and deploy) are documented in the schema itself. The description does not add parameter-level meaning beyond the schema; however, it implies deployment mechanics contextually. With full schema coverage, baseline 3 is appropriate — the description doesn't compensate for any gap because no gap 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 description clearly states the action: return the previous working build to the live address. It distinguishes the resource (site build) and verb (rollback) precisely, and the title complements rather than tautologizes. The scope is specific and unambiguous.

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

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

The description provides explicit guidance: call only when the user explicitly requested a rollback, ask first if not requested. It also names specific app types (ssr_next, streamlit, gradio, flask) where rollback often fails, and directs fallback behavior (offer rebuild, don't retry). This is model usage guidance exceeding the dimension requirements.

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 the time series is collapsed into a direction and breakdowns are limited to five items, explaining why raw chart points are not returned. This adds meaningful behavioral context. It doesn't cover pagination or auth, but for a simple read-only analytics tool, this is substantial.

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 exactly two sentences: the first gives a clear summary, the second explains the aggregation rationale. Every word earns its place, and the key info 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?

Given the presence of an output schema and simple parameters, the description conveys the tool's scope and behavior sufficiently. It doesn't explicitly state when not to use, but the tool is straightforward and the combination of description, schema, and annotations gives the agent a solid understanding.

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: period has an enum and default, project has slug/id explanation and a pointer to my_projects. The description adds no additional parameter-specific information; it only describes output semantics. With 100% schema coverage, 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 states 'Site traffic: totals, direction and top sources', clearly identifying the tool as providing traffic summary data. It distinguishes from sibling tools like site_status or site_issues, though the verb is implicit and no explicit alternative is named.

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 obtaining a concise traffic overview, noting that detailed time series are intentionally omitted. However, it does not explicitly state when to use this tool vs others, and no sibling alternatives are mentioned. The context is clear but exclusion criteria are absent.

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 `openWorldHint: true`, but the description adds valuable behavioral context: issues are sorted by importance, the output should be summarized rather than listed, and the tool focuses only on issues with a clear address and action. This goes beyond the structured 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 paragraphs and somewhat longer than the minimal case, but every sentence contributes value: it defines the scope, contrasts with a sibling, gives examples of issue types, mentions sorting, and provides usage guidance. It is well-structured and front-loaded, though slightly verbose.

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 an output schema present and rich annotations, the description covers essential context: it explains the tool's output (issues with addresses and actions), how to present results to the user, and what kinds of issues are included. This is complete for an agent to use the tool correctly.

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

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

Schema description coverage is 100%, so the baseline for this dimension is 3. The description does not add additional meaning to the parameters `path` and `project`, but the schema already provides detailed explanations for both (e.g., slug vs id, default path). No further compensation is needed.

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

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

The description clearly states the tool's purpose: it lists specific page issues, each with an address and a concrete action. It explicitly contrasts with `check_performance` (which gives a score without actionable items), thereby distinguishing itself from a sibling tool. The resource is 'site issues' and the verb is implicit but clear from context.

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

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

The description explicitly says when NOT to use this tool (when you have a performance score) and points to the alternative (`check_performance`). It also provides clear usage instructions for the agent: do not dump the full list, but highlight the top 2-3 issues and ask whether to fix them. This is strong 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?

With readOnlyHint=true provided, the annotation already covers the safety profile. The description adds meaningful extra context: the screenshot is generated at build time, not on-demand, so it may be stale after a fresh publish. This is critical behavioral disclosure that prevents the agent from misattributing the screenshot's content. Lacks some detail on exact staleness timing but otherwise strong.

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 short paragraphs, front-loaded with the core purpose in the first line, then useful caveats. Every sentence earns its place, with zero filler or repetition of schema/annotation content.

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 single-parameter read-only tool with a well-documented schema parameter and readOnlyHint annotation, the description fully covers purpose, usage context, timing caveats, and cost considerations. The inclusion of the cost/value warning is particularly thoughtful. No output schema needed given the tool's simplicity.

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 single 'project' parameter already has a detailed description explaining it accepts a slug or id and how to derive the slug (from my_projects). The tool description doesn't add anything beyond the schema, which aligns with the baseline 3 for high coverage single-parameter tools.

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 shows the last built version of the site as it looks visually. It distinguishes from siblings by explicitly naming read_site (content) and site_issues (problems), establishing this tool answers the third question: appearance. The verb+resource+scope is specific and differentiating.

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

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

The description explicitly states when to use it (before/after visual editing) and gives concrete exclusions: don't call aimlessly, and notably warns not to pass off a stale screenshot as the result of one's own edits after publishing. It also directs users to site_issues as the cheaper, more specific alternative for diagnosing problems. This is exemplary 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?

The annotation readOnlyHint=true already establishes this as a safe read operation. The description adds useful context about combining three checks into a single conclusion, but does not disclose other behavioral details like potential delays, caching, or error scenarios. This is acceptable 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 compact and front-loaded: it states the purpose in a single sentence, then adds the parameter clarification and rationale in a short parenthetical. Every sentence earns its place 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?

Given the tool's simplicity (one parameter, fully described schema, output schema present) and the read-only annotation, the description is complete enough. It adequately covers behavior and usage context without needing to explain return values or additional scenarios.

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 fully documents the 'project' parameter. The description briefly restates the id/slug distinction and references my_projects, but adds no new semantics beyond what the schema already provides.

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 what the tool does: it reports whether a site is being served and how its build ended. It also distinguishes itself from alternatives by positioning itself as the one-call conclusion instead of assembling raw data from three separate tools (project, deploys, live check).

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 describes when to use the tool: when the agent needs the conclusion rather than raw material. It also tells the user to get the slug from my_projects if needed. While it doesn't name sibling tools explicitly, it clearly enumerates the individual checks it replaces, giving sufficient context.

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

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

The annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds behavioral detail about error handling ('a clear error here') and indicates that the tool validates token configuration, which goes beyond 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 sentences, front-loads the purpose, and every sentence contributes. 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?

The tool has no parameters, an output schema exists, and the description covers purpose, usage, and behavioral context. The combination of annotations and description fully equips an agent to invoke 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?

The tool has zero parameters, so parameter semantics are trivial. The description appropriately omits parameter details. Baseline for zero-param tools is 4.

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

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

The description clearly states what the tool does: 'Who is connected to Layero and how many projects they have.' It specifies the resource (Layero) and the output (connection status and project count). This distinguishes it from sibling tools like my_projects or site_status, which have different scopes.

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

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

The description explicitly states when to use the tool: 'Call this first when you are unsure the token is configured.' It also provides a rationale ('a clear error here is cheaper than one halfway through a deploy'), giving clear context for usage. It does not name alternatives, but the guidance is explicit.

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