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

With no annotations, the description carries the full burden. It discloses the browser-opening behavior, user confirmation requirement, requested scopes, and the continuation flow with redirectUrl. This gives the agent a clear picture of the tool's side effects and interaction requirements.

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

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

The description is concise yet comprehensive, using clear sentences that each convey a necessary piece of information: purpose, warning, exclusion, scopes, and usage steps. No fluff.

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

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

Given the interactive auth flow and the presence of an output schema, the description sufficiently covers operational steps, prerequisites (user warning), and response handling. The absence of return value details is acceptable since an output schema exists.

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 both parameters (authMethod enum and redirectUrl). The description adds value by explaining the exact usage flow: call with no arguments to start, and pass redirectUrl when nextAction is paste-redirect-url. This enriches the schema's static definitions.

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

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

The description explicitly states the tool signs in to Google for the CEP MCP server, identifies the specific scope set, and distinguishes it from the Google Workspace MCP auth tool. This clearly differentiates it from sibling tools like cep_auth_status and cep_auth_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?

Provides explicit when-to-use guidance, including the mandatory user warning and confirmation, the restriction to only the CEP MCP server, and the specific two-step flow for handling nextAction. This goes beyond simple context and gives actionable instructions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently states the consequence of clearing cached OAuth credentials (forcing re-authentication on the next call). While it doesn't mention reversibility or impact on other servers, it clarifies the scope, which is sufficient for a simple clear operation.

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

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

Two sentences, front-loaded with the primary function, followed by usage guidance. No wasted words—both sentences earn their 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?

This is a simple zero-parameter tool with an output schema. The description covers purpose, scope, and behavioral effect. With an output schema present, return values need no explanation. The description is 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 tool has 0 parameters, and the schema coverage is 100% (i.e., no parameters to document). Per rubric, 0 params earns a baseline of 4. The description adds no parameter info because none exists.

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

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

The description states a specific verb ('Clears') and resource ('cached OAuth credentials for the Chrome Enterprise Premium (CEP) MCP server'), making the tool's function unmistakable. It also distinguishes from siblings by explicitly limiting scope to the CEP MCP server and referencing a separate clear tool for Google Workspace.

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 explicit when-to-use guidance: 'Use this tool only for the CEP MCP server; the Google Workspace MCP server has its own separate clear tool.' This clearly directs users to the correct context and points to an alternative when applicable.

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

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

With no annotations, the description carries the full burden. It discloses that the tool reports on 'cached scopes' and 'OAuth credential status,' implying a read-only inspection of existing state. It does not explicitly state that it makes no changes or that it requires prior authentication, but the verb 'reports' strongly suggests a non-mutating operation.

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 core function, the second provides usage boundaries. There is no redundant information or filler, making it concise and 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?

This is a zero-parameter status tool with an output schema, so the description need not explain return values. It fully covers what the tool reports, the intended server scope, and how it relates to other status tools. Given the simplicity of the tool, the description 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?

The tool has zero parameters, and the input schema is empty. The baseline for 0 parameters is 4, and the description correctly avoids discussing non-existent parameters. No parameter-level meaning is needed 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 it reports OAuth credential status and cached scopes for the CEP MCP server. The verb 'Reports' plus the specific resource and server scope fully define the tool's purpose. It also distinguishes this status tool from the one for the Google Workspace MCP server, differentiating it from potential 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 explicitly provides usage guidance: 'Use this tool only for the CEP MCP server; the Google Workspace MCP server has its own separate status tool.' This gives clear when-to-use and when-not-to-use instructions, including an alternative tool.

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

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

No annotations are provided, so the description carries the burden. The verb 'verifies' implies a read-only operation, which adds some transparency, but it does not explicitly state that no changes are made, require authentication, or disclose any side effects. It does add context about the 'actual protection state,' which is a mild extra, but lacks explicit behavioral 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 two short sentences with no redundant filler. The first sentence states the core purpose, and the second provides a practical context. Every word contributes meaning, making it highly concise and well-structured.

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

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

Given the tool's simplicity (one optional parameter) and the presence of an output schema, the description is largely complete. It covers the purpose, scope, and a use case. The only minor gap is that it does not clarify whether the operation is organization-wide or per-user, but this is already inferred from 'for an organization.' With no annotations, a small additional note about read-only behavior would improve completeness, but it remains 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?

