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

With no annotations provided, the description bears full responsibility. It clearly states 'It modifies no files: apply the returned plan yourself', effectively communicating the read-only, non-destructive nature. It also describes the output format, adding beyond what annotations could 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?

Two sentences: first states the core purpose, second clarifies behavior and output. Front-loaded and concise with no unnecessary words. Every sentence adds 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?

For a simple planning tool with no output schema, the description covers what the tool returns (instructions, manifest additions, templates) and its non-modifying behavior. It could mention prerequisites (e.g., project must be a valid extension) but is largely complete. Score 4.

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 67% (feature and projectPath have descriptions; framework does not). The description adds context about output (templates, manifest additions) that relates to parameters, but does not independently explain each parameter beyond the schema. 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 specifies the verb 'Plan' and the resource 'a new feature surface for an existing extension', clearly differentiating from siblings like extension_create or extension_build. It details the output (step-by-step instructions, manifest additions, reference templates) and explicitly states that no files are modified.

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 existing extensions to plan a feature, but does not explicitly state when to use this tool versus alternatives, nor does it provide when-not-to-use guidance. It is adequate but lacks explicit contextual boundaries.

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

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

With no annotations, the description must convey behavioral traits. It clearly states the tool is static, reads from dist/<browser>, and never touches a browser. It does not mention non-destructiveness explicitly, but the static nature implies no side effects. Could be more explicit about safety, but adequate.

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, no wasted words. First sentence covers purpose and specifics, second sets boundaries and alternatives. Front-loaded and efficient.

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

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

Given 3 params, no output schema, and no annotations, the description covers core functionality, prerequisites, and sibling differentiation. Missing details on output format styles and 'store-readiness checks', but sufficient for basic use.

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 67% and parameters are well-named with enums and defaults. The description adds little beyond the schema; it does not explain how 'format' affects output or the meaning of 'browser'. Baseline score is appropriate given schema handles most semantics.

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 it analyzes a BUILT extension on disk, listing specific aspects (file sizes, entry points, permissions, bundle composition, store-readiness). It distinguishes from sibling tool extension_inspect by specifying static vs. live analysis.

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

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

Explicitly states prerequisite (build first with extension_build), clarifies the tool is for static analysis only, and directs users to extension_inspect for live DOM/console inspection. This provides excellent 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?

With no annotations, the description discloses verdict semantics (pass/fail/inconclusive) and notes that inconclusive is never a pass Newton. It implies read-only behavior but doesn't explicitly state no side effects or prerequisites beyond extending dev session; still, it provides meaningful 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?

Two sentences pack purpose, verdict semantics, and alternative tools without fluffaine; the structure is efficient, though slightly dense.

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 annotations, the description covers the operational context well: how verdicts work, what inconclusive means, and the prerequisite of starting with extension_dev. It doesn't describe return value format, but it's adequate for usage decisions.

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 does not add substantial semantics beyond what the schema already documents for each parameter. Baseline 3 applies since schema is complete.

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 it runs a test stage against a live dev session and reads verdicts per expectation. It explicitly distinguishes itself from extension_inspect and extension_logs by noting the alternative for raw readings.

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 says to start with extension_dev and to use extension_inspect or extension_logs when raw readings are desired, giving 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?

With no annotations provided, the description carries the full burden of behavioral disclosure—and it excels. It reveals that status never returns the token, identity does not depend on the working directory, server verification can result in three distinct states, login never stores a GitHub token, tokens expire server-side after 7 days, and logout only removes local credentials. This level of transparency is exceptional and leaves no misleading assumptions.

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 appropriately sized for a complex auth tool with three distinct modes. It is front-loaded with the action summary and then methodically explains each path. Some redundancy exists (e.g., repeating 'deviceCode'), but no sentence is wasted; the length is justified by the need to convey security and flow details. It remains readable and well-organized.

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

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

Despite having no output schema, the description is complete enough for an agent to invoke all three actions correctly. It explains the login handshake, status verification states, token lifetime, logout side effects, and API base URL default. The richness of contextual details ensures the agent understands not only what to call but also the expected behavior and caveats, making this a fully self-contained tool 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?

