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

With no annotations, the description carries the burden and does disclose the two mutations: cache contents are discarded and counters are reset. It omits the consequences an agent would want — that subsequent source fetches will be slower while the cache repopulates, and whether the reset affects any other client or session. No output schema detail is needed here since one 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 short sentences, action first and usage condition second, with no padding. Every clause 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 no-argument, fully described-output tool this is close to sufficient: an agent knows what is cleared and when to invoke it. The remaining gap is purely the after-effects (rebuild cost, scope of the reset), which matters but is minor for such a simple tool.

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

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

Zero parameters, so there is nothing to disambiguate and the baseline applies. Nothing in the description conflicts with the empty 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: "Clear the decompilation source cache and reset counters" tells the agent exactly what state changes, and the decompilation framing separates it from the sibling get_cache_stats (read) without naming it. It stops short of explicitly contrasting with that sibling.

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?

"Use when switching APKs or to free memory" gives two concrete triggering conditions, which is more than most tools offer. There are no exclusions or warnings (e.g., don't call mid-debug-session), so it falls short of a full when/when-not treatment.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Get' implies a read operation, but the description does not state whether the debugger must be paused, whether frames are for the current/selected thread, or any other execution constraints.

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 words. It is appropriately sized for a simple zero-parameter tool.

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

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

Because an output schema exists, return values need not be explained. However, the description leaves important context ambiguous, particularly what 'current' means in terms of thread or debugger state, and gives no usage context for the surrounding debug toolset.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. Per the baseline for parameterless tools, a 4 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: 'Get current stack frames (call stack).' An agent can understand the basic operation without opening the schema. However, it does not distinguish this from sibling debug tools such as debug_get_threads or debug_get_variables.

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

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

There is no guidance on when to use this tool versus debug_get_threads, debug_get_variables, or other related debug tools. The description gives no preconditions, alternatives, or exclusions.

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

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

No annotations are provided, so the description carries the full burden. 'Get' implies a read-only, non-destructive operation, but there is no disclosure of blocking behavior, ordering, completeness/pagination, or the required debug session state. It is adequate for a simple getter but adds little behavioral context.

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

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

Single short sentence, front-loaded with the action and resource, with zero wasted words. Every word contributes to scope.

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-parameter read tool with an output schema covering return values, the description states what is returned and the process scope, which is nearly sufficient. It leaves minor gaps around debug-session prerequisites and how it relates to sibling debug 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?

The tool has zero parameters, so parameter semantics are not a concern and the baseline is 4. The description correctly does not invent parameters.

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

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

The description gives a specific verb (Get) and resource (all threads) with a clear scope (the debugged process). It is distinct from the neighboring stack-frame and variable debug tools, though it does not explicitly call out that distinction.

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

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

The phrase 'in the debugged process' implies the precondition that a debug session must be active, but there is no explicit when-to-use guidance, no exclusions, and no routing to debug_get_stack_frames or debug_get_variables.

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

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

With no annotations, the description carries the full behavioral burden. It discloses one meaningful trait - the tool only applies to a suspended process - but omits what happens when the process is not suspended (error vs empty), that it is a non-mutating read, and whether results are scoped to a selected frame or thread.

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. It is efficient, though its brevity comes at the cost of the sibling differentiation and precondition detail noted above.

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 covers return values and there are no parameters, so the remaining gaps are behavioral. The description does not say how variables relate to the frame/thread siblings a debugger session would use first, nor what happens outside a suspended state.

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 is nothing for the description to disambiguate. Baseline 4 applies; the description adds nothing misleading about 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 ('Get current variables') plus a scoping condition ('when process is suspended'). It is clear what it does, but it never distinguishes itself from the closely related debug_get_stack_frames and debug_get_threads siblings, leaving the agent to infer the boundary.

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

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

The phrase 'when process is suspended' implies the prerequisite context for calling it, but there is no explicit when-not guidance, no mention of what to do if the process is running, and no routing to the stack-frame or thread siblings that typically precede this call.

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

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

No annotations are provided, so the description carries the full burden; it does at least indicate this is a read of the active selection and that code is returned. It is silent on the important edge case of no current selection (error vs. empty result) and on whether it depends on GUI focus/state, which matters for a selection-scoped tool.

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

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

A single short sentence with the scope qualifier ('currently selected') front-loaded and no filler. 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, and a zero-parameter read tool needs little more than a clear statement of what it fetches. The only meaningful omission is behavior when no class is selected, which slightly weakens 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. No parameter claims are made that could mislead.

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 (fetch) and a specific resource (the currently selected class plus its code) tied to the JADX-GUI plugin. It is largely distinguishable from siblings like get_all_classes or get_class_source, though the overlap with get_selected_text and get_class_source (which also returns a class's code) is not addressed.

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

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

The phrase 'currently selected' implies the use case (work from whatever the user has open rather than naming a class), but there is no explicit when-to-use/when-not guidance or named alternative. An agent must infer that this is the tool for the active GUI selection versus get_class_source or get_selected_text.

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

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

No annotations, so the description carries full behavioral burden, yet it only says 'pagination support' without explaining what pagination means in practice (e.g., whether count=0 means 'all', or what happens at the end of the list). It says nothing about ordering, permissions, or scale of the result set.

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. It is efficient, though efficiency here comes partly from omission rather than precise scoping.

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-shape explanation isn't required. But for a tool with two opaque pagination parameters and a sibling keyword-search tool, the definition leaves too much to guesswork about how to call it correctly and when.

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 0%, with two integer parameters (count, offset) that are undocumented in both schema and description. The phrase 'pagination support' implies their role but does not define units, defaults (count=0, offset=0), or how a zero count is interpreted.

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 clear verb and resource: returns all classes in the project, with pagination. It does not differentiate from the sibling search_classes_by_keyword, which is the most likely alternative for retrieving classes.

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 or when-not-to-use guidance. The description doesn't mention the keyword-search sibling or any condition under which an agent should prefer that tool over an unfiltered list.

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

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

No annotations exist, so the description carries the full disclosure burden, yet it says nothing about ordering, whether results are paginated, whether 'all' is truly exhaustive, or cost/performance of enumerating an entire APK's resources. Only the existence of an output schema relieves it of explaining the return shape.

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

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

One short sentence with no waste and the resource is front-loaded, but the brevity comes from under-specification rather than economy — there is essentially nothing after the core statement.

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 bulk-enumeration tool with two undocumented pagination parameters and zero annotations, the description should at minimum explain paging behavior and the default count=0. The output schema covers return values, but the calling contract remains incomplete.

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

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

Schema description coverage is 0%, so both parameters (count, offset) are undocumented anywhere. The description does not explain that they paginate the results, nor the unusual default count=0 (which likely means 'everything'), leaving the agent to guess.

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+resource: 'Retrieve all resource file names' tells the agent this is a bulk listing of resource file names, and 'all' implicitly contrasts with the single-file sibling get_resource_file. However, it never names that sibling or states the distinction 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?

There is no guidance on when to use this instead of get_resource_file or get_strings, and no preconditions or exclusions. Usage is only inferable from the word 'all'.

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

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

No annotations are provided, so the description carries the behavioral burden. It implies a simple read-only retrieval of manifest content, but it does not disclose failure behavior, file-size concerns, or whether the manifest is returned as raw XML or parsed data. For a zero-parameter read tool with an output schema, this is adequate but not rich.

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

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

The definition is a single front-loaded sentence with no structural clutter. The phrase 'retrieve and return' is slightly redundant, but the description is otherwise appropriately concise.

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

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

An output schema exists, so the description does not need to explain return values in detail. For a zero-parameter read tool, stating that it retrieves the AndroidManifest.xml content is nearly complete, though it could mention how this differs from the component-level sibling.

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

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

The tool has zero parameters, so there is no parameter semantics to explain. The baseline for a zero-parameter tool is 4, and the description does not need to add parameter guidance.

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

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

The description states a specific verb and resource: it retrieves the AndroidManifest.xml content. It is clear what the tool returns, but it does not explicitly distinguish this whole-manifest tool from the sibling get_manifest_component, which likely handles component-level manifest data.

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 guidance about when to use this tool versus get_manifest_component, get_resource_file, or other manifest-related siblings. Usage is only implied by the resource name, with no exclusions or alternatives 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It communicates that the tool returns statistics fields such as hits, misses, hit_rate, cached_classes, compressed_mb, and compression_ratio, but it does not explicitly state safety, side effects, permissions, or performance characteristics.

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 words. It efficiently lists the key statistics fields without unnecessary elaboration.

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

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

The tool has no parameters, and an output schema exists, so the description need not explain return values in detail. For a simple cache-statistics read operation, the description provides enough context to call it correctly.

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

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

The tool has zero parameters, so the baseline is 4. There are no parameter semantics to explain, and the description correctly does not invent any.

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

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

The description uses a specific verb and resource: 'Get decompilation cache statistics.' It also names the metrics returned, which clarifies the scope. It does not explicitly distinguish itself from the sibling clear_cache, but the read-only 'statistics' purpose is still clear.

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

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

Usage is implied by the name and description: this is a read-only inspection tool for cache health. However, the description does not state when to use it versus alternatives like clear_cache, nor does it mention any prerequisites or follow-up actions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether the class must be loaded, whether source is decompiled from bytecode, what happens if the class is not found, or whether any prerequisites apply.

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 words. It states the action and resource 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?

Although the output schema covers return values and the tool is simple, the description leaves critical gaps: class name format and selection relative to many similar source/method/class siblings. For a 31-sibling toolset, this is not enough to reliably invoke the right 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 0%, so the single class_name parameter has no structured documentation. The description refers only to a 'specific class' and does not clarify whether the name must be fully qualified, simple, or nested-class syntax.

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: fetch the Java source of a class. It clearly implies decompiled Java rather than bytecode/Smali, but does not explicitly distinguish itself from close siblings like fetch_current_class or get_smali_of_class.

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

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

There is no guidance on when to use this tool versus fetch_current_class, get_smali_of_class, or the various get_methods/get_fields tools. The agent must infer the selection criteria from tool names 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?

No annotations are provided, so the description carries the full burden, yet it says nothing about whether inherited fields are included, whether the result is ordered, or that it is a read-only operation. Only the plain 'list' verb hints at a safe read.

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

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

One short, front-loaded sentence with no wasted clauses. Brevity is appropriate here, though it borders on under-specified rather than crisp.

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 don't need explaining, and the argument shape is trivial (one string). What is missing is the expected form of class_name and any scoping note about inherited 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 0% and the single parameter is undocumented in both places; the description never says whether class_name expects a fully qualified name, a simple name, or a path. This leaves a real ambiguity for the most important input.

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 ('List all field names') which is clearly distinct from the sibling get_methods_of_class. It doesn't explicitly name that sibling, but the field/method distinction is evident from the wording.

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 over get_methods_of_class, get_class_source, or get_smali_of_class, and no prerequisites or exclusions are given. The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses the data source (AndroidManifest.xml) and the fetch operation, but does not mention behavior when the manifest is missing, parsing failures, or whether the result is cached. For a simple read-only retrieval tool this is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately states the operation and the source artifact.

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 parameterless tool with an output schema, the description is largely complete: it identifies what is fetched and from where. The main missing piece is differentiation from sibling manifest and class-retrieval tools, which would help an agent choose correctly.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. The baseline for a parameterless tool is 4, and the description does not need to compensate for schema gaps.

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: fetch the main activity class from AndroidManifest.xml. It clearly identifies the artifact being retrieved, though it does not explicitly distinguish itself from sibling tools like get_android_manifest or get_manifest_component.

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 explicit guidance on when to use this tool versus related manifest tools. An agent can infer that it retrieves the main activity class, but there are no conditions, exclusions, or named alternatives.

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

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

No annotations are provided, so the description carries the full disclosure burden. It only notes pagination, without saying what format the code is in (source/smali), how heavy the response may be, or whether pagination has limits or ordering.

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 pagination note is placed immediately after the core purpose.

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

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

An output schema exists, so return values need not be explained, but for a tool with two undocumented parameters and no annotations the description should say more about what 'main application classes' means and what the code payload looks like.

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

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

Both parameters (count, offset) have 0% schema description coverage, yet the description only says 'with pagination' without explaining default behavior, maximum page size, or how offset interacts with count.

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 ('Fetch') and resource ('main application classes' code'), which implicitly separates it from get_main_application_classes_names and get_all_classes by emphasizing code retrieval rather than names or listing.

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

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

No guidance on when to use this versus siblings like get_main_application_classes_names, get_class_source, or get_all_classes. The agent must infer the distinction from the word 'code' and the tool name 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?

No annotations are provided, so the description bears the full behavioral burden, and it discloses little. It does not confirm the operation is read-only, say what happens when the manifest has no main classes (empty vs error), or note that results come from manifest parsing rather than static analysis. Only the data source ('Manifest package') is added context.

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

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

A single short sentence with the action and source front-loaded and no filler. It is arguably too terse rather than padded, but nothing in it fails to 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?

An output schema exists, so return values needn't be explained, and a no-param tool is structurally simple. However, with no annotations and a crowded sibling set, the description should still clarify what counts as a 'main application class' (activities, services, application class?) to prevent confusion with get_main_activity_class and get_main_application_classes_code.

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 and the schema is fully closed (additionalProperties: false), so there is nothing for the description to document. Baseline 4 applies; the description correctly adds no misleading parameter hints.

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 gives a specific verb ('Fetch') and resource ('main application classes' names'), and the word 'names' separates it from the sibling get_main_application_classes_code. It also names the source, 'Manifest package', which clarifies what these classes are. It stops short of explicitly distinguishing itself from get_main_activity_class or get_all_classes.

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 it should use this when it needs class names from the manifest rather than bytecode or a single activity. There is no explicit when-to-use or when-not-to-use guidance, and no mention of the closest alternatives (get_main_application_classes_code, get_main_activity_class, get_all_classes).

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

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

No annotations exist, so the description carries the full burden; it does disclose the data source (AndroidManifest.xml) and the supported component types, and the presence of an output schema offloads return-format disclosure. It says nothing about behavior for an unrecognized component_type, case sensitivity, or whether all matching components of a type are returned.

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 with the resource and data source front-loaded, then the supported values. Minor grammatical awkwardness ('support filter exported components'), but 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 simple 2-parameter tool with an output schema, the essentials are covered, but the definition leaves an agent unable to distinguish this from get_android_manifest in edge cases and silent on invalid component_type handling. Adequate but with clear gaps at the sibling boundary.

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 0%, so the description must compensate, and it largely does: 'activity, provider, service, receiver' effectively supplies the missing enum for component_type, and 'filter exported components' explains only_exported. It does not state defaults or whether only_exported is ignored for non-filterable types.

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: retrieve component data from AndroidManifest.xml, and enumerates the component types it covers (activity, provider, service, receiver). It stops short of naming the sibling get_android_manifest, so the boundary between 'whole manifest' and 'one component type' must be inferred.

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 description says it can 'filter exported components', which hints at when only_exported matters, but there is no explicit when-to-use, when-not-to-use, or pointer to get_android_manifest for whole-manifest reads. An agent must guess which of the two manifest tools to call.

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

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

No annotations are supplied, so the description carries the full behavioral burden, yet it says nothing about what happens when the method isn't found, how overloaded methods are resolved, or whether a partial/empty result is possible. 'Fetch the source code' is the only behavioral claim.

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. It is efficient, though efficient at the cost of summarizing rather than specifying.

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 explained, but for a code-retrieval tool with zero annotation coverage and zero parameter documentation, the description omits overload handling, not-found behavior, and how it relates to sibling retrieval tools — leaving real 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 0% across three parameters, and the description only implicitly maps to class_name and method_name. The third parameter, method_signature — critical for disambiguating overloads — is never mentioned, so the description fails to compensate for the empty 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 and resource: fetch source code of a method in a class. It's clear what the tool does, but it doesn't distinguish itself from close siblings like get_class_source, search_method_by_name, or get_methods_of_class, so an agent can't tell from the description alone which one to reach for.

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

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

There is no guidance on when to use this versus search_method_by_name or get_class_source, and no mention of prerequisites such as knowing the class first (cf. fetch_current_class). Usage is only implied by the name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether inherited methods, constructors, or overloaded methods are included, whether method signatures or only simple names are returned, or what happens if the class is not found.

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 concise sentence that is front-loaded and wastes no words. It is appropriately sized for the purpose, though its terseness contributes to gaps in 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?

The tool is simple and has an output schema, but the description omits the class_name format and does not describe what 'method names' includes. With no annotations and 0% parameter schema coverage, these gaps are significant.

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 0% for the single required parameter. The description does not clarify whether class_name should be a fully qualified name, simple name, or something else, leaving a meaningful ambiguity for invocation.

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 ('List') and resource ('method names in a class'), making the operation clear. It implicitly distinguishes itself from siblings like get_fields_of_class and get_class_source by focusing on method names, but it does not explicitly name alternatives or clarify scope.

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

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

There is no guidance on when to use this tool versus siblings such as get_method_by_name, get_class_source, or get_smali_of_class. The intended usage is only implied by the tool name and 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?

With no annotations, the description carries the behavioral burden. It discloses the return shape and ordering ('sorted by class count') and implies a read-only operation through 'Get' and 'Shows', but it does not explicitly confirm read-only safety, side effects, or prerequisites such as requiring a loaded APK.

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

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

The description is three short sentences and front-loads what the tool returns. The middle sentence listing output fields is somewhat redundant with the output schema, but it remains compact and readable.

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 zero-parameter schema, absence of annotations, and presence of an output schema, the description provides enough context to call the tool correctly. It could be slightly stronger by clarifying prerequisites or read-only behavior, but no essential invocation detail is missing.

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

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

The tool has zero input parameters, so parameter semantics are not a concern and the baseline is 4. The description appropriately does not spend space explaining nonexistent parameters.

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

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

The description states a specific verb and resource — 'Get all packages in the APK' — and adds scope details like sorting by class count and per-package output fields. It does not explicitly distinguish itself from close siblings such as get_all_classes or get_main_application_classes_names, so it is clear but not fully differentiated.

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 final sentence gives explicit usage guidance: 'Use this first to understand the APK structure before searching.' That establishes when to use this tool relative to search-oriented siblings, though it does not name a specific alternative or state when not to use it.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Retrieve' implies a read, but it says nothing about permissions, behavior when the file is missing, whether binary content is handled, or how large files are returned – all meaningful for a resource-file lookup.

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 efficient sentence with the action front-loaded and no filler. It is appropriately short, though the brevity reflects under-specification rather than tightness.

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. But with no annotations and an undocumented parameter, the description omits key context an agent needs: accepted name format and read-only/error behavior, making it insufficient for reliable invocation.

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 0% and the single required parameter resource_name is completely undocumented. The description does not explain whether the value is a full path, a bare filename, or a resource identifier, leaving the agent to guess the expected format.

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 ('Retrieve') and resource ('resource file content'), which the agent can distinguish from the sibling get_all_resource_file_names that only lists names. However, it never explicitly names that sibling or clarifies the relationship, so differentiation is inferred rather than stated.

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, no prerequisites, and no reference to the obvious alternative (get_all_resource_file_names) that would tell the agent which to pick. The agent must guess from the name 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a read of transient UI state, which is useful, but says nothing about the failure case (empty selection vs. error), whether the selection is stale, or any limits. That is a notable gap for a no-annotation tool, though the existence of an output schema lightens the load on return-value disclosure.

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

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

A single front-loaded sentence with no filler. Every word earns its place and the key qualifier ('currently selected') appears early.

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 trivial zero-parameter read tool with an output schema, the description covers what the agent needs to decide to call it. The only missing piece is empty-selection behavior, which is minor given the output schema covers the success shape.

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 is no schema semantics to add; baseline 4 applies. The description correctly implies the selection is implicit ambient state rather than something passed in.

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 ('Returns') and a precise resource ('the currently selected text in the decompiled code view'), which is meaningfully distinct from siblings like get_class_source or get_strings that return whole artifacts. It is clear without naming an alternative, which keeps it just below 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?

No guidance on when to prefer this over get_class_source or get_smali_of_class, and no prerequisites such as 'requires an active editor selection'. The agent must infer that this reads transient editor/UI state rather than persisted code.

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

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

No annotations are provided, so the description carries the full burden. It implies a read operation but says nothing about behavior when the class is missing, whether the result is cached, or whether the class name must be fully qualified. For a lookup tool in a reverse-engineering context, that is a meaningful 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?

A single front-loaded sentence with no filler. It is efficient, though the brevity borders on under-specification given the tool's role.

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, but the description omits the class_name format and the distinction from get_class_source. For a single-parameter lookup tool with no annotations and zero schema coverage, it leaves the agent under-informed.

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 0% and the description does not explain the class_name format (dot-separated vs slash-separated, inner classes, package prefix). With one undocumented parameter, the description fails to compensate for the schema gap.

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 ('Fetch') and resource ('smali representation of a class'), so the agent knows exactly what it returns. It does not differentiate itself from close siblings like get_class_source, which likely returns Java source, leaving the choice ambiguous.

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

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

There is no guidance on when to use this over get_class_source or get_methods_of_class. The agent must infer that 'smali' means bytecode-level decompilation and pick accordingly, which is not stated.

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

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

With no annotations, the description carries the full burden, yet it says nothing about read-only safety, whether results span multiple modules/files, or how pagination behaves. The existence of an output schema covers return shape, but pagination semantics for count/offset remain undisclosed.

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

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

A single front-loaded sentence with no filler, so it is concise. However, the brevity is under-specification rather than efficiency given two entirely undocumented parameters.

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

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

The output schema relieves the description of explaining return values, but for a paginated, annotation-less tool with 0% schema coverage, the definition leaves the critical paging behavior and usage context entirely unexplained.

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

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

Schema description coverage is 0%, so the description must compensate and does not: 'count' and 'offset' are never explained. An agent cannot tell whether count=0 means 'all strings' or 'none', nor what offset indexes over.

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 verb and resource ('Retrieve contents of strings.xml files'), which is clearer than the vague title. It is implicitly distinguished from siblings like get_all_resource_file_names and get_resource_file by narrowing to strings.xml, though that distinction is never stated.

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

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

There is no guidance on when to use this tool versus get_resource_file or get_all_resource_file_names, and no mention of prerequisites. The agent must infer selection criteria purely from the resource name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Find' weakly implies a read operation, but it says nothing about whether results are capped, whether count/offset truncate the reference list, or that only 20 results come back by default — behaviorally important for a xref tool that can return large volumes.

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 or redundancy. It is efficiently structured; the deficiency is missing information, not verbosity.

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, but with no annotations, 0% parameter coverage, and two undocumented pagination parameters, the definition leaves an agent unable to know that results are paged and default-limited. This is inadequate for a paged query tool with three parameters.

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

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

Schema coverage is 0%, and the description mentions no parameters at all. The required class_name is inferable from the tool name, but count and offset — including their defaults of 20 and 0, which silently truncate results — are completely unexplained in both schema and description.

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 ('Find all references to a class'), which is unambiguous on its own and clearly distinguishable from write-style siblings like rename_class. However, it does not distinguish itself from the near-identical get_xrefs_to_method and get_xrefs_to_field siblings, which the agent must infer from the names alone.

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

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

There is no guidance on when to use this tool versus the method/field xref siblings, no prerequisites, and no note about needing the class already loaded or selected. The agent must infer everything from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about pagination behavior, result ordering, default limits (count defaults to 20, offset to 0), or whether references are scoped to the analyzed app. It does not contradict anything, but discloses almost no behavior beyond the one-line purpose.

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 short, front-loaded sentence with zero filler. Its brevity is efficient, though it borders on under-specification for a four-parameter tool with no annotations.

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 explained, but for a tool with four parameters, no annotations, and pagination defaults, the description is too thin. An agent would not know default page size, how to page through references, or how this differs from the method/class xref variants.

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 0% and the description mentions no parameters at all. While class_name and field_name are self-explanatory by name, the pagination parameters count and offset — including that count is capped at a default of 20 — are left entirely undocumented in both schema and description.

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 ('Find all references to a field'), making the core operation unambiguous. However, the description never distinguishes it from sibling tools like get_xrefs_to_method or get_xrefs_to_class, relying entirely on the tool name for that 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?

No guidance on when to use this versus get_xrefs_to_method, get_xrefs_to_class, or get_fields_of_class, and no preconditions (e.g., must the class be loaded/analyzed first). The agent must infer the selection criteria from the name 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state that this is a read-only lookup, mention pagination via count/offset, describe what happens when the class or method is not found, or explain how the class_name scopes the search. The presence of an output schema relieves some return-value burden, but significant behavioral gaps remain.

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 single sentence is front-loaded and contains no wasted words, so it is concise. However, it is under-specified rather than optimally concise, and 'all' conflicts with the paginated count/offset defaults, reducing precision.

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 four-parameter tool with no annotations, no parameter descriptions, and sibling tools that perform adjacent reference lookups, the description is far too thin. The output schema covers return values, but the description lacks routing guidance, pagination behavior, and parameter semantics needed for correct invocation.

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 0%, so the description must compensate, but it adds almost nothing. It implies a method target via class_name and method_name but does not explain their exact-match requirements, and it entirely ignores count and offset, which are undocumented in the schema as well. Parameter names are somewhat self-explanatory, preventing a 1, but the description fails to clarify the four parameters.

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

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

The description states a clear verb and resource ('Find all references to a method'), so the basic operation is identifiable. However, it gives no scope beyond 'a method' and does not distinguish this from sibling tools like get_xrefs_to_field, get_xrefs_to_class, or get_method_by_name. The word 'all' is also slightly misleading since the schema exposes pagination defaults.

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

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

There is no guidance on when to use this tool versus get_xrefs_to_field, get_xrefs_to_class, or search_method_by_name. No prerequisites, exclusions, or alternative-selection criteria are provided, leaving the agent to infer usage from the name 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?

With no annotations, the description carries the full behavioral burden for a mutation tool. It does not disclose whether the rename updates cross-references, whether it is reversible, whether the class must be currently selected or loaded, or any failure modes.

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 single sentence is front-loaded and waste-free, but in this case brevity reflects under-specification rather than efficiency.

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, but the description still omits essential mutation semantics for a two-parameter, zero-coverage schema. An agent knows the intent but not the preconditions or side effects.

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 0% for both required parameters. The phrase 'a specific class' loosely implies class_name, but new_name is never explained, and there is no hint about naming conventions or whether a fully-qualified name is required.

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 verb+resource pair (rename + class) is identifiable, but it is essentially a restatement of the tool name and title. It does not distinguish this tool from siblings like rename_method, rename_field, or rename_package beyond the word 'class'.

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

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

There is no guidance on when to use this over renaming via other means, no prerequisite that the class must exist or be loaded, and no mention of what happens to references. The agent is left to infer everything.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only says the tool renames a field, without explaining what else changes, whether references are updated, whether the operation is reversible, or what permissions are needed.

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 short sentence with no wasted words and is front-loaded with the action. It is concise, though 'specific' adds little meaning and the brevity leaves no room for useful context.

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 documentation is not required. However, for a mutation tool with no annotations and three completely undocumented required parameters, the four-word description is insufficient to help an agent invoke it confidently.

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 0%, and all three required parameters (class_name, field_name, new_name) are undocumented in the schema. The description does not explain what any of these parameters mean or how class_name and field_name interact.

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: renaming a field. It distinguishes itself from sibling rename tools like rename_class, rename_method, and rename_variable by naming the field as the target, though 'specific field' remains somewhat vague.

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

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

No guidance is given on when to use this tool versus alternatives such as rename_variable or rename_class. There are no prerequisites, exclusions, or contextual cues about when renaming a field 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing. For a mutation tool it should say whether references/xrefs are updated with the rename, whether the operation is reversible, and how overloaded methods are disambiguated — none of that appears.

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 short sentence with no waste, but the brevity is under-specification rather than conciseness. There is no front-loaded scope or qualifier to anchor the agent before it picks parameters.

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. Everything else is missing, though: for a mutation with no annotations and 0%-covered parameters, the description should at minimum explain how a target method is identified and what the rename affects.

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 0% across three parameters, so the description must compensate and it does not mention any parameter. The critical ambiguity — what method_name alone means for an overloaded method versus the optional method_signature discriminator (default null) — is left entirely unexplained.

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?

"Renames a specific method" gives a verb and a resource, so an agent can tell it apart from the rename_class/rename_field/rename_variable siblings by target type. But it adds nothing beyond the name/title: no scope, no notion of what a "method" means here (name only vs. signature), and "specific" is filler.

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 the closely related siblings (rename_class, rename_field, rename_package, rename_variable), nor any prerequisite or constraint. The agent must infer everything from the resource noun 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?

With no annotations, the description carries the full burden. It does disclose one real behavioral trait — the rename cascades to all contained classes — but a mutation tool of this kind should say whether references/xrefs are updated, whether changes persist to disk or require an apply step, and whether the operation is reversible.

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 — efficient structurally. It is thin for the tool's complexity, but that shortfall is captured in the other dimensions rather than here.

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 explained. Everything else is missing, though: undocumented parameters, no annotations covering the mutation risk, and no statement of persistence or side effects for a two-parameter destructive operation.

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

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

Schema description coverage is 0%, so the description must compensate, and it does not: neither old_package_name nor new_package_name appears in the text. An agent gets no hint about expected format (dotted name vs. path), whether a missing package is an error, or what happens if the new name already exists.

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

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

States a specific verb plus resource ("Renames a package") and adds the scope qualifier "and all its classes," which implicitly separates it from the sibling rename_class that operates on a single class. It never names a sibling explicitly, so an agent must still infer the boundary.

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

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

There is no guidance on when to pick this over rename_class, rename_method, or rename_field, and no prerequisites or preconditions are stated. The only routing signal is the word "package" in the resource.

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

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

No annotations are provided, so the description carries the full burden. It says 'Renames' but does not disclose whether references are updated, whether the operation is reversible, what permissions or debugger state are required, or what happens to conflicts. For a mutation tool with zero annotation coverage, this is a clear gap.

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

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

The single sentence is front-loaded and not padded, but it is under-specified rather than concise. Every sentence earns its place only because there is just one sentence.

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. However, for a six-parameter mutation tool with no annotations and 0% schema description coverage, the description is far too thin. It omits parameter meaning, preconditions, and behavioral effects.

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 0% across six parameters. The description does not explain any parameter, including required ones like class_name, method_name, variable_name, new_name, or the undocumented reg and ssa parameters.

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

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

States a specific verb and resource: 'Renames a specific variable in a method.' It distinguishes itself reasonably from rename_field/rename_class by naming 'variable in a method,' though the sibling relationship is not made 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?

No guidance on when to use this instead of rename_field, rename_method, or other rename siblings, and no prerequisites such as needing an active debug session or loaded class.

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

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

No annotations are provided, so the description must carry the behavioral burden; it implies a read-only search but never states cost, caching, or performance characteristics of scanning a whole APK. Pagination behavior via count/offset is only visible in the schema, and there is no note about how many matches are scanned before returning.

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 opening sentence is well front-loaded, but the numbered list largely restates the search_in enum values that the schema already enumerates verbatim, so several lines do not earn their place. Structure is readable, content is partly redundant.

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, and all five parameters are documented in the schema. What remains missing is fit within the toolset — when this search should be used instead of the many sibling class/method retrieval tools — leaving the selection decision under-supported.

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's bullets echo the package and search_in semantics already fully documented in the schema, adding framing ('combine multiple scopes for precise results') but no new syntax or default behavior beyond what the properties describe.

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 (search) and resource (classes) plus the matching basis (keyword), so the agent knows it retrieves classes rather than a single known class. It does not name or differentiate itself from near-siblings like search_method_by_name or get_all_classes, and 'search across decompiled Android code' slightly muddies whether the unit of result is a class or a code match.

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 three bullets imply when the tool is useful (targeting a package, narrowing to scopes), but there is no explicit statement of when to prefer it over get_all_classes, get_class_source, or search_method_by_name. Usage context is inferable but never spelled out.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the search scope (all classes), which is useful, but says nothing about match semantics (exact vs. substring, case sensitivity), duplicate handling, result ordering, or performance implications of scanning every class.

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. It is efficient, though its brevity edges into under-specification for a search tool rather than being optimally 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?

An output schema exists, so return format needn't be explained, and only one parameter is present. Still, for a cross-class search tool the description leaves out match semantics and routing guidance that an agent needs to invoke it correctly versus get_method_by_name.

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

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

The single parameter has 0% schema description coverage, so the description must compensate. It only restates the parameter as a 'method name' and does not clarify whether a simple name, fully qualified name, or partial string is expected.

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 ('Search for a method name') and adds the scope 'across all classes,' which implicitly distinguishes it from get_method_by_name and get_methods_of_class. It does not explicitly name a sibling or clarify whether the search is exact or substring, so it stops short of full 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?

Usage is only implied: 'across all classes' hints that this is the tool for when the owning class is unknown, versus get_method_by_name. There is no explicit statement of when to use it, when not to, or which of the many siblings to prefer.

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