The schema description coverage is 100%, with the property customerId already described as 'The Chrome customer ID (e.g. C012345).' The tool description adds no further meaning about the parameter, so the baseline of 3 is appropriate since the schema fully documents the parameter.

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

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

The description clearly states both the action ('Verifies') and the resource ('Chrome Enterprise Premium (CEP) license assignments for an organization'). It also distinguishes itself from the sibling tool check_user_cep_license by specifying organization-level scope, making it unambiguous what the tool does.

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

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

The description offers a use case ('useful for checking the actual protection state of users') but does not explicitly indicate when to choose this tool over alternatives like check_user_cep_license or list_org_units. No exclusions or alternative names are provided, so guidance is only 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 verb 'checks' conveys a read-only, non-destructive operation, and the description adds context about the extension's importance. It does not detail permissions or exact return behavior, but an output schema is present, and the operation inherently has no side effects, so the description adequately covers behavioral transparency given the absence of 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 concise sentences that state the purpose first and then provide actionable context. 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 low complexity, full schema coverage, presence of an output schema, and clear usage guidance, the description is complete. It explains the tool's role in the broader workflow and links to the remediation tool, making it sufficient for an agent to invoke 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 coverage is 100% (both orgUnitId and customerId have descriptions), so the baseline of 3 applies. The description mentions 'given Organizational Unit' but adds no parameter-level details 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?

Clearly states the specific action (checks force-installation of SEB extension) and the target resource (given Organizational Unit). The mention of 'force-installed' and integration with sibling tools distinguishes it from similar checks like check_ev_extension_status.

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 when to use this tool as a prerequisite check and provides a direct alternative next step: 'use install_seb_extension to fix it.' It also explains why the extension matters (required for advanced features), giving context for the check.

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 conveys the read-only nature implicitly via 'checks', but does not disclose return shape, error behavior, permissions, or edge cases (e.g., user not found). The presence of an output schema mitigates some ambiguity, but behavioral details beyond the core action are missing.

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

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

Two concise sentences with the core action front-loaded in the first sentence. The second sentence provides practical usage context without fluff. Every word earns its place.

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

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

For a simple one-parameter tool with an output schema, the description covers the essential 'what' and 'when to use'. It does not explicitly differentiate from all sibling tools (e.g., check_cep_subscription), but the wording 'specific user' makes the distinction clear enough. Slight gap in noting exclusions or prerequisites, but overall sufficient for this complexity level.

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

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

Input schema coverage is 100%, with the parameter 'userId' described as 'The user's primary email address or unique ID.' The description adds no new meaning beyond saying 'by email or unique ID', which duplicates the schema. Baseline 3 applies because the schema already handles parameter semantics fully.

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 ('Checks if a specific user has a Chrome Enterprise Premium (CEP) license assigned') with a specific verb and resource. It distinguishes from sibling tools like check_cep_subscription by specifying 'specific user' and 'individual user', making the scope 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 gives clear context on when to use this tool: 'verify if an individual user (by email or unique ID) is licensed for CEP features.' It implies but does not explicitly state alternatives or exclusions (e.g., not for subscription-level checks), so it lacks full 'when-not' guidance but provides a solid contextual cue.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'reported by managed devices,' indicating a specific data source, and implies an aggregation (count). However, it does not detail behavior such as handling of missing data, time ranges, or permission requirements. This is adequate but thin for a tool with no 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 concise sentences with no filler. The first sentence states the core action, and the second gives a clear use case. 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?

Given the simplicity of the tool (two optional parameters) and the existence of an output schema, the description is nearly complete. It explains the scope ('across your organization or a specific Organizational Unit'), which adds context beyond the schema. A brief mention of parameter defaults or the absence of the orgUnitId behavior would make it fully complete, but current coverage is sufficient for a simple count 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 provides descriptions for both parameters (orgUnitId and customerId) with 100% coverage. The description adds a small contextual hint by referencing 'a specific Organizational Unit' which aligns with orgUnitId, but it does not meaningfully enhance what the schema already states. 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's function: 'Counts Chrome browser versions reported by managed devices.' This is a specific verb and resource, and the second sentence adds the purpose 'auditing and reporting on the distribution of browser versions,' which distinguishes it from sibling tools that handle logs or policies.

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 a usage context: 'Use this for auditing and reporting on the distribution of browser versions across your organization or a specific Organizational Unit.' It implies when to use the tool but does not mention alternatives or exclusion cases, so it lacks the 'when not to use' component.

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 description fully carries the burden. Discloses critical behavioral constraints: forbidden combos, display name prefix, trigger-specific parameter support, and need for reference document. Exceeds expectations.

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

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