The schema covers 75% of parameters (api, project, deviceCode have descriptions; action only has an enum). The description adds substantial meaning to action, project, and deviceCode by explaining the two-phase flow, the workspace/project slug format, and the role of deviceCode in resuming login. It does not elaborate on the api parameter, but the schema already provides its default behavior, and the description's added context goes well beyond schema basics.

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 precise, verb-driven summary: 'Sign this machine in to extension.dev, report that login, or clear it.' It clearly enumerates the three actions (status/login/logout) and distinguishes this tool from sibling dev tools by focusing on authentication lifecycle. The scope is unambiguous and immediately differentiates from the other extension_* siblings.

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 instructions for each action, including the two-phase login flow, project parameter format, and logout semantics. It stops short of explicitly stating when not to use this tool in favor of a sibling, but the auth-only purpose is clear from the name and context; the action-level guidance is thorough 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?

With no annotations, the description carries full burden. It discloses that install downloads 580-625 MB in one blocking call and that uninstall never touches system installs. It could mention potential failure modes or that detect might be slow, but overall it provides good behavioral insight.

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 paragraph but efficiently organizes information by action. Every sentence adds value, and the most important information (purpose and actions) comes first. No unnecessary 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?

While the description covers the main actions and their inputs, it lacks explicit details on return values for each action. For example, it does not specify the format of the output for detect or list, and for install/uninstall it does not confirm success/failure indicators. However, given the moderate complexity and lack of output schema, it is mostly 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 coverage is 75% (3 of 4 parameters have descriptions). The description adds context beyond the schema: it explains the actions in detail and specifies which parameters apply to which actions (e.g., 'browser' for install/uninstall, 'browsers' for detect). This helps an agent use parameters correctly.

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: 'Find, install and remove the browsers Extension.js tooling can launch.' It specifies each action (detect, list, install, uninstall) and what it does, making it distinct from sibling tools which focus on extension development rather than browser management.

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 instructions for each action, including default behavior, required parameters, and important caveats like the large download size and generous timeout needed for install. It clearly differentiates between system and managed browsers, helping the agent decide when 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?

With no annotations, the description carries full disclosure burden. It reveals output location, Safari-to-macOS conversion, bundleId behavior, and the refusal on build-blocking errors (with rationale), offering strong transparency into non-obvious side effects.

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

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

The description is four sentences, front-loaded with the core purpose, then adding output, zip, Safari, and validation behavior. Each sentence provides unique, necessary information without redundancy.

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

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

For a tool with 13 parameters, no annotations, and no output schema, the description covers the most critical non-obvious aspects (Safari, validation, zip). It omits some minor parameters like mode and silent, but the schema descriptions fill those gaps, making the description sufficiently complete for an agent.

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

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

Schema coverage is high (92%), so baseline is 3. The description adds value by explaining zip:true's store submission purpose, Safari-specific browser behavior, bundleId identifier role, and skipValidation logic. It does not cover all params (mode, silent, etc.), 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 states 'Build a browser extension for production' with a specific verb, resource, and scope. It also specifies output location (dist/<browser>) and unique behaviors (Safari conversion, validation refusal), distinguishing it from sibling tools like extension_dev.

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 clear context for production builds and specific use cases (zip for store submission, Safari conversion, skipValidation). However, it does not explicitly mention when to use alternatives like extension_dev for development, leaving some ambiguity.

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 git repository initialization may occur and tells the agent to read the defaultsApplied block in the result. No annotations are provided, so the description carries the burden; it covers key behaviors but could mention potential side effects like overwriting.

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 sentences, each serving a clear purpose: stating action, prerequisite, and behavioral note. No unnecessary words or information.

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

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

Given no output schema or annotations, the description covers purpose, prerequisite, side effect (git init), and how to interpret results. It lacks details on error conditions or dependencies but is fairly complete for a create tool with well-documented parameters.

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

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

Schema coverage is 100%, and the description does not add new meaning beyond the schema's parameter descriptions. No additional parameter guidance is provided, 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 tool creates a browser extension project from a template, with the specific verb 'create' and resource 'browser extension project'. It distinguishes from sibling tools like extension_templates which lists templates.

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 advises calling extension_templates first to see available templates, providing clear usage context. While it doesn't list when not to use, the guidance is direct and helpful.

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 control/eval channels, carrier behavior, replace conflict handling, and that result carries process info for other tools. No annotations present, so description bears full burden and excels.

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?

Well-structured: front-loads purpose, then details parameters and relationships. Every sentence provides necessary information without redundancy.

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

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

Comprehensive for a complex tool with 16 parameters and many siblings. Explains return value implications and dependencies on other tools.

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?

Adds significant context beyond schema: carrier gitignored, replace stops live session, allowEval implies allowControl. Schema coverage is 94%, but description still adds value.

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

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

