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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so safety is fully covered externally. The description adds nothing behavioral — no indication of content depth, session-caching behavior, or what happens when an unknown topic is passed — so it clears the (lower) annotated bar only barely.

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?

One compact sentence plus a topic list, with the version and breaking-change scope front-loaded. It is efficient, though the trailing topic enumeration is partly redundant with the schema and could have carried routing guidance instead.

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

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

For a read-only, zero-required-parameter reference tool with no output schema, the description is minimally sufficient but leaves gaps: it doesn't say what a call returns (migration steps, checklist items, doc links) or how large the payload is, which matters for a topic-driven knowledge tool.

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

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

Schema description coverage is 100%, and the topic list in the description merely duplicates the enum-style list already in the topic parameter's schema description. With the schema doing all the work, the baseline 3 is appropriate; the description adds no syntax or selection guidance beyond 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 names the subject matter (Android 17 / targetSdk 37 breaking changes) and enumerates its coverage areas, so an agent can infer it is a version-specific compliance reference. However, it never states the action or output form — no verb such as 'returns' or 'explains' — and differentiation from android_api36_compliance rests entirely on the version number, not on any stated scope difference.

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

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

No when-to-use guidance at all: nothing says whether to consult this before upgrading targetSdk, nor how it relates to android_api36_compliance, android_api_level_check, or android_official_search. An agent must guess which compliance/reference sibling is appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds domain substance (orientation/resizability locks ignored on ≥600dp, predictive back, 16 KB pages) but says nothing about how content is returned per topic or that 'refresh' resends session content beyond the schema's own wording.

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?

It is compact and front-loads the compliance requirement, but the trailing 'Topics: compliance, layouts, checklist, predictive back, page size' duplicates the schema's topic parameter nearly verbatim, so that sentence does not earn its place.

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

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

With no output schema and no annotations gap, the description should clarify what the tool returns (static guidance text per topic? a checklist?) and how refresh interacts with it. It omits that, leaving an agent unsure of the response shape for a two-parameter tool.

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

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

Schema description coverage is 100%, so both parameters are fully documented in the schema, establishing the baseline of 3. The description restates the same topic list already present in the schema enum, adding no new semantics (e.g., what happens with no topic, or default behavior).

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 names a specific resource and scope (Android 16 / targetSdk 36 compliance), and the name dates it against the sibling android_api17_compliance. The action is implicit rather than stated as a verb — it reads as a topic-based lookup rather than a 'checker' — but an agent can tell what it retrieves.

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 useful context ('required by Play for new apps and updates since Aug 31, 2026') that implies when the tool matters, but it never states when to use this versus overlapping siblings like android_play_policy_advisor, android_large_screen_guide, or android_api_level_check. Usage must 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds useful context by naming the returned content (features, minSdk warnings) and the bulk 'all' mode, but does not expand on output format or scope of the feature data.

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

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

Two short sentences, front-loaded with the core action and followed by a concrete special-case instruction. No filler or redundancy.

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

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

For a single-parameter, read-only lookup with no output schema, the description conveys enough: what gets mapped and what is returned. It stops short of describing the shape or volume of the feature/warning results, which is the only remaining 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 description coverage is 100% for the single required parameter, so the schema already documents accepted formats. The description only echoes the 'all' option and clarifies that it yields the full table, a marginal add beyond the enum-less 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?

States a specific verb (map) and resources (API level, version name, codename) plus the outputs (features, minSdk warnings), so the tool's job is unambiguous. It does not, however, distinguish itself from closely related siblings such as android_api36_compliance or android_api17_compliance, which also concern API levels.

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?

'Pass "all" for the full table' gives one concrete usage cue, and the mapping framing implies a reference-lookup use case. There is no explicit when-to-use/when-not guidance or pointer to the compliance siblings that could compete for the same request.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false, and destructiveHint=false, so the safety profile is fully covered. The description itself adds no behavioral context beyond that — no note on session state, caching, or return behavior. The one behavioral nuance (that content is normally not resent) lives only in the refresh parameter description, not here.

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

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

