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

Beyond the readOnly/non-destructive annotations, the description discloses substantial behavioral traits: duplicate class definitions are rejected, errors carry diagnostic codes, coverage is limited to supplied files, no JVM/JADX is needed, ambiguous overloads fail, inheritance and reflective accesses are not resolved, one-shot indexes are temporary, and graph boundaries/unresolved dynamic sites are explicit. It also clarifies that java never silently falls back and smali always disassembles the exact method.

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

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

The description is appropriately scoped for a 26-parameter, 24-operation tool, but it is a semicolon-heavy wall of text with no headings or operation-level structure. The source_format behavior is repeated in two places ("Explicit source_format=java..." and "source_format=auto... source_format=java..."), which wastes space.

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 nuanced operations (method/field/type refs, string refs, call graph, indexes, source formats) reasonably well, and the output schema handles return values. However, for a tool exposing 24 operations, many operations (info, list_classes, get_class_source, list_methods, search_classes, get_class_outline, get_class_hierarchy, get_string_constants, search_method_bodies, disassemble_method, get_class_source_metadata) receive no description at all, leaving the agent to infer their behavior from names alone.

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?

With 100% schema description coverage, the baseline is 3. The description adds some cross-parameter meaning (find_field_refs requires field_descriptor; type_match requires type_relation=operand; search_members accepts only kind=method/field), but most of these constraints are already stated in the schema descriptions, so the added value over structured fields is marginal.

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

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

The opening sentence states a specific verb and resource: "Analyze 1-64 standard DEX files with source hashes and per-DEX provenance." It is clear this is a static DEX analysis tool with many operations, but it does not differentiate itself from siblings such as asc_list_classes, asc_get_class_source, or asc_find_refs, which overlap with its operation list.

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 parameter-level guidance ("Use a full method_descriptor...", "Explicit source_format=java alone selects...") but never states when to use this tool instead of the dedicated sibling tools. The only scope exclusion is "this tool does not unpack applications," which concerns APK tools, not the overlapping DEX siblings.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds that the tool reports size, hash, manifest presence and top-level DEX entries, but says nothing about cost, truncation of DEX listings, or behavior when the APK is malformed.

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 front-loaded sentence with an explicit verb and an enumerated output list; nothing redundant and nothing buried.

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 and annotations cover safety, so the description does not need to explain return values. However, for a tool sitting in a dense cluster of APK/DEX inspection siblings, the absence of any routing guidance leaves the agent to guess which entry point to call.

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 apk_path and include_sha256 are already documented in the schema. The description's mention of SHA-256 loosely signals that hashing is part of the output and therefore toggleable, but adds no syntax or default details beyond the schema. 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?

Specific verb (Inspect) plus resource (APK) and an enumerated set of outputs: size, SHA-256, manifest presence, top-level DEX entries. That is enough to know it is a lightweight overview tool, but it never distinguishes itself from siblings like asc_manifest_summary, asc_list_apk_entries, or asc_analyze_dex, which cover overlapping ground.

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 versus the many overlapping siblings (asc_manifest_summary, asc_list_apk_entries, asc_analyze_dex) nor any exclusions or prerequisites. The word 'top-level' hints at a shallow scan, but the agent must infer that.

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=false and destructiveHint=false; the description adds real lifecycle semantics beyond that, namely that in-flight queries are allowed to finish before stored files are deleted. It stops short of stating idempotency or behavior when session_id is invalid or already closed.

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 clause pair with the action first and the completion guarantee second; no padding and nothing to trim.

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

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

With an output schema present, return values need not be explained, and the single param is covered by the schema. The remaining gap is error/edge-case behavior for an invalid or already-closed session, which slightly limits completeness.

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

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

Schema coverage is 100% and the single parameter is fully documented as an immutable session ID returned by an open tool. The description adds nothing further about the parameter, 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 ('Close a DEX session') and the scope is unambiguous. An agent can distinguish it from asc_open_dex_session and asc_query_dex_session without opening any schema.

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 session lifecycle rather than stated: nothing explicitly says when to close versus when to leave a session open, nor whether closing is required before opening another. The sibling set makes the intent inferable but no alternatives or exclusions are named.

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

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