Clearly states it runs the extension in dev mode with dev build, HMR, and browser. Distinguishes from extension_start for production build.

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 says 'Reach for this first when the ask is 'run my extension'.' Contrasts with extension_start and explains when to use alternative tools.

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

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

With no annotations, the description fully discloses behavior: it returns a per-leg object in dependency order, clarifies that 'skip' means blocked (not pass), and explains the read-only behavior for sessions without allowControl. This goes beyond a simple 'diagnose' and prepares the agent for unexpected statuses.

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 main diagnostic purpose, and each later sentence earns its place by adding behavioral nuances or usage guidance. No fluff, tightly packed with essential information.

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

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

Despite the lack of an output schema, the description fully explains the return shape and semantics. It covers both diagnostic modes, error handling context, and the meaning of distinct statuses (skip, read-only). This is complete for a tool of this 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% for both parameters, so baseline is 3. The description adds semantic clarity by explicitly noting that omitting projectPath triggers a pre-flight environment check, which supplements the schema's 'Omit for a pre-flight environment check' with additional context about what that check includes.

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: 'Diagnose a dev session end to end' and enumerates the specific checkpoints (ready contract, dev-server process, etc.). It clearly distinguishes itself from sibling act tools by positioning itself as a diagnostic tool to run first when act tools error.

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?

Explicit when-to-use guidance is given: 'Run this first when any act tool (storage, reload, eval, open) errors unexpectedly.' It also explains the two invocation modes (with/without projectPath) and the pre-flight use case. This clearly differentiates it from the act tools and sets expectations for when it should be called.

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

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

With no annotations, the description fully carries the burden. It discloses key behaviors: localhost only, need for debug port, optional byte-capped HTML, console lines, ambiguous tabUrl returns candidates, and that it does not navigate or run probes. Comprehensive.

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

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

The description is lengthy but front-loaded with the main purpose. Some sentences are dense with technical details, but every sentence adds value. Slightly more concise could improve, but still well-structured.

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

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

Given the tool's complexity (12 params, no output schema), the description covers prerequisites, behavior, limitations, and output characteristics. It explains what to expect for ambiguous inputs (returns candidates) and lists what the tool does not do.

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 high (92%), but the description adds significant extra context: explains the purpose of listTabs/listTargets, clarifies the context enum meanings, and details how tabUrl resolution works. This goes well beyond the schema descriptions.

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

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

The description clearly states the tool's purpose: taking a shallow structured DOM snapshot of a chosen surface. It specifies it is the 'SURFACE PICKER' and contrasts with extension_inspect, making the purpose 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 explicitly states when to use this tool vs alternatives: 'does not pierce closed shadow roots... use extension_inspect for those'. It also mentions the prerequisite 'Start the session with allowControl:true (extension_dev)', providing clear usage context.

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

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

With no annotations provided, the description fully discloses behavioral traits: writing a session token, default context behavior, Chromium MV3 specific changes, error messages for closed surfaces, and disambiguation logic. These are critical for safe usage.

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 paragraph that efficiently covers core purpose, multiple edge cases, and usage guidelines. Every sentence serves a purpose, and the most important 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?

The description thoroughly covers usage contexts but does not explicitly describe the return value format. Given the complexity of the tool and no output schema, a brief note on what the tool returns would enhance completeness, though the lack is minor.

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?

Despite 100% schema coverage, the description adds significant value by explaining parameter interactions (e.g., url vs tab, context defaults, no need for tab in extension surfaces). It goes beyond the schema to clarify disambiguation and prerequisites.

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 evaluates an expression in a running extension context. It distinguishes itself from siblings by detailing specific contexts and scenarios, such as background, page, and extension surfaces, making its purpose 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 explicitly provides when to use this tool, including references to extension_dev for session start and extension_dom_snapshot for tab enumeration. It also explains defaults and when to use url vs tab, and warns when a closed surface returns an error, offering clear 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?

With no annotations provided, the description fully discloses behaviors: it navigates tabs, pierces closed shadow roots, runs selector probes, picks the first inspectable target, and cannot address by name. It also details browser-specific behavior for Chromium vs Firefox, including permission requirements (allowControl, allowEval, host permissions).

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 core purpose and then detailing capabilities and limitations. While long, the complexity of the tool justifies the length. Slightly verbose but efficient.

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

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

The description is highly complete given the tool's complexity, covering behavior, limitations, browser differences, and prerequisites. However, it lacks explicit description of the return value or output structure, which would be helpful since no output schema is provided.

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?