A single, front-loaded sentence that opens with the core purpose and then lists scope. It is efficient, though the trailing keyword dump ('Google's Android CLI and skills') reads more like tag-stuffing than structured guidance.

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 reference-lookup tool with rich annotations, no output schema, and fully documented parameters, the description is adequate: an agent knows what topics it covers and that it is a safe, idempotent read. Nothing critical is missing, though routing context versus sibling reference tools is thin.

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

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

Schema coverage is 100%, so both parameters are already documented in the schema. The description's topic list loosely overlaps the topic parameter examples but adds no syntax, format, or matching semantics beyond what the schema provides — baseline 3.

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

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

The description names a specific resource ('Build and release reference') and enumerates concrete content areas (R8/ProGuard, version catalogs, kapt→KSP, signing, AAB/Play publishing, Baseline Profiles). This distinguishes it from most siblings, though it does not explicitly separate itself from overlap candidates like android_official_search or gradle_dependency_checker.

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 only implied: the topic list suggests when the reference is relevant (build/release questions), but there is no explicit when-to-use guidance and no named alternatives. The agent must infer routing from the topic keywords alone.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds real value beyond them: the 34-rule coverage areas, PASS/WARN/FAIL outcome shape, line-level fixes with doc links, structuredContent, and that comments are ignored. It omits any limits on code size or rate behavior, keeping it below 5.

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

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

Five short sentences, each carrying distinct information: when to call, what is checked, what is returned, an edge case, and remediation. The call timing is front-loaded 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?

An output schema exists so return values need not be spelled out, yet the description still summarizes the PASS/WARN/FAIL contract. Call timing, scope, language coverage, and remediation loop are all present, leaving nothing an agent needs 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?

Schema description coverage is 100%, so the schema already documents code, minSdk, targetSdk and language (including its enum). The description repeats the language set but adds no syntax or format detail about minSdk/targetSdk, so the 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?

Specific verb (validate/check) applied to a clearly bounded resource (Kotlin, XML and Gradle code blocks) with an explicit scope of 34 rules. It is easily distinguished from siblings such as gradle_dependency_checker or android_component_status, which serve different purposes.

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

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

Gives an explicit trigger ('call after generating every Android code block, before returning it') and a follow-up loop ('on FAIL, fix and re-run'). It does not name alternative validation tools (e.g. gradle_dependency_checker) or state when not to use it, so it falls short of a 5.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the bar is lower. The description adds genuinely useful behavior: it discloses the return contents (status, replacement, doc link) and, importantly, that unknown names are 'reported as unconfirmed, never guessed' — a non-obvious reliability guarantee beyond the annotations.

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

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

Two tightly written sentences, front-loaded with the core question, followed by the call condition and return/edge-case behavior. Every clause 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?

With no output schema, the description correctly takes on the burden of describing what comes back (status, replacement, doc link) and how ambiguous inputs behave. For a single-input validation tool, nothing an agent needs to invoke it correctly 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?

Schema description coverage is 100% and the single parameter is documented with concrete examples ('AsyncTask', 'android.widget.ProgressDialog', 'LiveData'). The description adds no additional parameter semantics, so the baseline 3 is appropriate.

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

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

The description states a specific verb and resource — validating whether an Android/Kotlin class or library is stable, deprecated, or removed — and does so as a crisp question an agent can match against a need. It is clearly distinct from search/general-knowledge siblings like android_official_search because it returns a lifecycle verdict rather than documents.

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 explicit when-to-use guidance: 'Call before using any android.*, androidx.* or kotlin.* API.' That is a clear triggering condition. It does not name an alternative sibling or state exclusions, so it falls short of a 5.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the bar is lower. The description adds genuinely useful behavior beyond the structured fields: it discloses that the tool performs doc-matching and constructs an Issue Tracker search link, which is real output behavior given no output schema exists.

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 tight sentences with zero filler. The purpose and outputs come first, followed by the one actionable input instruction, so nothing needs to be re-read.

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

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

For a read-only parse tool with full schema coverage and no output schema, the description is nearly sufficient: it explains what is returned and what input to supply. It stops short of covering limits (the 4000-char cap is only in the schema) or what happens on an unparseable stacktrace, but the core need is met.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema, including the refresh flag the description never mentions. The description's restatement of the stacktrace content ('include the exception class and at frames') duplicates the schema text rather than adding format or syntax guidance, so baseline 3 applies.

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

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

States a specific verb and resource ('Parse an Android/Kotlin stacktrace') and enumerates the outputs (error class, matching official docs, Issue Tracker link), so the agent knows exactly what the tool produces. It does not, however, reference or distinguish itself from the large set of sibling guide/search tools, so differentiation is left implicit.

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 only implied: 'Paste the exception line and "at" frames' tells the agent the input format but not the situations that select this tool over alternatives like android_official_search. There are no exclusions or named alternatives, so the agent must infer when to reach for it.

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

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

Annotations already declare a safe, read-only, idempotent, non-open-world lookup, so the safety profile is covered. The description adds useful domain context (identity-check program, enforcement window, exempted categories), but says nothing about what a call returns (content chunks vs. summary), caching, or how 'refresh' behaves beyond the schema line.

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?

One tight, front-loaded sentence plus a short topic list; no filler and the identifying information comes first. The parenthetical dates and regions are dense but relevant and 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?

There is no output schema, so the description carries the burden of explaining the return, and it does not (no format, granularity, or size indication). For a policy-information tool with all-optional parameters and full annotation coverage, this is adequate but leaves the agent guessing about the shape of the result.

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

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

Schema coverage is 100% and both parameters are documented there, so the baseline is 3. The description's topic list simply restates the schema's topic values and adds no extra meaning about semantics, defaults, or behavior when topic is omitted.

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 names a specific resource (the Android Developer Verification program) and enumerates the sub-topics it can answer ('who is affected, registration paths, enterprise exemptions'). An agent can tell it is a documentation/knowledge tool about a specific policy program. It stops short of naming a sibling it is distinct from, so it is not a 5.

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

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

Usage is only implied: the topic list hints at what this tool is good for, but there is no explicit when-to-use or when-not, and no routing against closely related siblings such as android_play_policy_advisor or android_official_search. The agent must infer the boundary itself.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds only the topical scope; it says nothing about how content is chunked or returned, and the session-dedup behavior is disclosed in the schema (refresh), not here.

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

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

A single compact passage with the core purpose front-loaded and the topic list trailing as supporting detail. The trailing list is mildly redundant with the schema but does not bloat the text.

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

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

For a read-only reference tool with no output schema and full schema coverage on both params, the description covers what the tool is and what it spans. Only the shape of the returned guidance is unspecified, a minor gap given the annotations carry the safety profile.

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 both parameters are fully documented in the schema, so the baseline is 3. The description merely repeats the topic list already present in the schema and adds no syntax, formatting, or default-value nuance for 'refresh'.

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 names a specific resource (Kotlin Multiplatform reference) and enumerates its scope: project setup, KMP libraries, Room KMP/Room 3, expect/actual. It implicitly distinguishes itself from generic siblings like kotlin_best_practices by scoping to KMP, but never names an alternative explicitly.

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 topic list implies when the tool is relevant, but there is no explicit 'use this when...' guidance, no exclusions, and no routing advice against siblings such as android_official_search or kotlin_best_practices. Usage must be inferred from the topic enumeration.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety and repeatability are covered structurally. The description adds the content scope but says nothing about return format, caching, or how 'refresh' changes session behavior — some value, but thin beyond the annotations.

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

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

A single front-loaded sentence listing scope in compact noun-phrase form — efficient with no filler. It is arguably a bare list rather than prose, but every element 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 read-only reference tool with no output schema, annotations carrying the safety profile, and full schema coverage, the description conveys enough scope to call it correctly. Only minor gaps remain (no sibling routing, no return-shape hint).

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

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

Schema description coverage is 100%, so both parameters are already documented, including the 'leave empty for index' behavior of topic. The description's topic list loosely echoes the topic parameter examples but adds no format or matching semantics beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description names a specific resource — an Android large-screen/tablet/foldable reference — and enumerates the concrete topics it covers (WindowSizeClass, NavigationSuiteScaffold, ListDetailPaneScaffold, hinge handling, continuity, Play checklist). An agent can tell it is a topical reference tool, though it does not explicitly distinguish itself from siblings like android_scalability_guide or android_official_search.

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 only implied: the agent infers it should query this for large-screen/adaptive-layout questions. There is no explicit when-to-use, when-not-to-use, or routing to a sibling (e.g. android_official_search for general Android docs), and the 'Leave empty for index' hint lives in the schema rather than guiding tool selection.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so safety is covered. The description adds genuine behavioral context beyond that: an ordering constraint (invoke before writing code) and a versioning rule (N3 is current, don't emit N2 code). It does not describe the shape of returned content, which keeps it short of a 5.

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

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

Three short clauses, front-loaded with the resource identity followed by the action constraint, then the topic index. No filler sentences and nothing that could be trimmed 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?

For a zero-required-parameter read tool with no output schema and full schema coverage, the description covers purpose, timing, and available topics adequately. It could note what the returned content looks like (e.g., reference docs vs. code samples), but nothing essential 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?

Schema description coverage is 100% and both parameters are documented there, so the baseline is 3. The description's topic list duplicates the schema's topic enumeration and adds no syntax or selection guidance beyond 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?

States a specific resource ('Navigation 3 reference') with an explicit version scoping cue ('current official library'), which cleanly distinguishes it from Navigation 2 material and from siblings like android_official_search. An agent immediately knows this returns N3 reference 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?

Gives an explicit trigger ('Call before any navigation code') and an explicit prohibition ('do not generate Navigation 2 NavController/NavHost for new projects'), which is stronger guidance than most sibling tools provide. Alternatives aren't named, but the when/when-not conditions are unambiguous.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered; the description goes beyond them by disclosing the dual data-source behaviour ('Google Developer Knowledge API when configured, else a verified page index') and the empty-result contract. It also describes return content (excerpts with source URLs), which matters because there is no output schema. No rate limits or latency expectations are given, but nothing contradicts the annotations.

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

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

Three short sentences, front-loaded with the imperative action, then the return contract, then the failure-mode guidance. No filler and nothing requiring rereading.

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 two-parameter read-only search with rich annotations, the description covers purpose, timing, return shape and empty-result handling, which is close to sufficient even without an output schema. It stops short of full completeness only by not positioning itself against the many topic-specific sibling guides.

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 both parameters are documented there (including the example queries for 'query' and the resend semantics for 'refresh'). The description adds no parameter-level detail beyond what the schema already carries, 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 states a specific verb and resource: it searches and returns official developer.android.com / kotlinlang.org excerpts with source URLs. It is clearly distinguishable from sibling reference tools (e.g. kotlin_best_practices, material3_expressive) because it is scoped as a general source-backed lookup rather than a curated guide, and it names its actual data sources.

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 triggering condition — 'Call first, before writing Android/Kotlin code' — plus an exclusion: if nothing matches, do not fall back to memory. What it does not do is say when to prefer the specialised sibling guides over this general search, so selection between this tool and the other ~20 Android tools is left partly to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered externally. The description adds only a small behavioral detail (AppFunctions is 'experimental'); it does not disclose return format, caching, or pagination behavior on top of the schema's refresh parameter.

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 compact sentences that front-load the subject matter and then the topic set, with no filler. The trailing 'Topics:' enumeration is slightly redundant with the schema but still helps scanning.

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

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

For a read-only, closed-world, zero-required-parameter guide tool with full schema coverage and no output schema, the description is sufficient to invoke it. It is incomplete on a key point: why an agent should pick this over android_official_search or the other topical guides.

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

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

Schema description coverage is 100%, so both parameters are documented in the schema, giving a baseline of 3. The description reinforces the topic options but also omits 'architecture', which the schema topic description lists, creating a minor mismatch that could steer topic selection.

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 names a specific subject area (on-device AI: AICore/Gemini Nano via ML Kit GenAI, ML Kit, repository pattern, AppFunctions) and enumerates the covered topics, so an agent knows what content it returns. It lacks an explicit verb ('get guide for') and does not differentiate itself from siblings like android_official_search or the other *_guide 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?

There is no statement of when to use this tool versus alternatives such as android_official_search or android_kmp_guide. The topic list implies coverage, but no condition, prerequisite, or routing guidance is given.

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

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

Annotations already declare readOnlyHint/idempotentHint true, so the agent knows this is a safe, repeatable lookup; the description correctly does not contradict that. It adds the useful fact that an empty query lists all permissions and that 'runtime pattern' is a magic query term. It still says nothing about the shape/volume of the returned data, which matters since there is no output schema.

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

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

Three tight sentences with the purpose front-loaded and the usage trigger immediately after; nothing is padded. The final clause largely duplicates what the parameter schema already says, a minor redundancy rather than bloat.

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

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

For a simple two-parameter reference lookup with a full read-only annotation set, the description covers purpose, trigger, and query modes adequately. The remaining gap is the absence of any hint about return contents/format, which is more notable because no output schema exists to cover it.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema, including the 'leave empty to list all' and 'runtime pattern' behaviors. The description restates those same facts rather than adding format, case-sensitivity, or validity guidance, so it earns the baseline 3 with no uplift.

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

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

States a specific resource (Android permission reference) and enumerates exactly what it returns: type, runtime-request need, Play restrictions, and request pattern. That is far more concrete than a generic 'get info' tool. However, it never distinguishes itself from the closely related sibling android_play_policy_advisor, which plausibly covers overlapping Play-restriction territory.

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?

Gives a clear trigger condition: 'Call before adding <uses-permission>.' That tells the agent exactly when to reach for it. It does not name alternatives or state when another sibling (e.g. android_play_policy_advisor) is the better pick, so it stops short of explicit when-not guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds that this is a reference/advice tool and that it should precede submission, but says nothing about what the advice contains or how the refresh flag changes session behavior beyond the schema field's own text.

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 resource and followed by the trigger condition. The topic list is somewhat long but each item maps to real coverage; nothing is padded.

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, zero-required-parameter, read-only reference tool with full schema coverage and complete annotations, the description supplies the needed purpose and timing. The only minor omission is any hint at output shape (e.g., checklist vs citations), which is not critical for an advisory tool.

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

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

Schema description coverage is 100%, so both the topic list and the refresh semantics are already documented in the schema. The description's topic enumeration largely restates the schema's topic examples without adding format or default-substitution guidance. 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?

States a specific resource (Play Store policy reference) and enumerates the concrete domains it covers: target API requirement, Restrict Minor Access, subscription transparency, permissions/Data Safety, large-screen quality. An agent can tell this apart from generic siblings like android_component_status, though it does not explicitly distinguish itself from android_permission_advisor or android_api36_compliance, which overlap on permissions and API level.

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 an explicit trigger: 'Call before Play submission or new monetization.' That is a clear when-to-use signal. It stops short of when-not to use it or naming the overlapping permission/API-compliance siblings as alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false, and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds nothing behavioral: it doesn't say whether content is cached, how 'refresh' affects session state beyond the schema note, or how large/responsive the responses are.

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?

One compact sentence, front-loaded with the highest-value keywords and no filler. It is appropriately sized for a lookup tool, though the fragmentary keyword-list style means it carries less information per token than a declarative sentence would.

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

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

With no output schema, the description should clarify what comes back (explanatory guidance, snippets, references) and how to scope a query; it only enumerates topics. For a zero-required-parameter retrieval tool this is minimally adequate but leaves the agent guessing about response shape and granularity.

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 topic list in the description does echo and expand the schema's example values ('Paging3', 'offline-first', 'cold start', 'modularization', 'recomposition'), giving the agent a rough taxonomy of valid topics, but adds no syntax, normalization, or fallback behavior 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 is a bare topic list ('Paging 3 + RemoteMediator, offline-first sync, HTTP caching, cold start, modularization, Compose recomposition performance') with no verb stating what the tool actually does — retrieve guidance, generate code, or explain trade-offs. It does usefully differentiate from siblings by domain coverage (scalability/performance vs. android_navigation3_guide or material3_expressive), but the agent must infer the operation from the name and title.

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

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

No when-to-use guidance at all: nothing says when this beats architecture_reference, kotlin_best_practices, or android_official_search for the same subject matter. The only usage cue is the schema-level note that omitting 'topic' returns an index, which is not restated or contextualized in the description.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the agent knows this is a safe, repeatable lookup with no side effects. The description adds the pre-test-writing trigger but says nothing about caching/deduplication behaviour, and the session-scoped 'refresh' semantics live only in the schema. Adequate against the annotation baseline, but not rich.

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

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

Two sentences: a front-loaded purpose statement followed by the invocation trigger. The parenthetical library names earn their space by signalling coverage depth, and there is no filler.

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

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

For a two-parameter, read-only lookup with no output schema, the description supplies the content domains and the call trigger, which is close to enough. The remaining gap is return shape and the purpose of `refresh` in cross-session reuse, but that is minor for a reference tool.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description goes beyond the schema's example values by naming topics the schema omits (ViewModel and Room tests, Compose UI tests, JUnit4/MockK/Turbine), which directly informs what strings are valid for `topic`. That is genuine added meaning for the primary 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 names a specific resource (a testing reference) and enumerates the exact domains it covers — unit tests, Compose UI tests, Espresso, ViewModel/Room, Hilt, test pyramid — so an agent knows precisely what knowledge it returns. It stops short of explicitly differentiating itself from near-neighbours such as kotlin_best_practices or android_code_validator, which is the only thing keeping it off a 5.

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

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

'Call before writing tests' is an explicit, actionable trigger condition, which is more than most reference tools offer. There are, however, no exclusions — nothing says when to reach for android_code_validator or kotlin_best_practices instead, so the routing guidance is one-sided.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds content-scope context (which topics exist, and that Wear-specific Compose APIs differ from phone ones), but says nothing about return volume, versioning, or caching behavior.

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

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

Two tight sentences, front-loaded with the resource and the key differentiation fact. The trailing topic list is slightly redundant with the schema enum, which keeps it from a 5.

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

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

For a read-only documentation lookup with no output schema, the description tells the agent what domain and subtopics are covered and that the guidance is Wear-specific, which is enough to call it correctly. Annotations carry the safety profile, so nothing critical is missing, though version applicability is unstated.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema. The description's 'Topics:' list merely restates the topic parameter's enum values and says nothing extra about 'refresh' or about what a given topic returns. Baseline 3 applies when the schema does the heavy lifting.

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

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

Names a specific resource (Wear OS reference) and pins down its scope with concrete API names (ScalingLazyColumn, SwipeDismissableNavHost, Wear Material 3) plus covered areas (Tiles, Health Services). It is clearly distinguishable from sibling guides like android_large_screen_guide or android_navigation3_guide by domain, though it never explicitly names them.

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

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

Usage is only implied — 'uses different Compose artifacts than phones' hints this is for Wear OS targets rather than phone UI, but there is no explicit when-to-use, when-not-to-use, or named alternative. The baseline for the topic argument is left to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds genuine context beyond that — that the content covers beta/RC releases (Compose for XR beta, ARCore RC) — which matters for an agent judging freshness, but it says nothing about content size or staleness.

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?

Compact and front-loaded, leading with scope before the topic enumeration. The topic list is duplicated between the first parenthetical and the trailing 'Topics:' clause, which is minor redundancy rather than bloat.

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?

A read-only, low-complexity reference tool with two fully documented parameters and no output schema, so return-value documentation is unnecessary. The description covers scope, topics and release-channel caveats adequately; only explicit sibling routing 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?

Schema description coverage is 100% and both parameters have inline descriptions, so the schema carries the load. The description restates the same topic list almost verbatim, adding no syntax or semantics beyond what the schema provides; baseline 3 applies.

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

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

It states a specific resource (Android XR / Jetpack XR reference) and enumerates the concrete artifacts covered (SpatialPanel, UserSubspace, Orbiter, ARCore for XR), which distinguishes it from the wear/large-screen guides. It is not a verb-led tool, but for a documentation-retrieval tool the scope statement is clear enough to select it.

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 domain: consult this when building XR experiences. There is no explicit when-to-use or when-not-to-use, and no routing to siblings such as android_large_screen_guide or android_component_status for overlapping questions.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description adds meaningful behavioral context the annotations do not: that the content is an official curated guide, that it should be fetched proactively before structural decisions, and that a 'list' sentinel enumerates topics. It omits that content is session-cached and re-sent only via the refresh flag, which lives only in the schema.

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

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

Three short sentences, front-loaded with the purpose, then the usage imperative, then the discovery sentinel. The parenthetical topic enumeration is long but arguably earns its place by defining the accepted vocabulary.

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

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

For a read-only reference lookup with no output schema, the agent knows what to pass and roughly what it gets back (a topic guide). It would be stronger with a sentence on return shape (e.g. markdown guide text vs. code samples) or how to chain results into further design work.

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% – both 'topic' and 'refresh' carry their own descriptions including the 'list' sentinel and session-cache semantics. The description largely restates the schema's topic examples, adding no syntax or format information beyond it, so the baseline 3 applies.

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

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

States a specific verb and resource: it retrieves an official Android architecture guide for a named topic, and it enumerates the valid topic space. It does not, however, distinguish itself from overlapping siblings such as android_navigation3_guide, android_testing_guide, or kotlin_best_practices, whose topical coverage intersects with the listed topics.

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?

"Call before proposing app structure" gives a clear triggering context for the agent, and "Pass 'list' for all topics" gives a concrete discovery path. There is no when-not guidance and no routing advice for the overlapping sibling guides, so it stops short of a 5.

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

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

Annotations already establish readOnly, idempotent, openWorld, and non-destructive behavior. The description adds useful output behavior, specifying stable version plus Gradle DSL/TOML snippets and BOM handling, though it does not describe error cases or refresh semantics beyond the schema.

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

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

Three compact sentences front-load the output, then input form, then when to call. No repetition or filler; every clause adds operational detail.

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

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

With no output schema, the description does the key work by naming the return content and Gradle formats. It leaves minor edge cases such as unknown library handling unstated, but it is sufficient for an agent to decide when and how to call it.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds meaningful syntax guidance: it accepts a short name or exact 'group:artifact'. The 'refresh' parameter is left to the schema, but its description there is adequate.

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

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

States exactly what it returns: current stable version and ready-to-paste Gradle for Android/Kotlin/Jetpack from Google Maven/Maven Central, including BOM handling. It also states accepted input forms, so an agent can distinguish it from general Android search/reference 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?

Provides a clear pre-call trigger: 'Call before adding or bumping any dependency.' It also clarifies accepted input shorthand, but does not state limitations such as unsupported repositories or whether it works for non-Android libraries.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuine value by naming the full topic catalog and the empty-topic listing behavior, which is behavioral context the annotations cannot convey. It stops short of describing return format or content freshness, which the 'refresh' flag hints at but never explains.

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

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

A single front-loaded sentence with the core capability first, followed by the topic inventory and the empty-topic rule. It is dense but every clause carries information; the only minor cost is that the topic list reads like a schema dump.

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

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

For a read-only, zero-required-parameter lookup tool with 100% schema coverage and annotations already covering safety, the description supplies enough to invoke it correctly. The remaining gap – what the returned content looks like and how the refresh flag behaves – is modest, and there is no output schema to carry that burden.

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

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

Schema description coverage is 100%: the 'topic' param already documents examples and the empty-to-list-all behavior, and 'refresh' documents re-sending session content. The description's topic list loosely mirrors the schema examples without adding syntax or matching rules (e.g., whether 'compose state' matches 'compose-state'), 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 states a specific resource (official Kotlin/Android code patterns with anti-patterns) and enumerates the retrievable topics, so an agent knows exactly what content this tool serves. It does not, however, explicitly differentiate itself from close siblings like architecture_reference or android_official_search, leaving overlap to inference.

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 one concrete usage rule ('Empty topic lists all'), which tells the agent how to use the topic parameter in list vs lookup mode. But there is no guidance on when to choose this over android_official_search, architecture_reference, or the various per-topic guide tools, so the routing decision is left implied.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world, so the safety profile is fully covered. The description adds a modest behavioral detail — an empty topic lists all topics — and implicitly frames the output as advisory reference content to consult pre-build. It does not disclose how content is returned, whether topic matching is exact, or what happens for an unknown topic; with no output schema, that remains a 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?

One sentence, front-loaded with the topic inventory that is genuinely the most useful information, followed by the usage cue. The keyword enumeration is dense but each term maps to a real capability, so little is wasted; it only loses a point for being a bare list rather than stating scope proportionally.

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 two-optional-parameter reference lookup with no output schema, the agent knows what topics exist, when to invoke it, and how to enumerate everything. The remaining gap is routing against overlapping siblings (component status, Wear OS guide) and any hint about result depth, neither of which is fatal for a read-only knowledge tool.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema with examples and the same 'empty to list all' note. The description repeats the empty-topic behavior and adds nothing about the refresh flag or accepted topic forms. Baseline 3 applies when the schema does the work.

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 names the resource (Material 3 Expressive reference) and enumerates the concrete topics it covers — MaterialExpressiveTheme, MotionScheme, ButtonGroup, FloatingToolbar, LoadingIndicator, MaterialShapes, typography, Wear, migration. That gives an agent a strong signal of scope. It is weaker on verb phrasing ("reference" rather than an explicit retrieve/lookup) and overlaps with siblings like android_wearos_guide on the 'Wear' topic, which it does not disambiguate.

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?

"Call before building Compose UI or theming" is explicit timing guidance that tells the agent when this tool belongs in a workflow. "Empty topic lists all" gives a discovery path. However, it offers no exclusions or named alternatives, and the sibling set contains overlapping guides (android_component_status, android_wearos_guide) that are never mentioned.

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