Adds real context beyond the annotations: the no-Java/no-instruction-index basis and the hard caps of 1M identities and 64 MiB of cumulative declaration records. However, annotations declare readOnlyHint=false for what reads like a pure comparison over already-open immutable sessions, and the description never explains any side effect or session-state requirement, leaving that inconsistency unaddressed.

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?

Front-loads the purpose in the first sentence and follows with scope-limiting caveats. Three short sentences with little waste, though the caveats could be tighter and the bound sentence sits apart from the usage warning it belongs with.

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?

Output schema exists, all parameters are described, and annotations cover safety. The description supplies the resource bounds and the semantic limitation of identity-only diffs, so an agent has nearly everything needed; only the readOnlyHint=false discrepancy and the lack of a named alternative are 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 description coverage is 100% and each parameter (kind, change, limit, offset, session IDs) is documented inline, so the schema carries the load. The description mentions only the comparison subject and hash fields, adding no semantics for filtering, paging, or sort order beyond what the schema states.

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: compare class/member identities, with full descriptors and old/new source hashes across two sessions. This distinguishes it from query/analyze siblings, though it never explicitly contrasts itself with asc_analyze_dex or asc_query_dex_session.

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 clear operating context: it uses native DEX declarations without Java or an instruction index, and warns that unchanged identities say nothing about changed bodies, access flags or annotations. That implies when it is insufficient, but no alternative tool is named for the cases it cannot cover.

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, non-destructive, closed-world), and the description adds genuine behavioral context beyond them: results are non-transitive ('direct declarations only') and the rust_asc backend has 'unverified coverage'. Pagination/offset behavior and server-side caps are left to 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 with no filler, and the core capability is front-loaded. The phrasing is telegraphic and slightly awkward ('extends/impl use an exact class in value'), which costs a point but not readability.

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

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

With an output schema present and full parameter documentation, the description only needs to convey the cross-kind behavioral differences, which it does. Minor gaps remain around graph-traversal constraints and result shape, but both are covered by schema fields.

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 all nine parameters are already documented, establishing a baseline of 3. The description reinforces the `value` semantics for extends/impl and the kind restrictions on rust_asc, but largely restates what the schema already says rather than adding new constraints or formats.

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 ('Find') and two concrete resources: cross-DEX references, and direct subclasses/interface implementors. The kind semantics (extends/impl vs. member references) make it distinguishable from a plain class lister, though no sibling tool is named 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?

Gives useful selection rules within the tool — extends/impl take an exact class in `value` and return direct declarations only, and rust_asc is limited to string/type/method/field. It never says when to choose this over asc_list_classes or asc_get_class_source, so cross-tool routing 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=true, destructiveHint=false, and closed-world scope, so the safety profile is covered. The description adds useful context that results are paginated and bounded, but says nothing about decompilation cost, failure modes for an unknown class, or backend trade-offs that the schema hints at.

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 zero filler; the core action and the paged return are both delivered up front.

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 a full output schema, return-value documentation is unnecessary, and the description covers scope and pagination adequately. It could go further on error behavior for missing classes and on the backend choice, but nothing essential to a correct call 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%, so all six parameters are documented in the schema itself, establishing a baseline of 3. The phrase "bounded page of source lines" reinforces the limit/offset semantics but adds no syntax or constraint detail 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?

States a specific verb+resource pair ("decompile one class") and the return shape ("bounded page of source lines"). The singular framing implicitly distinguishes it from asc_list_classes, but no sibling is named 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?

Usage is only implied: an agent can infer this is the tool for pulling the source of a specific class rather than enumerating classes. There is no explicit when-to-use/when-not or pointer to alternatives like asc_find_refs or asc_list_classes, and no mention of what to do if the class is not found.

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

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

The annotations already declare this is a safe read-only operation, and the description adds that results are a bounded page of decoded XML lines. It does not add much about paging behavior, backend tradeoffs, or failure modes beyond what the schema and annotations already provide.

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

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