All 7 parameters have schema descriptions (100% coverage), and the description adds substantial context beyond the schema, e.g., explaining deepDom piercing, the include options, maxBytes truncation, and the need for a live dev session for projectPath.

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

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

The description clearly states that the tool inspects a running extension deeply over the browser's debugger protocol, listing specific capabilities (HTML, shadow DOM, console, probes). It explicitly distinguishes from sibling tools like extension_dom_snapshot and extension_analyze, making the purpose 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 on when to use this tool versus alternatives: use extension_dom_snapshot for choosing tabs/surfaces, use extension_analyze for built extension files. It also notes that the tool requires an active dev or start session, giving clear use cases and prerequisites.

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

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

With no annotations provided, the description carries the full burden and excels. It explains browser-specific differences (Chromium via CDP requiring live contexts, Firefox via RDP listing add-ons regardless of contexts), owns-extension detection, and dormant service worker behavior. It also clarifies that other extensions' contexts are never attached or evaluated.

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 detailed but well-structured, starting with the core function then diving into browser-specific details. Every sentence adds value, though a slight trim could be made. It is appropriately front-loaded with the main action and critical requirements.

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

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

Given the complexity of cross-browser differences and lack of annotations, the description covers the essential details: what the tool does, returned fields, browser behaviors, and session requirements. No output schema exists, but the description sufficiently describes return structure (id, name, version, contexts, ownExtension flag). It is complete for a list 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% for both parameters (browser and projectPath). The description adds context about session requirements (e.g., projectPath needing a live dev session) but does not significantly enhance parameter understanding beyond the schema. Baseline of 3 is appropriate given the schema already describes parameters well.

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

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

The description clearly states the verb 'list' and the resource 'extensions in the running dev browser,' specifying the information returned (id, name, version, live contexts on Chromium). It distinguishes behavior across browsers and mentions the own-extension marker, making the purpose unambiguous and distinct from sibling tools.

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

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

The description explicitly requires an active dev or start session, providing a clear precondition. It implies when to use the tool (to inspect installed extensions) but does not explicitly state when not to use it or suggest alternatives. The detail on browser-specific behavior acts as a guideline for expected differences.

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

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

No annotations are provided, so the description carries the full burden. It explains the behavioral modes (one-shot, follow), the bounded window, and the requirement for an active session. It does not mention destructive actions, which is appropriate for a read-only tool. 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?

The description is concise, with front-loaded main purpose and no unnecessary words. It is a single paragraph of four sentences that 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 has 11 parameters and no output schema, the description explains overall behavior and modes but does not describe the return format or details of structured diagnostics (signalsOnly). It is adequate but could be more 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 100%, so baseline is 3. The description adds the concept of 'agent-bridge plane' and 'live control channel' which provide context, but does not significantly enhance understanding of individual parameters 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 verb (read/stream) and the resource (logs from all contexts of a running dev session), and distinguishes it from the CLI tool. It is specific and actionable.

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 context about one-shot vs follow mode and requires an active extension_dev session, but does not explicitly compare to sibling tools or state when not to use it. Lacks clear when-to-use versus 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?

With no annotations, the description should disclose side effects, permissions, or output behavior. It mentions reporting actions but does not confirm read-only status, clarify whether it modifies state, or describe the response format. The reference to buildBlocking adds context but more detail would improve 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?

Two sentences cover essential information: purpose and a key usage hint. No filler words; every sentence adds 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?

No output schema exists, and the description does not clarify the structure of the validation report (e.g., error codes, severity levels). While the listed checks give some context, the format and how to interpret results remain unclear.

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 parameters are well-documented in the schema. The description does not add new meaning to parameters—it only states the tool's purpose. Baseline score 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 specifies a concrete action ('Validate a manifest.json'), identifies the resource, and lists specific checks (missing fields, invalid permissions, dangling file references, cross-browser compatibility). It differentiates from siblings like extension_analyze or extension_doctor by focusing solely on manifest validation.

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 suggests use before building by referencing buildBlocking errors. However, it does not explicitly compare with sibling tools (e.g., when to use extension_analyze instead) or state prerequisites.

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

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

With no annotations, the description fully discloses key behaviors: the effect of each surface, automatic use of asTab in headless sessions, gesture-derived activeTab grant not applying for action/command, and the need for allowControl:true. This is comprehensive.

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

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