Tool description is 3 concise sentences, front-loaded with purpose and usage constraints. Parameter descriptions in schema are verbose but necessary for documenting constraints. 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?

Covers safety, constraints, prerequisites. Output schema exists (though not shown) so return info not needed. Could mention idempotency or error handling, but overall complete for a creation 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%, but description adds significant value: cross-parameter compatibility (e.g., dataMasking only with URL_NAVIGATION and WARN/AUDIT), blockScreenshot constraints, customMessage limitations. These are not in 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?

Clearly states it creates a Chrome DLP rule for an OU. Verb 'creates' and resource 'Chrome DLP rule' are specific. Distinguishes from sibling tools like get_dlp_rule or list_dlp_rules, but could explicitly differentiate from create_default_dlp_rules.

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 explicit safety restrictions (no ACTIVE+BLOCK) and alternatives ('use INACTIVE BLOCK or ACTIVE WARN/AUDIT'). Advises to consult get_document for technical reference. Lacks direct comparison to other create 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 must carry the burden of behavioral disclosure. It does list the three rules and the Gemini exclusion, which is useful, but it does not mention permission requirements, idempotency, whether existing rules are affected, or potential conflict/error situations. For a mutating bulk operation, this is a notable gap.

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

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

The description is front-loaded with the main action, followed by a concise numbered list of rules. Each line earns its place, though the list could be slightly more compact without losing 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?

The output schema covers return values, so that omission is acceptable. However, the description lacks guidance on when to choose this tool over create_chrome_dlp_rule and does not address prerequisites or side effects, leaving the agent without enough context to confidently select 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?

Schema coverage is 100%, with both orgUnitId and customerId already described. The description only reiterates that the rules are for a specific OU, adding no new parameter-level semantics beyond what the schema 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 the verb ('Creates') and the resource ('Starter Pack' of default Chrome DLP rules), scoped to a specific Organizational Unit. It also enumerates the exact rules, which distinguishes it from the sibling create_chrome_dlp_rule that likely handles a single custom rule.

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

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

The phrase 'Starter Pack' implies a quick-setup use case, but the description does not explicitly tell when to use this tool versus alternatives like create_chrome_dlp_rule or list_dlp_rules. No exclusions or conditions are given, leaving usage to be inferred.

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 that the tool creates a detector and that the resulting resource name is used in DLP rules, adding lifecycle context. However, it does not mention side effects, validation rules, permissions, or error behavior, leaving notable gaps for a creation tool.

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

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

The description is two sentences, front-loaded with the core purpose, then adds essential workflow context. Every sentence earns its place; there is 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?

The tool has a moderate complexity (4 params, output schema exists). The description explains the tool's role in the DLP rule-building workflow and the need to use the returned resource name in create_chrome_dlp_rule. It does not detail the output structure, but the presence of an output schema reduces that need. Overall, it is sufficiently complete for an agent to decide and invoke.

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% parameter description coverage, so the description does not need to explain parameters. The description does not add extra parameter-level semantics beyond what the schema already provides, aligning with the baseline score of 3.

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

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

The description states the specific action: 'Creates a new DLP regular expression detector.' This clearly identifies the resource (regex detector) and distinguishes it from sibling tools like create_url_list_detector and create_word_list_detector by the 'regular expression' modifier.

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

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

The description provides clear context on how to use the created detector: 'After creating a detector, you must reference its resource name in a create_chrome_dlp_rule condition.' It implies this tool is the starting point for building DLP rules with regex patterns, though it does not explicitly name alternative detectors or state 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?

No annotations are provided, so the description bears the full burden of behavioral disclosure. It only states that a detector is created and that its resource name must be used later. It does not mention permissions, side effects, reversibility, or response details, which is a significant gap for a mutation tool.

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

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

The description is two sentences: the first states the tool's purpose, and the second provides essential usage context. It is front-loaded and contains no fluff or repetition of schema 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?