The description is a single front-loaded sentence with no wasted wording. It communicates the core operation and result shape immediately.

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 annotations covering safety, an output schema, and full parameter documentation, the description is largely complete for calling the tool. Its main gap is the lack of explicit routing guidance against manifest-summary siblings.

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 all four parameters are already documented in the input schema. The description mentions bounded paging, which relates to limit/offset, but adds no syntax or selection guidance 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 states a specific verb and resource: decode AndroidManifest.xml and return XML lines. It is clear enough to distinguish from a summary-style tool, though it does not explicitly name asc_manifest_summary as the alternative.

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 what the tool returns but gives no explicit guidance on when to use it instead of siblings such as asc_manifest_summary or asc_read_apk_entry. Any usage context is only implied by the output format.

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/destructive=false, so safety is covered; the description goes further with real limitations: nested APK splits are inventory-only and not reconstructed, first-level JAR class names only, AAB protobuf XML is not decoded, and manifest diagnostics are separate from inventory status. These are non-obvious scope boundaries an agent could not get from the schema, though the phrasing is terse and omits any note on result ordering/paging 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?

It is short, but it reads as a stack of decontextualized caveat fragments ("First-level JAR class names are included.") with no lead sentence establishing the primary behavior. Facts are present but not front-loaded by importance, so the agent must assemble the mental model itself.

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 needn't be spelled out, and the caveats cover many edge cases. However, for a 9-parameter tool the description never states the core output (per-artifact capability inventory) or how inventory and summary outputs relate, leaving a gap in the agent's ability to predict results before calling.

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

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