The description is a single dense paragraph that front-loads the main action. While it packs much information, it could be more structured with bullet points or clearer separation of scenarios. Still, every sentence adds 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 tool's complexity (7 parameters, enum, no output schema), the description covers essential aspects: all surface options, asTab behavior, gesture implications, session requirement. It omits return format but that is acceptable without an output schema.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value beyond schema by explaining how parameters interact (e.g., surface='command' requires name, asTab applied automatically in headless). It clarifies behavioral aspects not 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 states the tool opens an extension surface or replays an event in a running session. It enumerates specific surface values (popup, options, sidebar, newtab, history, bookmarks, action, command) and their distinct behaviors, distinguishing it from sibling tools like extension_start or extension_eval.

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 context on when to use each surface type, including UI surfaces, chrome_url_overrides, toolbar action, and command replay. It also notes the gesture limitation for action and command, but does not directly compare to sibling tools.

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

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

With no annotations provided, the description carries the full burden, and it is remarkably thorough: it discloses builds, uploads, quota consumption, zip exposure of source code, token requirements, expiry, permanent revocation, and the gitignored shared-previews.json record. It also warns the agent to read the share property before using the response.

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 purpose is front-loaded and each clause is information-dense, so nothing feels like filler. However, it is a long single block of text for its length, and the complexity of the sharing lane could benefit from sharper structural segmentation. This is acceptable given the tool's complexity.

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

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

There is no output schema, yet the description covers the key return concepts: share URL, zip URL, local deepLink, share.browserLoadable, expireAt, revokeUrl, and the local dev-server constraint. It also covers auth side effects, lifecycle, and cleanup, so an agent can invoke and respond to the tool safely.

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?

Since schema description coverage is 100%, the baseline for adding value is already high. The description does add meaningful parameter usage context, especially for share:true, build:false, and browser→dist/<browser>, but it does not enrich the other parameters in any meaningful way 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 opening sentence states a specific action: preview an in-progress extension in the web emulator with no real browser. It then describes the resource and behavior — building the project and previewing dist/<browser> — and clearly distinguishes the shared-preview lane from the dev-only deep-link lane.

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 an explicit selection rule: pass share:true unless you are inside the extension.dev monorepo, noting that sharing is the only lane that works from an npm install. It also marks the default lane as being for extension.dev developers and names extension_shares as the cleanup path for shared links.

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

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

With no annotations provided, the description fully carries the behavioral transparency burden. It discloses the two-phase device flow, the temporary provisioning grant ('lives minutes, can only create the one named project, and is never stored on this machine'), the automatic GitHub App installation discovery, fallback connect link, and side effects (creates project, mirror repo, dispatches first build). This goes far beyond basic mutation disclosure.

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

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

The description is a dense paragraph but every sentence provides distinct value: purpose, sequencing, prerequisites, two-phase flow, security properties, success side effects, and follow-up actions. It is front-loaded with the primary purpose and maintains tight, information-rich phrasing without redundancy.

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

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

For a complex two-phase tool with 10 parameters and no output schema, the description is remarkably complete. It covers prerequisites, the approval flow, security behavior, post-success state, and next steps. The only gap is lack of explicit success-response structure or error cases (e.g., project already exists), but given the rich flow description, this is a minor omission.

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

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

The schema already covers 100% of parameters with detailed descriptions, giving a baseline of 3. The description adds meaningful semantic context by explaining the high-level flow ('call again with the returned deviceCode to finish'), advising against using installationId ('Leave it out'), and simplifying scope ('Ask for nothing but the project slug and the repo'). This elevates it above baseline, though individual parameter detail is largely 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 opens with a specific, unambiguous statement: 'Create an extension.dev project for an extension that does not have one yet, without opening the console.' It further distinguishes this tool from siblings by placing it in a sequence (after extension_create and extension_build, before extension_auth), making its unique role clear.

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 timing: 'Use it right after extension_create and extension_build, once the extension's source is pushed to a GitHub repository, and BEFORE extension_auth.' It also explains why ordering matters ('extension_auth can only log in to a project that already exists') and what not to ask for ('Ask for nothing but the project slug and the repo'), effectively guiding selection among siblings.

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

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

Without annotations, the description fully discloses behaviors: no local file upload, no projectPath, token-scoped, and details for public vs. private projects, including ttlHours being ignored for public projects and buildSha rejection for unknown shas.

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 somewhat lengthy but each sentence adds value. It is front-loaded with the main action and then explains nuances. Slight room for tightening but overall efficient.

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

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