An output schema exists, so return values are covered. The description explains the next step (referencing the resource name in a rule), which is helpful. However, for a creation tool with no annotations, it lacks details about prerequisites, permissions, or how this detector type differs from siblings, leaving the context incomplete.

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

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

The input schema has 100% coverage of parameter descriptions, but the tool description adds no parameter-specific meaning. The fact that it is a 'URL list' detector is already captured in the schema's 'urls' parameter description. No additional detail such as URL format or validation rules is provided.

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 a clear, specific verb and resource: 'Creates a new DLP URL list detector.' It distinguishes itself from sibling tools like create_regex_detector and create_word_list_detector by specifying the URL list type, and it explains the broader role of detectors as building blocks for DLP rules.

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 that the created detector must be referenced in a create_chrome_dlp_rule condition, but it does not explicitly state when to choose this tool over alternative detector types (regex, word list). The usage guidance is general to all detectors and does not differentiate the URL list variant.

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 behavioral disclosure burden. It adds context about the detector's role and how the result must be used, which is useful. However, it does not mention any side effects, permissions, idempotency, or failure modes that would be expected for a creation tool.

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

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

The description is only two sentences. The first sentence states the core action, and the second provides actionable integration guidance. Every sentence earns its place, with no filler or repetition of schema details.

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

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

Given the tool's moderate complexity—four parameters, full schema coverage, and an output schema—the description adequately explains the tool's purpose and how to use the result. It could be improved by explicitly contrasting with regex/URL detectors or noting any prerequisites, but it is sufficiently complete for common usage.

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 covers all four parameters with descriptions, including constraints like maxItems for words and maxLength for displayName. The description adds only a usage example ('matches_detector') and reinforces the required nature of displayName and words, but does not provide new parameter-level meaning.

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

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

The description clearly states 'Creates a new DLP word list detector.' It uses a specific verb and resource, and the 'word list' qualifier distinguishes it from sibling tools like create_regex_detector and create_url_list_detector.

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 detectors are building blocks for DLP rules and explicitly instructs the user to reference the detector's resource name in a create_chrome_dlp_rule condition. This provides clear integration context, but it does not explicitly state when to prefer this over regex or URL detectors.

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

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

With no annotations, the description carries the full burden. It discloses default behavior (summary without large arrays), pagination details, drill-down capabilities, and auto-resolution of customerId. It does not explicitly state read-only nature, but the health check context implies it. Overall, transparent and sufficient.

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. Three short paragraphs front-load the purpose, then detail the default behavior, drill-down options, and pagination. Every sentence earns its place with no 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 moderate complexity (duel mode, pagination, auto-resolve), 100% schema coverage, and the presence of an output schema, the description provides all necessary information. It covers usage, parameters, and output expectations without significant gaps.

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 meaningful context beyond schema: for 'section', it explains what each value returns (e.g., DLP rules with action types, browser version counts); for 'limit' and 'offset', it clarifies pagination usage; for 'customerId', it confirms auto-resolution. This 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 runs a health check of the Chrome Enterprise Premium environment, distinguishing it from sibling tools that focus on specific sub-resources (e.g., list_dlp_rules, list_org_units). It explains the dual behavior (summary vs. detail) and explicitly lists drill-down sections.

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 advises using the tool for a high-level summary by default, and to drill into specific sections via the 'section' parameter. It implies alternatives exist (the dedicated list tools) but does not explicitly say when not to use this tool. The agent guidance to present findings to the user is 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?

With no annotations provided, the description carries the full burden. It discloses that the tool modifies configuration (activation) and that it only changes unconfigured connectors, which is valuable behavioral insight. It does not mention auth, rate limits, or output structure, but the output schema covers returns, so the description is reasonably transparent for a configuration tool.

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

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

The description is efficiently structured: three sentences, front-loaded with the action and examples, then usage guidance and an explicit alternative. Every sentence adds value and there is no redundancy or fluff.

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

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