Schema coverage is 100% and the parameter descriptions are already detailed (module semantics, limit/offset paging, compare_to), so the baseline is 3. The description reinforces module selection and adds that include_summary still describes the input artifact when compare_to is set, but most statements (AAB base/exact/list/*) simply restate the schema.

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

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

The opening line states a verb and rough resource ("Inspect container capabilities"), and the artifact_path schema clarifies the container types. But it never plainly says what the tool returns (a capability/entry inventory per artifact) and never distinguishes it from close siblings like asc_apk_info, asc_list_apk_entries, or asc_list_classes, so an agent must infer the split.

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?

"before selecting a DEX analysis workflow" implies a positioning step, and "compare_to compares JVM identities; DEX declarations use session diff" gives one routing rule toward asc_diff_dex_sessions. There is no explicit when-to-use/when-not guidance against the other artifact-inspection siblings, leaving the main selection decision unresolved.

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

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

Goes well beyond the readOnly/destructive annotations by disclosing data-trust caveats: CRC values are declarations not verified, standalone DEX entries lack code validation and ZIP CRC metadata, and native rows are an archive inventory rather than ELF analysis. It also explains that SHA-256 binds each page to the input for stable pagination.

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?

Purpose is front-loaded and every sentence carries useful caveat or pagination information. Some sentences are telegraphic fragments ('Archive CRCs are declarations.') that could be marginally clearer, but there is no wasted 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?

With full schema coverage, an output schema, and explicit safety annotations, the description fills the remaining gaps: no extraction, stable pagination, and caveats about CRC and native-row interpretation. An agent has enough context to call it correctly and interpret the results.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add meaning to kind, prefix, apk_path, or the paging parameters beyond what the schema already documents; 'Follow next_offset' refers to an output field rather than clarifying inputs.

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: 'List archive contents or a standalone DEX file'. The phrase 'without extracting files' contrasts with read/extract behaviour, but no sibling tool is named, so the differentiation is implicit rather than explicit.

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

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

Provides pagination guidance ('Follow next_offset for more') and notes SHA-256 binding across pages, but never states when to choose this tool over alternatives such as asc_read_apk_entry, asc_apk_info, or asc_inspect_artifact. Usage is implied, not prescribed.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that: no mention of pagination behavior, result caps, backend tradeoffs, or the fact that a fresh APK read may occur; it merely restates the filter capability.

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 no filler, which is well sized for a simple enumeration tool. It is efficient but borders on under-specified rather than maximally informative.

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

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

With an output schema present and full schema coverage, the description needn't explain return values. However, for a six-parameter listing tool on an APK analysis surface it omits how prefix matching interacts with package versus class names and how this list relates to the sibling source/ref tools.

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

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

Schema coverage is 100%, so all six parameters including prefix, backend, limit and offset are documented in the schema with semantics like case-sensitivity and server caps. The description only echoes that prefix filtering exists and adds no format or syntax detail, making the baseline 3 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 verb and resource ('List class descriptors') plus the optional filter scope, so an agent knows exactly what comes back. It does not differentiate itself from siblings like asc_get_class_source or asc_find_refs, which likely operate on the same class universe.

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 no when-to-use context, no exclusions, and never names an alternative. An agent cannot tell from this text whether to enumerate classes here versus resolving source via asc_get_class_source or refs via asc_find_refs.

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

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

Beyond the readOnly/non-destructive annotations, it discloses real interpretive limits: exported defaults and resource values stay unresolved, and permission inheritance is 'static triage, not a runtime accessibility or vulnerability test'. That tells the agent exactly how much confidence to place in results, which no annotation conveys.

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 capability statement is front-loaded and each following clause carries a distinct caveat, so no sentence is filler. Phrasing is terse to the point of fragmentation, but nothing 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?

An output schema exists, so return values need not be explained; the description instead spends its budget on scope and epistemics, which is what's missing at this complexity. Combined with full parameter documentation, an agent has enough to call it and interpret results 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% and limit/offset/apk_path are each documented in the schema, including server capping and allowed roots. The description adds nothing about parameter behavior beyond the schema, 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?

Uses a specific verb (Read) plus enumerated resources (components, filters, metadata, permission inheritance) so the agent knows the output shape. It implicitly distinguishes itself from a raw-dump sibling via 'Raw declarations are preserved separately', but never names asc_get_manifest, so the differentiation stays inferential.

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: 'Raw declarations are preserved separately' and 'need separate review' hint at when this tool stops and another begins, but no sibling is named and no explicit when-to-use condition is given. The agent must infer that asc_get_manifest covers the raw case.

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 disclose that this is not read-only, not destructive, and closed-world; the description adds useful context that it creates an immutable reusable session with hashes. It also discloses that duplicate classes are rejected and that some inputs stay inventory-only. It does not mention permission requirements or other operational constraints beyond the schema's byte budget.

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 short, front-loaded with the core action, and each additional sentence adds useful scope or follow-up information. There is no redundant restatement of the tool name or schema fields.

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 annotations, 100% schema coverage, and an output schema, the description provides enough context to invoke the tool correctly. It covers supported inputs, limitations, duplicate handling, and how to use the resulting session ID.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful context for artifact_path and module by explaining supported artifact forms, selected AAB modules, and inventory-only cases. It does not add much beyond the schema for max_uncompressed_bytes, but the schema already documents that 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 states a specific verb and resource: it snapshots selected direct DEX into an immutable reusable session with container hashes. It also scopes supported artifact types and limitations. It does not explicitly distinguish this from the sibling asc_open_dex_session, so it falls short of full sibling differentiation.

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

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

It clearly indicates supported contexts: direct DEX at archive paths, AAR classes.jar DEX, and selected AAB modules, while noting that pure JVM classes and nested split APKs remain inventory-only. It also says to query and close the resulting ID with existing DEX session tools. It does not explicitly name when to prefer asc_open_dex_session instead.

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

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

Annotations only cover the safety profile (non-read-only, non-destructive, closed-world), and the description adds real behavioral facts beyond them: the session is a validated snapshot, not a resident engine, it is hash-bound and immutable, idle sessions expire, capacity eviction is possible, and invalidation requires a new session. These are exactly the lifecycle facts an agent needs to avoid stale-handle failures.

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 action and result, followed by the reuse model and invalidations. No filler; each sentence carries a distinct fact.

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

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

With an output schema present, the description needn't explain return values, and it covers the parts an agent would otherwise get wrong (expiry, eviction, invalidation). A small gap is that it never points to the related lifecycle siblings asc_query_dex_session / asc_close_dex_session, leaving the follow-up path implicit.

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

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

Schema coverage is 100% and the single dex_paths parameter is already documented (ordered, max 64, server-bounded byte total). The description adds only implicit meaning, that ordering matters because the session is hash-bound; it contributes no format or precedence detail 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?

Specific verb plus resource plus result: 'Validate and snapshot DEX inputs once; return an immutable hash-bound session.' The DEX-inputs scope cleanly distinguishes it from the artifact-oriented sibling asc_open_artifact_session, and the returned handle (a session) is named.

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

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

'Source file changes require opening a new session' gives an explicit trigger condition for calling this tool, and the first sentence implies call-once-then-reuse. What's missing is an explicit alternative (e.g. asc_open_artifact_session for non-DEX artifacts) or a pointer that this is a prerequisite for asc_query_dex_session.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered structurally. The description adds only the categories of configuration reported, which overlaps what the output schema would carry; it discloses nothing extra about cost, failure modes, or latency.

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 tersely constructed sentence with no filler, and the scope enumeration is front-loaded. It is efficient, though the single sentence is dense with comma-separated nouns rather than structured clearly.

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 described, and the tool is a trivial zero-parameter read. What remains missing is only the framing that this is a health/connectivity check, which is a small but real gap for a tool named ping.

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 takes zero parameters, so there are no semantics to explain; baseline 4 applies. The description's mention of pagination configuration is the only parameter-adjacent hint and is harmless.

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?

"Report" is a weak verb, and the description never says this is a ping/connectivity-health check, which is what the name implies. It does enumerate the config domains returned (server, engine, path-scope, pagination), giving partial specificity, but an agent must infer that the tool is a liveness/config probe rather than a data-fetch.

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

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

There is no statement about when to call this versus the many session/analysis siblings (asc_open_dex_session, asc_apk_info, etc.). No prerequisites, no mention that it is a safe first call to validate connectivity.

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

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

Annotations declare readOnlyHint=false on a tool named 'query', and the description explains why: build_xref_index 'persists an atomic static index for this session's lifetime' and an optional durable cache restores indexes across restarts. It also discloses failure modes and limits beyond the schema — truncated pages stopping 'at the byte budget before limit', ambiguity failing rather than guessing an overload, and unresolved_sites/truncation_reasons to inspect.

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

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

The purpose is front-loaded in sentence one, but the remainder is an unstructured wall of one-clause statements hopping between operations with no headings or grouping. Given 23 operations some length is warranted, yet several lines (e.g., the instruction/catch and array-matching note) read as spec fragments rather than selection 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?

An output schema exists, so return shapes need not be explained. However, for a dispatcher with 23 enum values, many operations (info, list_classes, get_class_source, list_methods, search_classes, get_class_outline, get_class_hierarchy, search_method_bodies, disassemble_method, get_class_source_metadata) are never described anywhere except the bare enum list, so the description is only partially complete for the tool's actual surface.

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

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

Schema coverage is 100%, so the baseline is 3. The description does add some meaning beyond the schema — grouped format making 'limit counts caller groups' while 'total/offset/returned_sites count sites', and source_format=auto never falling back to JADX — but most of the 28 parameters get no mention, and the added detail is selective rather than compensatory.

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

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

The opening sentence names a specific verb and resource ('Query an immutable DEX session in a supervised worker, with original provenance') and the body enumerates many of the 23 operations it dispatches. It stops short of differentiating this multi-op tool from overlapping siblings such as asc_list_classes, asc_get_class_source, and asc_find_refs, so an agent cannot tell from the text alone which entry point to pick.

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 substantial operation-level guidance ('find_field_refs requires field_descriptor', 'Or supply exact class_name and method_name... Ambiguous names fail', 'search_strings scans DEX string-pool values ... not instruction use sites'), which is genuinely useful. But the tool-selection question — when to use this dispatcher versus the dedicated sibling tools that expose the same operations — is never addressed, leaving the most important routing decision 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 this a safe read, and the description goes well beyond them: it discloses that XML-decode and truncation are reported as separate statuses, that partial raw reads do not verify CRC, that standalone DEX bytes (including 041 headers) are returned unmodified, and that no extraction occurs. These are exactly the operational caveats an agent needs before trusting the returned bytes.

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

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

The core action is front-loaded in the opening sentence and every following sentence carries a distinct caveat with no filler. Some fragments are elliptical ('separate statuses' separate from what?), which slightly blunts the density, but overall the length is well matched to the tool's complexity.

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

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

With annotations, a full output schema, and 100% parameter coverage, the description only needs to supply behavioral caveats, and it does so thoroughly (CRC, truncation, no extraction, DEX header preservation). The one gap is not pointing at asc_list_apk_entries as the source of valid entry_path values.

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 apk_path, entry_path, max_bytes, byte_offset, and decode_xml are already documented. The description adds only indirect context — that truncation and decoding are distinct statuses and that partial reads skip CRC — without explaining encoding selection or how byte_offset interacts with decoded versus raw content. Baseline 3 applies.

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

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

The first sentence names a specific verb and resource — read bounded entry bytes from an APK/DEX archive — and adds the return encodings (UTF-8 or base64) plus provenance. It is clearly distinct from asc_list_apk_entries by being a read rather than an inventory operation, though it never names that sibling 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?

Usage is implied through negative scoping: no resource-ID resolution, no filesystem extraction, code validation is separate. There is no positive routing such as 'use asc_list_apk_entries first to obtain entry_path', even though the schema's 'from inventory' phrasing gestures at it. An agent can infer scope but must work 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?

Goes well beyond the thin annotations by disclosing the default redaction posture, the include_values opt-in, hard caps (20 matches per pattern/string, 2M strings), the explicit 64K UTF-16 skip, and the byte budget. It also flags the key caveat that findings are unvalidated candidates, which an agent needs to avoid over-reporting.

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?

Front-loads the purpose in the first sentence, then layers caveats and caps. Dense but every sentence carries information; the mid-sentence line breaks are cosmetic noise rather than padding.

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 6 parameters, an output schema present, and full schema coverage, the description supplies the behavioral context the schema cannot (redaction, caps, exclusions). It omits only that an immutable DEX/artifact session must already be open, which the session_id field description covers instead.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning on top: it explains the redaction default tied to include_values, the capped match volume that governs limit/offset semantics, and the skip threshold relevant to max_scan_bytes. It doesn't elaborate on pattern-family ordering used by offset.

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 verb and resource ("Find redacted candidate secrets in DEX strings") plus the distinguishing output ("exact pool indices and fingerprints"). No sibling tool scans for secrets, so an agent can route here unambiguously, and the mention of native DEX string pools separates it from the source/ref-oriented 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?

Clearly delimits scope by exclusion: assets, native code, runtime values and arbitrary encodings are "outside this scan," and it warns that candidate validity and instruction use sites "remain untested," implying a follow-up tool is needed. It does not name the sibling to use for those follow-ups (e.g. asc_get_class_source / asc_find_refs), so routing beyond this tool 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?

Beyond the readOnly/destructive annotations, the description discloses substantive behavioral traits: presence is independent of cryptographic validity, digests and v4 sidecars stay unverified, malformed containers yield explicit diagnostics, and v1 certificates are a raw PKCS7 bag rather than resolved signer identities. These caveats directly shape how an agent should interpret results and are not derivable from the annotations or schema.

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

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

The capability statement is front-loaded in the first sentence, followed by a compact list of limitations, with no filler. The caveat block is dense and slightly fragmented across line breaks, but every clause carries distinct informational 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?

An output schema exists, so return-value details are not required, and the description covers scope, limitations, and malformed-input behavior. It could go slightly further on error conditions for unreadable paths, but for a one-parameter read-only inventory tool it is essentially 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 single apk_path parameter is fully documented in the schema (100% coverage, including the allowed-roots constraint). The description adds no additional semantics about the path argument, so the schema does the work and 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 first sentence names a specific verb and resource: inventory v1/v2/v3 containers, certificate fingerprints, and v3.1 block presence. That is clearly distinguishable from siblings like asc_apk_info and asc_inspect_artifact, which cover broader artifact metadata, even though no sibling is named 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 second paragraph effectively scopes the tool by stating what it does NOT do — no digest, signature, trust, or rotation-lineage verification — which implicitly routes verification work elsewhere. It stops short of naming an alternative tool or an explicit 'use this when' condition, so it is clear context rather than full routing guidance.

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