Given no output schema, the description explains the return value (shareable URL) and covers key behavioral details. It is complete for a tool with 3 optional parameters, though could mention error cases or prerequisites.

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%, providing baseline 3. The description adds context beyond the schema: explains that buildSha pins to a specific build and is rejected if unknown, ttlHours only applies to private projects, and api defaults 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 clearly states it publishes the project to extension.dev and returns a shareable URL. It distinguishes from extension_submit ('store-review path') and explains it is what 'deploy' or 'ship' usually means, providing a specific verb and resource.

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

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

The description explains when to use this tool (to publish/deploy) and contrasts it with extension_submit. It also clarifies behavior differences for public vs. private projects, but does not explicitly state when not to use it or provide alternative tools for different contexts.

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

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

The description explicitly states 'This WRITES' and explains auth-gating and token expiry. It also indirectly conveys irreversibility through the approvalId parameter description ('not reversible in place'). While this information is present, it is not repeated in the main description, so a slight deduction is warranted.

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, conveying necessary information in a few sentences without redundancy. It balances clarity and brevity, earning a high score.

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 key contextual elements: prerequisites (buildId), authentication, limitations (headless constraints), and the irreversible nature via parameter docs. It lacks an explicit output description, but since there is no output schema, this is not a significant gap. Overall, it is sufficiently complete for the tool's 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?

The schema already provides rich descriptions for all parameters (e.g., buildId, channel, approvalId). The main description adds only minor context (e.g., buildId is found via release_status, project comes from token), which does not significantly enhance the schema's coverage. Thus, baseline score 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 purpose: 'Promote a built extension to a release channel' and explicitly differentiates it from siblings by noting it is 'the only verb that changes what a channel points at.' This makes the tool's role 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 usage context by mentioning the prerequisite to 'Call extension_release_status to find a valid buildId' and notes limitations such as not being able to cut a version-bump PR headlessly. However, it could more explicitly contrast with alternative tools beyond stating it is the only verb for channel changes.

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?

Since no annotations are provided, the description fully carries the burden. It explicitly states 'read-only', 'dispatches nothing and promotes nothing', describes the data returned for each include option, and mentions access control and potential lag.

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 detailed but not verbose. Every sentence provides useful information, though it could be slightly more streamlined. It is front-loaded with the main purpose.

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

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

Given the lack of an output schema, the description compensates well by outlining the kind of data returned for each include option. It covers purpose, behavior, parameters, and usage context comprehensively.

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%, but the description adds significant value by detailing what each include option returns and how the workspace/project parameters default. The api parameter's default URL is also clarified.

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 starts with 'Read where a project stands on extension.dev, from the public registry', using a specific verb and resource. It distinguishes itself from sibling tools like extension_release_promote and extension_submit by explicitly stating it is read-only.

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 when to use the tool (to read status), how to use the include parameter to get releases or stores data, and how the output can be used to find valid SHAs for other tools. It also covers default behavior and limitations like lag.

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

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

No annotations are provided, so the description must disclose behavioral traits. It states 'reload' (a mutation) but does not mention side effects (e.g., state loss), whether the extension must be running, or what happens to open connections. The note about allowControl is useful but insufficient for full 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?

Two sentences with no wasted words. The main action is front-loaded, and the critical prerequisite is included. Every sentence adds 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?

The tool has five parameters, no output schema, and moderate complexity. The description covers the core purpose and a key prerequisite but omits details like error conditions, effect on extension state, or that a live dev session is required (implied in schema). Adequate but not comprehensive.

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 80%, so the schema already describes four of five parameters. The description does not add additional meaning beyond the schema, such as how 'context' affects the reload behavior. It meets the baseline but does not enhance understanding.

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

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

The description clearly states the tool reloads a running extension's background context or a tab. It uses specific verbs ('Reload') and identifies the resources ('extension's background context, or a tab'), distinguishing it from other extension tools like extension_start or extension_stop.

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 prerequisite: 'Start the session with allowControl:true (extension_dev).' This gives clear guidance on when to use the tool but does not explicitly exclude alternatives or describe 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?

With no annotations provided, the description carries full disclosure responsibility. It clearly states that revoke 'permanently kills' a share and 'cannot be undone', explains the approval gate for revokes, details the append-only and read-only nature of the local record, and clarifies nuanced field semantics (e.g., server.count vs server.scanned).

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 dense, front-loaded paragraph that begins with the core purpose and then layers actionable detail. Every sentence contributes unique information, but the single-paragraph structure could be better organized with bullets or sections for improved scannability. Still, it is appropriately sized for the tool's complexity.

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

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