Given the output schema exists and the input schema fully documents parameters, the description covers the essential behavioral aspects: what it does, when to use it, and how it differs from the read-only alternative. It is complete for a tool of this complexity, with no critical information gaps.

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 three parameters with 100% coverage, so the baseline is 3. The description adds general context about connector examples but does not provide additional per-parameter semantics beyond what the schema offers. It meets the baseline without adding extra parameter detail.

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 specific verbs ('enables and configures') and clearly identifies the resource ('Chrome Enterprise connectors') with concrete examples (Print, Paste, File Upload/Download). It distinguishes itself from the sibling get_connector_policy by explicitly noting the activating action versus checking status.

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 ('Use this tool to ACTIVATE security protections') and provides a clear alternative for read-only checks ('To check current status without modifying, use get_connector_policy'). It also clarifies the tool's idempotent behavior ('ONLY apply changes to connectors that are not already configured'), giving strong 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 carries the full burden of behavioral disclosure. It implies a read-only operation (retrieves) but does not mention any specific behavioral traits like authentication requirements, rate limits, or whether a customer ID is mandatory. It adds some context by listing event types but leaves security/prerequisite details undisclosed.

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

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

The description is two sentences long, with the first sentence front-loading the core purpose and the second providing usage context. Every word earns its place with no redundancy or fluff.

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

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

Given the tool has an output schema (so return values are already documented) and all parameters have descriptions, the description sufficiently covers purpose and usage context. It might benefit from mentioning that a customer ID may be needed (given the sibling get_customer_id tool), but overall it is complete enough for an AI agent to select and use it effectively.

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 fully documents all six parameters. The description does not add parameter-specific meaning beyond the schema, though it provides general context about the type of data involved. Baseline of 3 is appropriate given the schema's high 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's purpose with a specific verb ('Retrieves') and resource ('audit logs of Chrome browser activity'), and provides concrete examples of events (login events, policy violations, extension installs). This distinguishes it from sibling tools like DLP rule management or detector creation.

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: 'Use this for security investigations, auditing user actions, and to help tune DLP rules.' It gives clear use cases, though it does not explicitly name alternative tools or exclusion criteria.

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

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

With no annotations provided, the description carries the full burden. It implies a read-only operation via 'Retrieves' but does not explicitly state it is side-effect-free. However, it adds valuable context about the limitations of related tools, which helps set expectations. A slightly more explicit disclosure of non-mutating behavior would elevate it further.

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

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

The description is three sentences, front-loaded with the primary action. Each sentence contributes value: the first states what it does, the second gives the use case, and the third provides important limitations. No word is wasted.

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

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

Given that an output schema exists, the description does not need to explain return values. It provides a clear purpose, usage guidance, and a comparison with related tools. It is complete for a retrieval tool, and the note about manual updates in Admin Console rounds out the operational context.

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

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

Schema description coverage is 100%, so parameters are already well-documented. The description adds context by mentioning example features like 'printing sensitive data' and 'real-time URL checks', which helps interpret the enum values. This goes beyond the schema without being redundant.

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 specific verb 'Retrieves' and clearly identifies the resource as 'the current configuration for a specific Chrome Enterprise connector or all connectors'. It also distinguishes itself from the sibling 'enable_chrome_enterprise_connectors' tool by focusing on retrieval/audit rather than activation.

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: 'Use this to AUDIT or VERIFY settings'. It also provides clear guidance on alternatives: the enable tool can only activate unconfigured connectors, and there is no tool to modify configured connectors. This is explicit 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 the burden of disclosing behavior. It transparently indicates a read-only retrieval operation ('Retrieves') and the authenticated-account context. It doesn't detail error scenarios or authorization requirements, but for a parameterless read tool, this is sufficient.

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

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

The description is two sentences, front-loaded with the core action, and every word adds value. It avoids redundancy and clearly links the output to downstream use.

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?

This is a simple, parameterless tool with an output schema, so the description doesn't need to explain return values. It fully covers what the tool does, the context (authenticated account), and why it matters (dependency for other tools), making it complete.

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

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

The tool has zero parameters, and the schema is empty. The baseline for no parameters is 4, and the description appropriately adds semantic context about the ID's format and purpose without needing to explain any input fields.

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

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

The description clearly states the tool's purpose with a specific verb ('Retrieves') and resource ('unique Google customer ID for the authenticated account'). It also mentions the ID's common 'C' prefix, making it distinct from sibling tools that perform management actions.

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

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

The description provides clear usage context by noting the ID is 'required as a parameter for many other Chrome management tools,' implying this tool should be called first to obtain the ID. It does not explicitly state when not to use it, but the simple bootstrap nature makes that unnecessary.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explicitly warns that the agent cannot modify or delete rules despite the Admin Console link permitting these actions. It also notes the response includes a direct link, which is a useful behavioral detail. However, it does not explicitly state whether the read operation has any side effects or permissions required, though 'retrieves details' implies a safe read.

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

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