Given 8 parameters, no output schema, and no annotations, this description is exceptionally complete. It covers return fields, row-level semantics, attribution meanings, authentication behavior, approval requirements, local record reconciliation, and count semantics, leaving no significant ambiguity for the agent.

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

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

Even though schema coverage is 100%, the description adds substantial meaning to every parameter. It explains the action enum default, the relationship between url and artifactId, the two-call approvalId flow, the status filter's rationale, the limit's truncated flag, and projectPath's reconciliation behavior—far exceeding the schema's basic 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 a specific verb+resource: 'List and revoke the public preview links this token has shared,' and immediately distinguishes this tool from the sibling extension_preview_web by noting these are the links it hands out. It further clarifies the two main actions (list and revoke), making the tool's purpose unmistakable.

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 explains when to use list vs revoke, when approvalId is needed, and when projectPath is useful. It also names the authentication requirement (extension_auth or EXTENSION_DEV_TOKEN) and the behavior without a token, providing clear usage context without needing to consult siblings.

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?

Details that there is no hot module replacement, no control channel, and that extension_eval etc. cannot attach. Discloses limitations without requiring 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, front-loads the key action, then covers limitations and usage advice efficiently.

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?

No output schema, but description covers purpose, usage, and limitations. Could mention return type, but not critical for a launch 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 92%, so baseline 3. Description adds context for build parameter but does not add much beyond schema for others.

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 it runs the production build in a browser, building, serving, and launching. It distinguishes from extension_dev by specifying this is for production checks.

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

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

Explicitly says when to use this tool vs extension_dev: 'Use extension_dev while writing code, and this to check what actually ships'. Also gives guidance on build:false for serving existing dist.

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?

Since no annotations are provided, the description bears full responsibility for behavioral disclosure. It details multiple side effects: terminating server/browser, removing live-preview carrier, covering build:false sessions, and the behavior of the 'all' parameter (stopping all sessions across projects, working after MCP restart). This is highly transparent.

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 primary action. Every sentence provides essential information: what the tool does, its coverage, and when to call it. No redundant or extraneous 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?

The description covers the tool's effects and usage context comprehensively. However, it does not mention the return value or error scenarios, which could be inferred from the tool's action but are not explicitly stated. Given the tool's simplicity (no output schema, no required parameters), this is a minor gap.

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

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

Schema coverage is 100%, with each parameter having a detailed description in the schema. The tool description does not add additional meaning beyond what the schema provides, so it meets the baseline but does not exceed it.

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

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

The description clearly states the action: stopping a session started by extension_dev or extension_start, terminating the server and browser, and removing the live-preview carrier. It also explicitly distinguishes from sibling tools like extension_start and extension_dev by focusing on the cleanup step.

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 clear usage guidance: 'Call it when you are done verifying, so sessions do not accumulate.' This tells the agent when to use the tool. It does not explicitly list exclusions or alternatives, but the context is sufficient 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?

No annotations are provided, so the description carries the full burden. It discloses read/write behavior and the single-key constraint, but omits error handling, permission requirements, and return value behavior for 'get' actions.

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 states the core purpose, and the second adds crucial operational constraints.

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 8 parameters, no output schema, and no annotations, the description is adequate but incomplete. It lacks details on return values, error states, and the exact behavior of 'get' when a key 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 input schema already describes all 8 parameters (100% coverage). The description adds modest value by clarifying that only one key can be set per call, reinforcing the relationship between key and value.

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 explicitly states 'Read or write chrome.storage in a running extension,' providing a specific verb and resource. This clearly distinguishes the tool from siblings like extension_eval or extension_dom_snapshot.

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 prerequisite (session with allowControl:true via extension_dev) and a key constraint (one key per call, no bulk), but does not mention when to use this tool versus alternatives like extension_eval for arbitrary code execution.

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

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

No annotations are provided, so the description fully discloses key behaviors: it holds credentials, dispatches from CI, defaults to dry run, real submission is irreversible, credentials are never arguments, no local file upload, token expiry up to 7 days, and the importance of trusting per-store rows over preflight. This is thorough and goes beyond schema details.

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 moderately long but packed with essential information, front-loaded with the purpose and key distinction. It uses clear warnings and step hints. Slight verbosity in the approval flow could be trimmed, but each 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?