Two concise sentences front-load the core purpose and add a relevant behavioral note. No wasted 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?

The tool is simple with one parameter and an output schema. The description covers the purpose, a key response feature (Admin Console link), and an important limitation. Given the existence of an output schema, no further explanation of return values is needed.

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 a clear description for the only parameter resourceName, including an example. The description adds little beyond the schema, merely restating 'by its resource name.' This meets the 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?

The description clearly states 'Retrieves details for a specific Chrome DLP rule by its resource name,' with a specific verb, resource, and scope. It distinguishes itself from sibling tools like list_dlp_rules (which lists rules) and create_chrome_dlp_rule (which creates rules).

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

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

The description implies usage when you need details for a known rule, indicated by 'by its resource name.' However, it does not explicitly mention alternatives or prerequisites, such as using list_dlp_rules to discover resource names, nor does it 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?

No annotations are provided, so the description carries the full burden. It does not disclose any behavioral traits such as idempotency, side effects, permissions required, rate limits, or error behaviors. The read-only nature is implied but not explicitly stated.

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

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

The description is extremely long due to the full knowledge index table. While the table is informative, it significantly reduces conciseness. The first paragraph is efficiently front-loaded, but the bulk of the description is a large table that could be a separate resource.

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 comprehensive: it explains the input format, includes a detailed index of available documents (with topics and keywords), and references cross-links. Since an output schema exists, return value explanation is not needed. This provides the agent with all necessary context 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?

The schema already provides a description of the 'filename' parameter. The description adds value by explaining that entries can be numeric articleIds from cross-links, which is not in the schema's description. Schema coverage is 100%, so the description enhances 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 action ('Retrieves the full text') and the resource ('knowledge base documents'). It explains the two input forms (single string or array) and distinguishes from sibling tools like get_dlp_rule by focusing exclusively on knowledge base content.

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 guidance on when to use the array form ('load related articles in a single call') and includes a comprehensive knowledge index table that helps the agent decide which documents to fetch. However, it does not explicitly state when not to use the tool or mention 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?

No annotations are provided, so the description carries the full burden. It discloses that the operation is a force-install at the OU level, but does not mention permission requirements, reversibility, potential disruption to existing extension settings, or failure behavior. The rationale about data masking is purpose context, not behavioral 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 a clear action verb and a rationale. No fluff; the second sentence earns its place by conveying the business need for the force-install.

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 purpose and a use-case trigger but omits safety/behavioral details that are important for a mutation tool with no annotations. The existing output schema may account for return values, but prerequisites and side effects remain unexplained.

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 (100% coverage), so the baseline is 3. The description does not add extra meaning beyond the schema's orgUnitId and customerId 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 starts with 'Force-installs the Secure Enterprise Browser (SEB) extension for a given Organizational Unit,' which is a specific verb+resource+scope. It clearly differentiates from sibling tools like install_ev_extension by naming the SEB extension.

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 second sentence provides a clear context cue: the SEB extension is REQUIRED for advanced Chrome Enterprise Premium features like data masking. However, it does not explicitly state when not to use this tool or name alternatives such as check_seb_extension_status or install_ev_extension.

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 that the tool lists profiles and provides details like OS, platform, and email, which implies a read-only operation. However, it does not mention pagination, required permissions, or any limitations, which would be valuable context for an agent.

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

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

The description is two sentences long, front-loaded with the action, and every sentence adds value. The first sentence states what it does, and the second clarifies the nature of the profiles and the data provided. 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 list tool with a single parameter and an output schema, the description is fairly complete. It explains what the profiles are and the type of information returned. It could mention pagination or other context, but given the existence of the output schema, the missing details are not critical.

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 provides 100% coverage of the single parameter (customerId) with an example. The description does not add any additional meaning about the parameter, which aligns with the baseline score of 3 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?

The description clearly states the tool 'Lists Chrome browser profiles for the customer,' with a specific verb and resource. It distinguishes itself from sibling tools like list_org_units by focusing on browser profiles, and adds context about what these profiles are and what details they provide.

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

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

Usage is implied by the description ('Lists... profiles for the customer') but not explicitly stated with alternatives or exclusions. The tool's purpose is clear enough that an agent would infer when to use it, but there is no direct guidance on when not to use it or how it compares to other list 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. It states that the tool 'lists all' detectors, implying a read-only, non-filtering operation, and explains the practical purpose of the returned data. It lacks explicit mention of no side effects, but the verb 'lists' and context are clear for a simple list operation.

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

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

The description is two sentences, front-loaded with the core action and resource, then adds practical context about usage. 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 that the tool has no parameters and an output schema exists (so return structure is elsewhere), the description fully covers what the tool does, what it returns conceptually (policyName), and why to use it. It is 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?

This tool has zero parameters, and the schema coverage is 100% (an empty object). The description adds no parameter-specific details, but the baseline for zero-param tools is 4, and there is nothing more to add.

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

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

The description uses a specific verb ('Lists all') and clearly identifies the resource ('custom Chrome DLP detectors'), including the three types (URL lists, word lists, regular expressions). This distinguishes it from sibling tools like list_dlp_rules or create_regex_detector.

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 use case: finding the 'policyName' of a detector to include in a rule. It does not explicitly mention when to avoid using it or name alternative tools, but the context is sufficiently implied given the sibling list.

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

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

With no annotations provided, the description carries the full burden. It implies a read-only operation via the verb 'Lists' and adds context on DLP rules, but it does not mention permission requirements, pagination, or any potential side effects. This is adequate but not thorough.

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

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

The description is two sentences long, front-loading the core purpose and adding useful context about DLP rules in the second sentence. There is no fluff 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 tool's simplicity (no parameters) and the existence of an output schema, the description sufficiently explains the tool's purpose and scope. The added context about what DLP rules protect makes it complete for an AI agent.

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

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

The tool has zero parameters and the schema coverage is 100%. The description correctly omits parameter details since there are none to explain, and the baseline for zero-parameter 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 uses the specific verb 'Lists' with the resource 'Chrome DLP rules' and scopes it to 'currently configured in the organization.' This clearly distinguishes it from siblings like get_dlp_rule (singular) and create_chrome_dlp_rule.

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

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

The description makes clear that the tool lists all DLP rules, providing context about what DLP rules do. However, it doesn't explicitly state when to use this tool over get_dlp_rule or mention any exclusions, so it stops short of full alternative 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?

No annotations are present, so the description carries the full burden. The verb 'Lists' implies a read-only operation, and the description mentions output content, but it does not explicitly state it is non-destructive, require specific permissions, or explain behavior when customerId is omitted. Adequate for a simple list tool but not detailed.

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

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

Two concise, front-loaded sentences convey purpose, usage context, and output value. No superfluous words 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?

An output schema exists, so the return values are externally defined. The description provides essential context (what the OUs look like, why they are needed) and is appropriate for the tool's simplicity. The only minor gap is not clarifying the optional nature of customerId, but that is a small 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 input schema already fully describes customerId with format example. The tool description does not add additional meaning beyond the schema, so the baseline of 3 applies.

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

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

The description starts with 'Lists the Organizational Units (OUs)' - a specific verb and resource. It also explains the key outcome (provides orgUnitId, human-readable path, unique ID), distinguishing it from sibling list tools like list_customer_profiles.

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 'Use this tool to find the orgUnitId required by most other Chrome management and policy tools', providing clear context for when to use it. It does not mention alternatives or when not to use, but 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?

With no annotations, the description carries the full burden. It states the actions (check/enable/disable) but does not disclose side effects, reversibility, permission requirements, or that enabling may create connectors for target OUs. This leaves the agent unaware of the tool's operational impact.

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

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

Two sentences, front-loaded with the purpose and direct usage guidance. No redundant or filler 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?

Given the output schema exists and schema coverage is complete, the description adequately covers the essential purpose and usage. Minor gap: it does not mention the targetOus scoping nuance, but the schema provides that detail.

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 parameters are already well-documented. The description adds minimal semantic value beyond the schema, only implying customer-wide operation that aligns with the customerId parameter.

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

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

The description clearly states the tool manages the enablement status of Chrome Security Insights, with specific actions check, enable, or disable. This verb+resource combination and customer-wide scope distinguish it from sibling tools focused on other Chrome features like CEP or extensions.

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 'Use this to check, enable, or disable the security insights feature customer-wide,' providing clear usage context. It does not mention exclusions or alternative tools, but the context is clear enough for selection among siblings.

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