Given the tool's complexity (multi-store, auth, dry-run, approval flow), no output schema, and no annotations, the description provides complete guidance: it covers prerequisites, side effects, error-prone points (credential health), and directs to extension_release_status for follow-up. It is comprehensive for both dry-run and real submission.

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

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

Schema coverage is 100%, so baseline is 3. The description adds extra context for parameters like dryRun (irreversible), approvalId (two-step approval flow), and buildSha (needs completed build). This adds meaning beyond schema, earning a 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 it submits a built extension for store review via extension.dev, targeting specific stores (Chrome Web Store, etc.), and explicitly distinguishes from extension_publish. Verb and resource are specified, and it differentiates from the sibling tool extension_publish.

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 to use it ('only when the ask is explicitly a store submission'), when not to use it (not for pushing a build or making a shareable link), and names the alternative (extension_publish). It also clarifies the default dry run behavior and how to trigger a real submission.

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

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

No annotations provided, so burden is on description. It describes actions and parameter dependencies but does not explicitly state read-only behavior, auth requirements, or rate limits. Adequate but not exhaustive.

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 sentences, concise and well-structured. Front-loaded with action types and default. Could be slightly more organized but efficient.

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

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

Given 8 parameters, high schema coverage, no output schema, the description covers both actions, parameter usage, and special interpretations. Completeness is sufficient for agent use.

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 high (88%), and description adds meaning beyond schema: clarifies that framework is UI-only, explains slug patterns for TypeScript/JavaScript and shadcn, and how to reach AI templates via tags. Adds value.

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 browses the extension.dev template catalog with two actions (list and source). It distinguishes itself from sibling tools like extension_create or extension_build by focusing on catalog browsing, not creation or building.

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 explains when to use list vs source, how to filter via query/tags/slug/surface/framework, and provides clarifications on framework interpretation. Does not explicitly state when not to use, but the scope is well-defined.

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

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

With no annotations provided, the description fully discloses behavior: it is headless, derives colors from the manifest, classifies problems into three specific types (D1, D3, D4), and states that app-rendered and real-pixel legs require a browser and will come back as needsAttended. It honestly covers its limitations and what it can and cannot verify.

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 paragraph but front-loaded with the main purpose. It uses specific jargon and provides many details, which are valuable for a complex tool. While it could be slightly more concise, every sentence adds necessary information, and it avoids redundancy.

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

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

Given the tool's complexity and no output schema, the description provides good context: what verification entails, problem classification, and limitations. It hints at output format (needsAttended for unresolved legs), but more explicit output structure would improve completeness. Overall, it covers the tool's functionality adequately.

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 baseline is 3. The description does not add parameter-specific details beyond what the schema already provides (e.g., 'Pass this or manifestPath' is already in the schema). No additional semantics or usage hints are given for the parameters.

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

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

The description clearly states the verb+resource: 'Verify a Chrome theme manifest before it ships.' It provides specific details about what the tool does (derives colors, classifies problems) and explicitly states it only verifies and never mutates, distinguishing it from sibling tools like extension_manifest_validate which may validate but not with this theme-specific color resolution.

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 before shipping and clarifies that the tool only verifies without authoring or mutating, so it should not be used for modifications. It also indicates that for browser-rendered aspects, the tool will return needsAttended, guiding the agent to use other harnesses for those parts. However, it does not explicitly mention alternative sibling tools.

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

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

With no annotations, the description fully discloses behavioral traits: polling mechanism, trustworthiness of guestLoaded, handling of noBrowser sessions, timeout behavior (call again), and port matching. This is comprehensive and honest.

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 detailed but well-structured, starting with the core purpose and then elaborating on signals, edge cases, and return values. Could be slightly more concise, but every sentence adds meaningful information.

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

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

Given the lack of an output schema, the description fully explains the return fields (compiled, browserAttached, guestLoaded, budgetMs, elapsedMs) and covers edge cases (noBrowser, timeout retry). It is complete for a polling 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%, and the description adds value by explaining defaults for browser, deprecation of timeout, and the clamping and retry behavior of timeoutMs. This supplements the schema effectively.

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: waiting for a dev or start session to be ready by polling a contract. It provides specific signals (compiled, browserAttached, guestLoaded) and distinguishes itself from sibling tools like extension_dev and extension_start by focusing on readiness polling.

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 when to use the tool (after starting a session) and provides guidance on interpreting results and handling timeouts. It does not explicitly mention alternatives, but the context of waiting after a dev/start command is clear.

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