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

The annotations already declare readOnlyHint=false, destructiveHint=true, openWorldHint=true, and idempotentHint=false, so the safety profile is partly covered. The description adds useful behavior beyond the annotations by stating that shared observer dispatch preserves original return/exception semantics and that loader IDs are trace-local. However, it does not explain what is destroyed or modified in the trace, or what permissions/error conditions 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 three sentences, front-loaded with the main action, and each sentence carries relevant operational information. The final sentence about observer dispatch is dense but earns its place by clarifying runtime semantics. It could be slightly clearer, but it is 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?

For a destructive active-trace instrumentation tool with three parameters, no output schema, and low schema description coverage, the description covers the prerequisite and the loader-ID caveat. It still omits what happens after hooks are added, error conditions, and how the nested selector fields are interpreted. It is adequate but not fully complete 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 only 33%, so the description needs to compensate. It adds meaning for trace_id (same active trace) and loader_id (trace-local, not copied between traces), plus a high-level sense of selectors as 'exact Java selectors'. It does not explain class_name, method, or arg_types, leaving important selector semantics to the schema alone.

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 and resource: add exact Java selectors to the same active trace. It also anchors the action after search_java, which helps separate it from the sibling search/discovery tool. It is not quite a 5 because the relationship between 'Java selectors' and the tool name 'add_java_hooks' remains slightly implicit.

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

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

It clearly states the prerequisite 'after search_java' and the constraint that selectors must go to the same active trace. It also warns that explicit loader IDs are trace-local and must not be copied between traces. It lacks explicit when-not-to-use or alternative guidance, so it falls short of a 5.

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

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

Annotations carry the safety profile (idempotent, non-destructive, closed-world), so the description could add value with real behavior—what happens when no symbol exists at the address, whether it falls back to a synthesized label, whether debug info or dynamic symbols are consulted—but it says nothing. Note the tension between the verb "Read" and readOnlyHint=false; the analysis_project_id parameter plausibly explains the side effect (result retention), but the description never reconciles it.

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. Brevity is achieved, though partly by omitting needed content rather than by discipline.

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

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

There is no output schema, so the description must convey what an agent gets back—a symbol string, a null, a fallback—and it does not. Combined with the undocumented document parameter and the unstated open-binary prerequisite, an agent can only call this correctly by guessing.

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 only 33%, and the description compensates for none of it. The required address parameter has only a regex pattern and no explanation of accepted forms (module:offset vs raw hex), and the optional document parameter is 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?

"Read the symbol name at an address" states a specific verb and resource, and "in the active ELF analysis" scopes it to the open binary session. It does not differentiate from nearby siblings such as list_names, address_to_file_offset, or map_native_address, which an agent could plausibly confuse it with.

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 choose this over list_names (bulk listing) or map_native_address, and no stated prerequisite that a binary must first be opened via open_binary. The only hint of context is the phrase "active ELF analysis," which implies far more than it explains.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that: it doesn't explain behavior when the address is unmapped, whether an open binary session is needed, or why readOnlyHint is false for an apparently pure lookup (presumably the analysis_project_id retention path).

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

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

A single front-loaded sentence with the verb and both resources; nothing extraneous and no buried detail.

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

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

Three parameters, one required, no output schema and no annotations covering side effects, yet the description says nothing about session prerequisites, error cases for unmapped addresses, or what the returned offset looks like. For a lookup tool in a binary-analysis session it is under-specified.

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 only 33% and the description explains no parameters at all. In particular it never mentions the accepted second address form (module/namespace-prefixed 'name:0x...') permitted by the regex, nor the optional document/analysis_project_id arguments — exactly the gap the low coverage requires the prose to fill.

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 ('Resolve') and both ends of the transformation (ELF virtual address -> input file offset), which is precise about scope. It does not, however, distinguish itself from the sibling map_native_address, which sounds like an adjacent capability an agent could easily confuse it with.

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 map_native_address or resolve_containing_procedure, and no prerequisites stated (e.g. whether an open binary/document session is required). The agent must infer all selection criteria.

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

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

Annotations already declare idempotent, non-destructive, closed-world behavior, so the bar is lower; the description adds the genuinely useful prerequisite that an ELF analysis must be active. It does not resolve the tension between "Read" and readOnlyHint=false (the analysis_project_id retention side effect), nor does it describe what the dossier returns.

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 filler. It is well structured, but the brevity is partly under-specification given everything the tool leaves unsaid.

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

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

There is no output schema, so the description should explain what a "dossier" contains, yet it does not; combined with an unexplained required parameter and heavy sibling overlap, the definition is not sufficient for confident 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?

The required "procedure" parameter has no schema description and the tool description adds nothing about its form (symbol name, address, mangled name?). With coverage at 50%, the description was expected to compensate and instead contributes no parameter meaning at all.

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

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

It has a concrete verb and resource ("Read a function dossier"), but "dossier" is undefined jargon and the definition gives no signal for choosing it over the many similar siblings such as procedure_info, procedure_pseudo_code, procedure_assembly, or read_function_instructions. An agent knows roughly what it touches but not what makes it distinct.

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 when-to-use guidance and no named alternative. The only usage-adjacent hint is "active ELF analysis", which implies a session must be open but never states the prerequisite explicitly or what to do if no session exists.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds one genuine behavioral fact beyond them — that no provider is started as a side effect — but omits what happens when there is no active session (empty result vs. error).

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

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

One front-loaded sentence with no filler; every word carries information. It is efficient, though the same terseness leaves gaps elsewhere in the definition.

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?

Read-only, no output schema, and a single fully-documented optional parameter — a simple tool, so modest description is defensible. But with no output schema the description is the only place to say what 'session state' actually returns, and it does not.

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 optional parameter has 100% schema description coverage, including its regex pattern and the caveat that it does not prove target identity, so the schema does the heavy lifting. The description adds nothing about analysis_project_id, which is acceptable at full coverage but yields only the baseline.

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 ('Read') and resource ('active ELF session state'), and the qualifier 'without starting a provider' implicitly separates it from open_binary/close_binary. It stops short of naming a sibling, and 'session state' is never unpacked into the fields an agent would expect.

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 'without starting a provider' implies the usage condition (checking session state cheaply, without lifecycle side effects), but it never states when to call it versus open_binary, nor what to do if no session exists. Usage is inferable rather than prescribed.

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

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

Beyond annotations, it adds useful mechanics: the capture uses `screencap -p` through exec-out, creates no device-side file, writes into an output directory, and reports a digest and dimensions. It remains consistent with readOnlyHint=false because it creates a local PNG, and it does not overstate destructive behavior.

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

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

The description is two compact sentences, front-loads the core action, and includes only relevant technical detail. Every clause contributes to understanding what the tool does or does not do.

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 three-parameter tool with full schema coverage and no output schema, the description is largely sufficient: it explains the capture mechanism, output location, digest, dimensions, and exclusions. It could be slightly more complete about the digest format or failure behavior when the target file already exists, but the schema covers the latter.

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

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

Schema description coverage is 100%, so all three parameters are already documented. The description adds only the notion of a caller-selected output directory and does not explain serial selection or analysis_project_id beyond what the schema provides.

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

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

The description states a specific verb and resource: capture one frame of the device screen as a PNG. It also scopes the operation by noting it is not recording or interaction, which distinguishes it from nearby UI/runtime siblings.

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

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

It clearly establishes the intended use case: a single-frame screenshot into a caller-selected directory. It also gives an exclusion, 'No recording or interaction,' but does not explicitly name when to prefer sibling tools such as capture_ui or inspect_adb_display.

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

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

The description adds useful context beyond annotations: it states the return contents (node IDs, bounds, artifact hashes), explains that one owned temporary device XML file is used and deleted, and warns about partial semantics for some rendering technologies. This clarifies the destructive annotation rather than contradicting it.

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 tightly written sentences: purpose first, then return and side effects, then limitation. Every sentence adds useful information with no wasted text.

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

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

The description covers return contents, temporary file lifecycle, and rendering limitations, which are helpful for a complex device-capture tool. However, it omits parameter guidance and sibling differentiation, leaving notable gaps for correct invocation in this 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?

Schema description coverage is only 33%, with serial and package undocumented in the schema, and the description does not mention any parameter meaning beyond 'Android device'. It does not compensate for the low coverage.

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

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

The description states a specific verb and resource: capturing Android screen, focus, and UIAutomator hierarchy into a snapshot. It is clear what the tool does, but it does not explicitly distinguish itself from siblings such as capture_adb_screen or read_ui_snapshot.

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

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

There is no explicit guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. The note that Compose/WebView/custom rendering may expose only partial semantics is a limitation, not usage routing.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description's job is to say what is destroyed — and it does: the provider-owned temporary project, not user projects. It leaves gaps on repeat-call behavior (idempotentHint=false is declared but unexplained) and on whether the session becomes unavailable afterward.

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

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

One sentence, zero filler, with the action and its side effect front-loaded and the scope qualifier ('active') placed before the destructive consequence.

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 one-optional-parameter tool with full annotation coverage and no output schema, this covers the essentials: what it closes, what it deletes, and that it is provider-owned. A brief note on what state the caller is left in (or the counterpart open_binary) would close the remaining gap.

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

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

Schema coverage is 100% and the single optional parameter analysis_project_id is fully documented in the schema, so the baseline of 3 applies. The description adds nothing about how this parameter interacts with a close operation — notably whether the tool result is retained in that project after the session is removed.

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 (close) and resource (the active ELF session), plus the consequence (removal of the provider-owned temporary project). An agent can distinguish it from open_binary and binary_session, though it never names the counterpart tool to reopen a session.

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

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

Usage is only implied: the word 'active' signals it applies only to an already-open session, and 'temporary project' hints at cleanup semantics. There is no explicit when-to-use/when-not-to-use guidance, no mention that open_binary is the counterpart, and no note about what happens if no session is active.

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

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

Adds real context beyond annotations: the multi-minute latency of collection and the fact that only configuration is left untouched while one new zip is written to the target directory — which reconciles the `readOnlyHint: false` / `idempotentHint: false` flags with the 'read-only' framing. Nothing here contradicts the annotations, but failure modes (no device, adb timeout, partial transfer) are unmentioned.

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

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

Two sentences, zero filler, with the operation and destination front-loaded ahead of the cost warning. Every clause carries information an agent cannot get from the schema alone.

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

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

There is no output schema and the description never says what the call returns (zip path, artifact handle, or whether the result is retained in a project). Combined with the ambiguous phrase 'digesting the zip', an agent still lacks the post-call picture for a long-running, file-producing 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 100%, so the schema already explains `serial`, `output_directory`, and `analysis_project_id`. The description reinforces that the directory is caller-selected but adds no format, collision, or retention semantics beyond what the schema states.

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

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

States a specific verb (collect) and resource (a device-generated `adb bugreport` archive) and names the output destination, so it is immediately distinguishable from siblings like `read_adb_logcat` or `pull_adb_file`. Enumerating what the archive contains (dumpstate, dumpsys, logcat) confirms scope without ambiguity.

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

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

The description implies usage ('one device-generated bugreport archive', 'collection can take minutes') and thereby signals this is the heavyweight option, but it never states when to prefer it over `read_adb_logcat`, `pull_adb_file`, or `inspect_adb_device`. No exclusions or prerequisites (device connected, adb authorized) are given.

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

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

Goes well past the readOnly/idempotent/non-destructive annotations by disclosing the operational envelope: no adbd restart, no permission changes, no force-stop, pre/post device hash checks, root-method reporting, and the caveat that sequential capture is not an atomic SQLite/device snapshot. That non-atomicity warning is the single most decision-relevant fact and it is stated explicitly.

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

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

Front-loaded with the action and constraints, and every clause carries information a caller needs. The prose is dense to the point of being telegraphic ('no force-stop', 'Checks device hashes before/after'), which reads as notes rather than polished guidance but wastes nothing.

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 6-param, root-capable forensic read with no output schema, it covers the safety profile, the fidelity limitation, and the returned logical_root. The gaps are the unmentioned max_bytes ceiling and only a single returned field named, leaving the agent without a full picture of the result payload.

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 only 17%, so the description has to carry the load, and it does for the high-risk params: paths (how many, that they must be exact), use_root (reuse or su -c / su 0 sh -c), and include_sqlite_sidecars (WAL/SHM). It says nothing about max_bytes or run_id semantics, which remain undocumented in both places.

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 and hard scope: 'Read 1..16 exact files inside the selected run package data directories via ADB.' The 'exact files' + count cap + run-package confinement distinguishes it from bulk/generic siblings like pull_adb_file and list_adb_directory, and it names snapshot_storage as the follow-on step.

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

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

Gives real conditional guidance for two params (use_root with the su re-use path, include_sqlite_sidecars) and prescribes the downstream handoff to snapshot_storage. However, it never says when to choose this over the visible alternatives pull_adb_file or pull_adb_package, nor when not to use it, which is exactly what an agent needs at selection time.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, openWorldHint=true, and the description is consistent with them rather than restating them. It adds genuinely new behavioral facts: collection happens without launching the app, hash collection is capped at 16 files, and signature validity is handled elsewhere. Missing only the resource/cost implications of openWorld access and what state the run holds afterward.

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

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

Three sentences, front-loaded with the create action and its bindings, then the collection behavior, then the exclusions. Every clause carries information an agent would otherwise have to guess; nothing is repeated from the schema or 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?

With no output schema, the description should say what an agent gets back — presumably a run identifier needed to drive read_analysis_run and get_run_timeline — but it never mentions the return value or how to reference the run afterward. The behavior side is well covered; the handoff side is not.

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 20% — only analysis_project_id is documented in the schema, so the description has to carry serial, device_id, package, and label. It meaningfully maps three of those (explicit ADB serial, Frida device ID, installed package), which is more than the schema offers. But label is never mentioned and no format expectations are given for the three required strings, so the coverage gap is only partly closed.

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

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

Names a specific verb and resource ("Create a run") and pins down the three binding inputs: ADB serial, Frida device ID, installed package. It also states concretely what the run captures (build/ABI/page-size, up to 16 APK hashes) rather than leaving the resource abstract. It does not, however, name or contrast itself with the adjacent siblings an agent would weigh it against (start_trace, list_adb_devices, create_project).

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 negatives give real scoping: it does not launch the app, does not attach, and does not deploy frida-server, which rules out several sibling tools by implication. But there is no positive "use this when…" framing, no statement that it is the prerequisite step before start_trace/get_run_timeline, and no named alternative. Usage is inferable rather than instructed.

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

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

Annotations already cover the mutation profile (readOnlyHint=false, destructiveHint=false, non-idempotent); the description adds real value with 'persistent' and the 'evidence ledger' concept plus a scope exclusion. However it omits what an agent needs for a non-idempotent create: whether duplicate names are rejected or produce duplicates, and whether anything is mutated outside the new project.

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

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

Two tight sentences with the primary action front-loaded and the scoping caveat second; nothing is padded. Slightly under-specified rather than verbose, but structurally sound.

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

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

With no output schema, the description never says what is returned (a project handle/id) or how the project relates to analysis runs, evidence reads, or export_workspace in this large sibling set. Adequate to call, thin for reasoning about the result.

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

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

Schema description coverage is 0%, so the description should carry parameter meaning. It mentions the question but never explains what 'name' denotes (project label? identifier?) or how the two relate, leaving one of two required params essentially undocumented.

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

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

States a specific verb+resource: 'Create a persistent Android investigation', with two named inputs (question, evidence ledger). The clause 'Does not choose or execute a target' draws a boundary that separates it from execution-oriented siblings like start_trace or create_analysis_run, though it does not name those siblings directly.

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 exclusion ('Does not choose or execute a target') implies this is a scoping/organizing step done before targeting work, but no explicit when-to-use statement or named alternative (e.g. create_analysis_run vs create_project) is given. Usage is implied rather than 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?

Adds substantial behavior beyond the annotations: a provider-owned workspace is created and removed after projection (explaining why readOnlyHint=false while destructiveHint=false), the APK is SHA-256 hashed, and string projection is bounded to 2000 entries. That is exactly the context the hints alone cannot convey.

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

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

Two sentences, each front-loaded with the action then the output list. Dense but nearly every clause carries information; the trailing JADX remark is short and useful. Slightly heavy for an agent skimming many tools.

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

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

There is no output schema, so the description carries the return-value burden and does so: manifest, apktool.yml version/SDK facts, strings, locale list, and decoded file count. Combined with the hashing and workspace-cleanup notes, nothing an agent needs to call this correctly is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reiterates 'default or one locale' and the 2000-entry bound, which the schema already documents, and it says nothing about analysis_project_id or the mutually-exclusive feel of locale vs include_strings. Marginal value added.

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

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

Names a specific verb (decode), a specific resource (one local APK's resources), and the exact mechanism (apktool d --no-src). It then enumerates the projected outputs and explicitly scopes out smali, which belongs to the JADX family, so the agent can separate it from the android inspection siblings.

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

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

It states the input must be a local APK and routes Java-source recovery to the JADX family, which is a real exclusion. However, with siblings like pull_adb_package and inspect_android_package present, it never says that a device package must first be pulled to disk before this tool applies.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely new behavioral context: results may be truncated and snapshots may be inconsistent, and diffing is keyed on stable relative keys rather than absolute paths. It stops short of explaining pagination mechanics or ordering of before vs after.

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 dense sentence that front-loads the action and resource, then appends scope and caveats in descending priority. No filler, no restatement of the tool name.

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

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

With no output schema, the description does useful work by enumerating the change categories and warning about truncation/consistency. Still missing for a 4-parameter analysis tool: how to source the snapshot IDs, whether before/after ordering matters, and behavior when a snapshot is missing or expired.

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 25% — only analysis_project_id is documented — so the description must compensate. It partially does: 'two retained storage snapshots' implies before_id/after_id are snapshot identifiers, and the mention of truncation hints at limit's role, but neither the 1-200 bound nor the ID format constraints are reinforced in prose.

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 ('Compare') plus a precise resource ('two retained storage snapshots') and an explicit comparison basis ('stable relative keys'), followed by the domains covered (file, XML preference, SQLite). It is clearly distinguishable from read_storage_snapshot or snapshot_storage, though it never names those siblings directly.

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

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

Usage is only implied: the agent can infer it needs two retained snapshot IDs and that this is the diff counterpart to read_storage_snapshot. There is no explicit when-to-use/when-not, no guidance on obtaining the before/after IDs, and no statement about what to do if only one snapshot exists.

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

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

Annotations already declare non-read-only, non-destructive, non-idempotent, closed-world, which matches a copy operation. The description goes beyond them by disclosing rejection conditions (active traces, symlinks, concurrent ops), the SHA-256 manifest artifact, and inclusion/exclusion rules (excludes session lock, includes retained app data). It stops short of stating failure behavior if the destination already exists or whether partial copies are cleaned up.

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

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

Three compact sentences, zero filler. Purpose first, then constraints, then inclusion/exclusion detail — well front-loaded and appropriately sized for a one-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?

With one parameter, no output schema, and annotations covering the safety profile, the description supplies what is needed to invoke it: what is copied, what is excluded, and what causes rejection. The remaining gap is the return value (where the manifest is written) and destination-exists behavior, which is minor given no output schema.

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

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

Schema description coverage is 0% and the single 'destination' parameter carries no description, so the definition must compensate. 'To a new directory' usefully implies the path must not already exist, but nothing is said about absolute vs relative paths, permissions, or whether the parent must exist.

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 + scope: 'Copy the quiescent workspace to a new directory with SHA-256 manifest for migration.' An agent understands exactly the operation and that it is a migration/export, distinct from the sibling import_workspace. It does not explicitly name that sibling as the counter-operation, keeping it from 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?

'quiescent workspace' plus 'Rejects active traces, symlinks and concurrent operations' effectively states preconditions for successful use. However it never names the alternative (import_workspace) or says what to do when the workspace is not quiescent, so routing guidance is implied rather than explicit.

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

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

Annotations already carry readOnly/idempotent/non-destructive, so the description adds real value by disclosing that the call starts no external processes or apps (i.e., it is cheap and side-effect free) and by warning that 'installation checks are not device acceptance'. It does not describe output shape or failure modes, keeping it out of 5 territory.

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

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

Two short sentences, front-loaded with the action and scope, with the second sentence supplying a non-obvious caveat. No filler.

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

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

With no parameters, no output schema, and complete annotations, the definition supplies what an agent needs to decide to call it. The gap is that 'configuration and provider capabilities' remains abstract and the term 'REA' is never grounded, so the agent cannot anticipate what the response contains.

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 and 100% schema coverage, so there is nothing for the description to compensate for; baseline of 4 applies.

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

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

The description names a specific verb ('Read') and resource ('Android REA configuration and provider capabilities'), and bounds the scope by listing what it does NOT start (Java, Python, Ghidra, ADB, app). It stops short of 5 because 'REA' is unexplained jargon and it never distinguishes itself from the very similar sibling runtime_status.

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

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

The 'without starting...' clause implies the use case (a cheap pre-flight/config check before launching heavier tooling), but no alternative is named and no explicit when-to-use / when-not-to-use condition is given. The closing caveat steers interpretation of results rather than tool selection.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description adds real context beyond them: results are ordered by host receipt time, paging applies, and cross-process Binder entries are candidates rather than causal proof. It stops short of explaining the retention window or what merging does with unregistered traces.

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

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

Two sentences, both earning their place: the first states operation, ordering, and paging; the second is a meaningful epistemic caveat. Slightly dense with domain jargon 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?

No output schema exists, so the description should say more about the shape of the merged result (entry types, fields, ordering guarantees across sources) and what 'retained' means. As written an agent knows how to call it but not what it will get back beyond 'a paginated timeline'.

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 only 25% — only analysis_project_id is documented. The description's sole nod to parameters is 'with pagination', which adds nothing about limit/offset semantics, defaults, or page size, and it never clarifies what run_id accepts or how it relates to the Frida trace files being merged.

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

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

Names a specific operation (merging retained run events with explicitly registered Frida trace files), the ordering key (host receipt time), and the pagination behavior. This is distinguishable from siblings such as get_trace_events (raw trace events) and read_analysis_run (run metadata), though the jargon 'retained run events' is not defined and 'merge' could mean producing a view vs. mutating stored 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?

Use is only implied: an agent can infer this is the tool for a combined chronological view of a run's events plus registered traces. It never states when to prefer it over get_trace_events, inspect_trace, or read_analysis_run, nor any prerequisites (e.g. that Frida trace files must already be registered).

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety bar is low. The description adds genuinely non-obvious caveats: results may be truncated, coverage limits apply, and module RVA is not a file offset — a real correctness trap for the caller.

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

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

Three short sentences, front-loaded with the core action, followed by return categories and then caveats. No filler, though the phrase 'Preserve truncation and coverage limits' is terse enough to be slightly ambiguous.

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

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

With no output schema, the description must describe return values itself, and it partially does by listing event kinds and warning about truncation. It omits ordering, how to detect the end of the result set, and any error behavior, which an agent paging through results would want.

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 only 25%: trace_id, limit and cursor are undocumented in the schema. The description says 'Page,' which loosely implies integer cursor/limit paging, but it never explains the cap of 200, how the integer cursor advances, or what trace_id must reference — a notable gap given the low coverage.

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

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

States a specific verb and resource: 'Page retained events from this connection's Frida trace,' and even enumerates the event categories returned (Java/native calls, JNI bindings, UI markers, diagnostics). It is clear what the tool does, but it never names how it differs from the closely related inspect_trace sibling, 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?

There is no explicit when-to-use, when-not-to-use, or alternative routing guidance. With siblings like inspect_trace, start_trace, mark_trace, and stop_trace in the set, the agent gets no signal about which one to pick for which temporal phase of a trace session; only the word 'retained' hints at post-capture retrieval.

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

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

Annotations already declare non-read-only, non-destructive, non-open-world, so the safety profile is covered; the description usefully adds the 512 MiB cap, the immutability rule ("source changes are rejected") and the no-execute guarantee. It does not clarify duplicate-import behavior, which is notable given idempotentHint=false alongside a content-addressed SHA-256 identity.

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 dense sentences: identity/scope first, then the negative guarantees and limits. No filler, and the most decision-relevant constraint (SHA-256 identity) is front-loaded.

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

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

Simple three-parameter tool with annotations present, so the barrier is modest, but with no output schema the description should say what the agent gets back (an artifact id/handle?) and what happens on re-import of an identical hash. Those gaps matter for chaining into binary_session/open_binary.

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 carry parameter meaning, and it only partially does: it explains what kind values mean (APK/DEX/ELF SO formats) and that path is a source file. It says nothing about the project_id format, path resolution rules, or whether path is host-side or device-side, leaving real ambiguity.

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 concrete verb (copy/import), a precise resource set (APK, DEX, ELF SO) and a destination (into a project), plus the key identity rule (SHA-256). It is clearly distinguishable from transfer siblings like pull_adb_package or push_adb_file, which move bytes to/from a device rather than into a project's content-addressed store.

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?

"Does not install or execute it" implicitly steers the agent away from install_adb_package/start_adb_app for execution, but no alternative is named and there is no explicit when-to-use or when-not-to-use guidance. Usage is inferable rather than 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?

The annotations already declare destructiveHint=false and readOnlyHint=false, but the description adds useful specifics beyond them: it verifies every file and 'Never overwrites an existing workspace.' This clarifies the non-destructive behavior and the new-directory outcome, though it doesn't explain failure modes or permissions.

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

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

Three short sentences, front-loaded with the core action and followed by the key constraint and next step. No wasted words; each sentence adds distinct value.

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

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

For a simple two-parameter write tool with no output schema, the description covers purpose, key behavioral constraint (no overwrite), and post-call workflow. It leaves minor gaps around what 'verify' entails and how destination conflicts are handled, but overall it is sufficient 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 for both parameters. It implies source is the exported workspace and destination is the new directory, and later clarifies that directory serves as 'output_dir,' but it does not explicitly map parameter names or state expected formats (e.g., paths vs. identifiers), leaving some ambiguity.

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: 'Verify every file of an exported workspace and restore it into a new directory.' This clearly distinguishes the import operation from the sibling export_workspace, though it does not explicitly name the sibling or other related tools like import_artifact.

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

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

Usage is implied through the workflow instruction 'Use that directory as output_dir in a new connection' and the non-overwrite guarantee, but there is no explicit statement of when to choose this tool over alternatives or any exclusions. The agent can infer it is for restoring an exported workspace, but the guidance is not fully 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?

Annotations already declare idempotentHint=true and destructiveHint=false, and the description adds genuinely non-obvious behavior: it never contacts devices, never starts the adb server, and never installs platform tools. That is exactly the kind of side-effect disclosure an agent needs before invoking a process-spawning tool. It stops short of saying what happens on failure (e.g. no adb found) or why readOnlyHint is false despite being an inspection.

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

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

Three short sentences, front-loaded with what is inspected and immediately followed by the behavioral constraints. No filler, no restating of the tool name.

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

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

With no output schema, the description usefully enumerates the returned fields (resolved binary, version, install path) and the configuration mechanism that determines them. Only minor gaps remain, such as the failure mode when no adb binary is resolvable.

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?

There is a single optional parameter with 100% schema description coverage, so the schema already documents analysis_project_id and its caveats. The description adds nothing about that parameter, which is acceptable at full coverage but leaves the baseline of 3.

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

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

The description names a specific verb (inspect) and a specific resource (the caller-selected adb client) and enumerates exactly what is resolved: binary, version, install path. It is clearly distinguishable from device-facing siblings such as list_adb_devices or inspect_adb_device, since it explicitly operates on the client tooling rather than a device.

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

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

It establishes the usage context precisely by ruling out device interaction and server startup, which implicitly routes device work to the adb device tools. It also explains how the inspected binary is selected (REA_ADB_PATH absolute, or adb on PATH). What it lacks is an explicit named alternative (e.g. 'use inspect_apktool_client for apktool') or an explicit when-not statement.

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?

Clarifies the read surface is a fixed getprop whitelist and explicitly says it is read-only with respect to the device, which usefully explains why readOnlyHint is false (the result can be retained in a project). It adds the emulator indicator detail but says nothing about failure modes for unauthorized/offline devices.

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

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

One front-loaded sentence with the key scope fixed whitelist up front; every clause (versions, patch, ABIs, qemu indicator, read-only) carries information. Slightly dense but not padded.

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

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

With no output schema, the enumeration of returned properties is doing necessary work and is present. The device-state prerequisites (device must be authorized/online) and what happens if the device is offline are the only 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 100% and both parameters are documented there, so the baseline of 3 applies. The description adds context about what the whitelist reads but gives no extra syntax or constraint detail for serial or analysis_project_id.

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

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

Specific verb (inspect) plus a precisely scoped resource (one device's build identity via a fixed getprop whitelist), and it enumerates the properties returned. This clearly separates it from list_adb_devices (enumeration) and inspect_adb_package (package-level inspection).

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 'one device' framing implies you need a serial already, but it never states when to reach for this instead of list_adb_devices, list_adb_features, or collect_adb_bugreport. Usage is inferable from the sibling set rather than 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?

The description explicitly says 'Read-only; setting values is not exposed,' but the annotations declare readOnlyHint=false. This is a direct contradiction about a core behavioral trait. The annotations also mark openWorldHint=true while the description implies a constrained device-local read, but the read-only contradiction alone is decisive.

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

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

The description is two compact sentences, front-loads what the tool reports, and ends with a relevant read-only boundary. Every sentence contributes without redundant restatement of the name or schema.

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

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

For a simple two-parameter inspection tool with full schema coverage and no output schema, the description communicates the core result: physical and overridden size and density. It does not describe output formatting, units, or multi-display behavior, but it is largely complete for the tool's scope.

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

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

Schema description coverage is 100%, so both parameters (serial and analysis_project_id) are fully documented in the schema. The description adds no parameter-specific meaning, so the baseline of 3 is appropriate when the schema carries parameter documentation.

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: it reports the display's physical and overridden size and density as declared by the device. This is clear without opening the schema. It does not explicitly differentiate itself from related sibling tools such as inspect_adb_window or read_adb_setting, so it falls short of the highest clarity tier.

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 sentence 'Read-only; setting values is not exposed' gives an implied usage boundary: use this for reading, not changing display settings. However, it does not explicitly state when to prefer this tool over alternatives or name any alternative tools, leaving usage guidance at a minimum viable level.

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

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

The description ends with 'Read-only,' which directly contradicts the declared annotation readOnlyHint=false — the same semantic axis, opposite values. The other context it provides ('fixed projection of version-dependent output; unknown sections are ignored rather than guessed') is genuinely useful behavioral disclosure, but the explicit read-only claim conflicts with structured metadata and could mislead an agent about whether the call mutates state.

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

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

Three short sentences, front-loaded with the verb and resource, then the projection caveat, then the safety note. No filler, no restatement of the tool name, and the field enumeration earns its length by substituting for a missing output schema.

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

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

There is no output schema, but the description compensates by listing the returned fields and by explaining that the projection is fixed and unknown sections are skipped — exactly the caveat an agent needs when parsing version-dependent dumpsys output. What's missing is any note on failure modes (package not installed, offline device) or result size, and the read-only claim is inconsistent rather than clarifying.

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

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

Schema description coverage is 100%, so all three parameters (serial, package, optional analysis_project_id) are already documented with patterns and semantics in the schema. The description adds nothing about parameter format, package-name syntax, or what retaining a result in an analysis project implies. Baseline 3 applies when the schema carries the burden.

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

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

Specific verb ('Inspect') plus a bounded resource ('one installed package') and an explicit mechanism ('dumpsys package'). It also enumerates the exact fields returned (version name/code, install/update times, installer, user id, flags, permission count), so the agent knows the payload shape. It never names the sibling it is *not* (list_adb_packages, pull_adb_package, inspect_android_package), leaving that distinction to 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?

The phrase 'Inspect one installed package' implies the unit of work and rules out bulk listing only by implication. There is no explicit when-to-use, no statement of prerequisites (device connectivity, package must be installed), and no pointer to list_adb_packages for discovery before inspecting or pull_adb_package when the artifact itself is needed.

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

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

The description declares the tool 'Read-only,' while the annotations set readOnlyHint=false. An agent reading both signals receives conflicting guidance about whether calling this mutates device state. The dumpsys framing is informative ('without any interaction'), but the direct conflict with the structured annotation is disqualifying under the rubric.

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 tightly packed sentence, front-loaded with the verb and resource, followed by the mechanism and the read-only claim. No filler text.

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

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

For a two-parameter snapshot tool with no output schema, the description says enough: what is read, from which dumpsys target, and that no interaction occurs. It stops short of describing the returned shape, but the enumerated field names largely cover that.

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

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

Schema description coverage is 100%, so both the required 'serial' and the optional 'analysis_project_id' are fully documented in the schema with patterns and semantics. The description adds no parameter-level detail, which is acceptable given the schema already carries that load, but nothing is gained either.

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 ('Report') plus a precisely scoped resource: the window manager's focus declarations, naming the exact dumpsys fields (mCurrentFocus, mFocusedApp). It is clearly separable from siblings like capture_adb_screen or inspect_adb_display, which produce pixels rather than focus state.

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 clause 'what is on screen at read time without any interaction' implies this is the non-invasive alternative to capture_adb_screen, but no sibling is named and there are no explicit when-not conditions. Usage must be inferred rather than read.

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

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

Annotations already declare the safety profile (destructiveHint=false, idempotentHint=true, openWorldHint=true, readOnlyHint=false). The description adds context beyond that: no source is generated, output is display signatures plus explicit unknown DEX descriptor markers, and overload indices are stable within an artifact and engine session. It does not explain why readOnlyHint is false (presumably result retention or session state), which leaves a small 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?

Three dense sentences, front-loaded with the core action and scope before the output and session-consistency notes. No filler, though 'Overload indices remain consistent within the artifact and engine session' is jargon-heavy and could be tightened.

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

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

With no output schema, the description must describe returns and it does: display signatures plus explicit unknown DEX descriptors, and no source emission. It does not address output size or truncation for very large classes, nor the retention semantics of analysis_project_id, but the essentials for correct invocation are present.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema, and the description adds only the 'exact class' matching constraint. It says nothing about how analysis_project_id changes behavior (result retention), so it does not meaningfully exceed the structured baseline.

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 ('Inspect') plus a tightly scoped resource ('one exact Android class's parsed methods, fields and inner classes'). The phrase 'one exact' implicitly separates it from search_android_classes and from inspect_android_method, but neither sibling is named, so the differentiation 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 word 'exact' signals that a fully qualified class name is required, and 'including synthetic members' hints at a completeness-oriented deep-dive. There is no explicit statement of when to use this instead of search_android_classes (discovery) or inspect_android_method (drill-down), and no prerequisites such as first importing the artifact.

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

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

Beyond annotations, it discloses that smali is a fallback representation, that output carries representation/fallback markers and truncation flags, and that display signatures are not exact DEX identities — meaningful caveats an agent needs to interpret results. Annotations already cover side-effect profile (destructive=false, idempotent=true), so this added context is the right kind of contribution.

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

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

Three tight sentences, front-loaded with what it does, then the required disambiguation rule, then output caveats. Slightly dense jargon ('representation', 'display signatures') but no filler sentences.

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 five-parameter tool with no output schema, the description covers the action, the disambiguation requirement, and what the response reports (representation, fallback markers, truncation). Minor gap: it does not explain when smali fallback triggers or what the analysis_project_id retention implies.

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

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

Schema coverage is 80%, so baseline is 3; the description adds real meaning by explaining the ambiguity condition that makes overload_index mandatory and by warning that display signatures should not be treated as exact DEX identities, which affects how class_name/method_name should be supplied.

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 and resource are precise: decompile exactly one Android method, with a named fallback (smali). Scope ('one method') implicitly separates it from class-level siblings like inspect_android_class or search_android_classes, but no sibling is named explicitly, so it stops short of 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?

One genuine conditional rule is given ('Requires explicit overload_index when multiple methods share a name'), which tells the agent how to disambiguate. However there is no guidance on when to choose this over inspect_android_class, inspect_android_package, or the native/procedure tools, so usage is only implied.

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

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

Adds substantial context beyond the annotations: caller must supply a JADX MCP JAR and a JDK, processing runs with one worker in an isolated temporary workspace, and the target is never executed. These are real operational constraints (prerequisites, concurrency, sandboxing) that annotations like readOnlyHint=false and openWorldHint=true do not convey. It could still say more about output volume or failure modes for large APKs.

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

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

Three dense sentences: purpose and outputs first, then exclusions, then prerequisites. Every clause carries information an agent would otherwise have to guess, and there is no filler.

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

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

With no output schema, the description compensates by enumerating the returned artifacts (manifest contents, permission set, class/resource counts), which is what an agent needs to plan a call. It does not mention rough runtime cost or behavior on malformed/obfuscated APKs, leaving a small gap for a tool that shells out to JADX.

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

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

Schema description coverage is 100%, so both parameters are already documented, including the regex for analysis_project_id and the 'never executed' note on path. The description reinforces 'local APK' but adds no format or syntax detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (inspect) and resource (local APK) and enumerates exactly what is extracted: package, SDK, permission declarations, decoded manifest, class/resource counts. The word 'local' plus the explicit non-goals ('does not execute the APK or verify signatures') separates it from device-side siblings like inspect_adb_package and from decode_android_resources.

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 establishes the context of use (a local APK on disk) and rules out two plausible but wrong expectations: execution and signature verification. It stops short of naming a specific alternative sibling or stating a when-not-to-use condition beyond those exclusions, so it is clear but not fully routing.

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

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

Annotations already declare openWorldHint=true, idempotentHint=true and destructiveHint=false, so the safety surface is partly covered, yet the description still adds meaningful behavior: it decodes nothing and never installs Apktool or Java, and it names the exact env/PATH resolution order. Minor gap: it does not say what happens when no launcher resolves.

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

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

Three short sentences, capability stated first, the negative constraint second, the environment prerequisite last. No restated title, no filler, nothing to trim.

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

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

With no output schema, the description compensates by naming the three things returned (resolved command, selection source, version). All parameters are optional and documented in schema, so remaining gaps — failure behavior when no launcher exists, and the meaning of the readOnlyHint=false annotation on an inspection tool — are comparatively minor.

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

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

Only one optional parameter with 100% schema description coverage, and the schema already explains that analysis_project_id merely retains the result in an investigation. The description adds no parameter detail, which is acceptable at full schema coverage but is the 3 baseline.

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 ("Inspect the caller-selected apktool launcher") and enumerates the return content: resolved command, selection source, version. The clause "Decodes nothing" separates it from the decode/inspect_android_package siblings that actually process binaries, though no sibling is named explicitly.

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

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

The description explains the selection mechanism (REA_APKTOOL_COMMAND absolute path or apktool on PATH), which implies the tool is a pre-flight check before decoding work, but never states "use this when X" or names an alternative such as decode_android_resources for actual decoding. Usage is inferable, not instructed.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the safety profile is partly covered. However, the description does not explain why a tool named "inspect" is not read-only, what side effects may occur, or what the result looks like; it adds only the name/address input modality.

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 wasted words. It is efficient, though its brevity contributes to gaps that other dimensions capture.

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 inspection tool with no output schema and low schema description coverage, the definition is under-specified. It lacks usage context, return behavior, and parameter details needed for reliable invocation among many similar tools.

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

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

Schema description coverage is only 25%, with just analysis_project_id documented in the schema. The description partially explains type and address as "exact name or ELF address," but leaves document, the optionality of all parameters, and the relationship among parameters unexplained, so it does not compensate for the low coverage.

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

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

States a specific verb ("Inspect") and resource ("Ghidra data type"), plus the selection method ("exact name or ELF address"). It is clear what the tool does, though it does not explicitly distinguish itself from sibling inspection tools such as inspect_native_instruction or inspect_native_load_image.

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 on when to use this tool versus the many sibling inspection tools, no prerequisites, and no exclusions. It only implies that the caller should provide an exact type name or an ELF address.

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

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

Annotations already declare idempotent=true, non-destructive, closed-world, and (notably) readOnlyHint=false, so the description adds no safety context. It does not explain what is returned (decoded instruction? raw bytes? operand details?), whether a binary must be opened first, or why the tool is not marked read-only despite the word 'inspect' (possibly due to analysis_project_id retention).

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. The brevity is a virtue in structure but contributes to the under-specification penalized in other dimensions.

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 3-parameter tool with no output schema and low schema coverage, the description omits essentials: address syntax (hex vs module:offset), what 'document' means, the relationship to an open binary, and the shape of the inspection result. An agent has too little to call this correctly without trial and error.

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 only 33%: only analysis_project_id is documented. The 'address' parameter's regex allows hex or module:offset forms and 'document' is a bare string, but the description explains neither format nor what 'document' selects. With low coverage, the description fails to compensate for the undocumented 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 one-sentence description gives a specific verb ('Inspect') and resource ('native instruction') plus a scope qualifier ('at an ELF address'), so the basic action is identifiable. However, it does not distinguish this from close siblings such as procedure_assembly, read_function_instructions, read_bytes, or inspect_native_data_type, leaving overlap unresolved.

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 many instruction/binary-reading siblings, nor on prerequisites such as an opened binary session or a resolved address. The agent must infer usage entirely from the name and the required 'address' parameter.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false; the description adds nothing about what 'active' means, whether an image must first be loaded via open_binary, or what happens when no image exists. There is also mild tension: the verb 'Inspect' reads as a pure read while readOnlyHint=false, and the description offers no clarification of what side effect (image loading?) justifies that flag.

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 at the cost of the behavioral and usage detail the tool actually needs.

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?

Placeholder.

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

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

Schema coverage is 100%, so the single optional analysis_project_id is fully documented in the schema, including its retention caveat. The description adds no parameter meaning beyond that, which is acceptable at this coverage level but nothing more.

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 ('Inspect') and a specific resource ('the active ELF load image, mapped segments and sections'), which is more informative than the bare tool name. It does not, however, differentiate itself from siblings such as list_segments, which plausibly covers overlapping territory.

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

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

No guidance on when to use this versus list_segments or inspect_native_instruction, and no preconditions stated (e.g. that a binary session must be open and an image loaded). The agent must infer the usage context entirely.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds real value beyond that by disclosing what is returned and the caveat that 'returned artifact paths resolve in the current workspace' — a non-obvious resolution rule. It stops short of covering failure modes (missing project) or result size.

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

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

Two sentences, no filler, with the core action front-loaded and the path-resolution caveat placed second where it reads as a qualifier. Nothing is wasted, though the second sentence could be tightened slightly.

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

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

With no output schema, the description does carry some of the return-value burden by naming the three result categories, and the workspace-resolution note is a genuine completeness win. However, for a read tool returning a nested investigation record, it omits structure, ordering, and what happens when the id is unknown.

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%: the single parameter carries only a regex pattern and length bounds, with no prose explaining that project_id is the identifier produced by create_project. The description never mentions the parameter, so an agent gets no help on where the id originates or whether it accepts other formats.

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

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

States a specific verb ('Read') and a specific resource ('one persistent investigation'), then enumerates what comes back: artifact identities, evidence references, analyst findings. This clearly separates it from write-side siblings like create_project and import_artifact, though it never names a sibling explicitly.

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

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

There is no statement of when to call this versus create_project, list_evidence, or read_evidence; the only hint is the word 'one', implying single-project lookup by id. No prerequisites, no exclusions, no alternative routing are given.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower. The description adds a genuinely useful interpretive constraint — 'Absence of events does not establish absence of execution' — which prevents an agent from over-reading empty results. It says nothing about how pagination interacts with that coverage claim, costing it the top score.

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

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

Two tight sentences with no filler, and the core action is front-loaded. The only weakness is the compressed jargon in the second clause, which reads as terse rather than clear.

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

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

For a read-only inspection tool with four parameters and no output schema, the description is adequate but thin: it never explains what a 'trace summary' contains, what 'hook coverage' means, or how paged results relate to the aggregate summary. An agent knows the general shape but not what to expect back.

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 only 25%, so the description must compensate but largely doesn't. It implies paging via 'paged hook coverage','but doesn't say what limit/offset page over, and adds no detail on trace_id format or analysis_project_id retention behavior beyond the schema's own text.

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 ('Inspect one trace summary') plus the content it returns (hook coverage, installed/pending/failed states, overload/loader identities). This distinguishes it from data-fetching siblings like get_trace_events, though the dense noun stacking ('concrete overload/loader identities') makes the resource somewhat hard to parse.

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: pick a trace_id and inspect it. No explicit when-to-use versus get_trace_events or list_evidence, and no prerequisites or exclusions beyond the epistemic caveat. The caveat about absence of events is a caution, not routing guidance.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the description's job is to add context — and it does: the device is mutated, `replace` preserves app data, the tool records the host digest and byte size, and the device's own Success/Failure verdict with reason is passed through. It stops short of saying what happens when `replace` is false and the package already exists (fail vs. overwrite), which is the one behavior an agent still has to guess.

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 dense sentences: what it does and the adb equivalent first, then mutation semantics and output behavior. Nothing is repeated from the annotations and no sentence is filler.

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

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

With no output schema, the description usefully covers what comes back (device verdict plus reason, digest, byte size) and what gets mutated. The missing piece is preconditions — device reachability and the failure mode when `replace` is false against an existing package — leaving a small but real gap for a destructive tool.

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

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

Schema description coverage is 100%, including the `replace` semantics, so the schema carries the parameter meanings. The description reinforces the `replace` behavior and the 'local APK' constraint on apk_path but adds no format, resolution, or validation detail beyond the structured fields — baseline 3 is appropriate.

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

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

States a specific verb and resource ('Install one local APK on the device') plus the underlying adb command, and the 'one local APK' scoping separates it from pull_adb_package, push_adb_file, and uninstall_adb_package. An agent can pick this out from the many adb siblings without opening the schema.

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

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

The description gives clear context: local APK only, single package, and it explains when `replace` applies (re-installing over an existing package while keeping its data). It does not explicitly say when to prefer push_adb_file or what to do if the APK is not on the host, but the usage context is otherwise unambiguous.

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

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

Adds real value beyond annotations: it discloses that REA neither starts nor manages emulators (scope limitation) and that the first call may start the local adb server — which usefully explains why readOnlyHint is false for a 'list' tool. Returned-field shape is also disclosed. Minor gap: no mention of failure behavior if no devices are attached or the adb server cannot start.

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

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

Three sentences, front-loaded with the core identification ('adb devices -l' parity) before scope and side-effect caveats. No filler and no repetition of what the schema or annotations already state.

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

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

There is no output schema, and the description compensates by enumerating the fields returned, so an agent knows what to expect. Combined with the scope and adb-server side-effect notes, it is nearly complete; only error/empty-state behavior is unaddressed.

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

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

Schema description coverage is 100% for the single optional analysis_project_id, so the schema already carries the parameter meaning. The description says nothing about that parameter or its retention semantics, so the baseline 3 applies rather than a higher score.

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

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

States a specific verb and resource ('List attached devices exactly as `adb devices -l` reports them') and even enumerates the returned fields (serial, state, transport, model metadata, inferred kind), which is far beyond a tautology. It implicitly separates from the sibling inspect_adb_device (single-device deep dive) but never names it, so sibling differentiation is left to inference.

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

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

The description establishes context — it lists whatever is attached, emulators and USB/network alike — which implies when to call it. However, it never states when to prefer it over inspect_adb_device or inspect_adb_client, nor any preconditions such as a reachable adb server beyond the note that one may be started.

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

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

The description explicitly states 'Read-only', but annotations set readOnlyHint=false. This is a direct contradiction and is flagged. While the error handling note adds some context, the contradiction on the core safety profile is severe.

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 waste. It states the action, the output fields, and error behavior without burying the lede.

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

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

No output schema exists, but the description lists the returned fields and notes standard error recognition, which covers the essentials. However, the contradictory read-only claim undermines completeness for a tool whose annotations say otherwise.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description reinforces that device_path must be absolute and that serial is required, but adds no new semantic detail beyond the schema.

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

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

States a specific verb and resource ('List one absolute device directory') and enumerates the exact fields returned (names, kinds, permissions, owner, group, sizes, dates, symlink targets). This is distinguishable from sibling tools like list_adb_devices or inspect_adb_device, which operate on devices rather than a directory.

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 does not say when to use this tool versus alternatives such as inspect_adb_device or read_adb_logcat, nor does it give prerequisites beyond the implicit 'absolute device directory'. It provides no exclusions or routing guidance.

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

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

The description asserts 'Read-only' while the annotations declare readOnlyHint=false, which directly conflicts with the structured safety signal an agent relies on to decide whether a write may occur. No other behavioral context (permissions, side effects, scope) is provided to resolve the ambiguity.

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, front-loaded sentences with the core action first and the read-only claim second. Nothing redundant or padded.

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

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

For a simple two-parameter list tool with complete schema coverage and no output schema, the description covers purpose but skips any indication of return shape or what identity assumptions the fingerprint data carries. Adequate but with clear gaps, and the read-only/mutation ambiguity hurts completeness.

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

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

Schema description coverage is 100%, so the serial format and the analysis_project_id retention semantics are already fully documented in the schema. The description adds nothing about either parameter, so the baseline 3 applies.

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

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

The description names a specific verb and resource ('List the device's declared hardware and software features') and grounds it in a concrete ADB command (`pm list features`), so the agent knows exactly what is returned. It does not distinguish this from adjacent ADB siblings such as inspect_adb_device or list_adb_packages, which keeps it out of the top band.

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

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

It gives a purpose context ('for device fingerprinting'), which implies when the tool is worth calling, but there is no explicit when-not guidance and no named alternative for overlapping device-introspection needs.

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

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

The annotations declare readOnlyHint=false, but the description explicitly ends with 'Read-only.' This is a direct contradiction that could mislead an agent about whether the call mutates state. Beyond that conflict, the description 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?

Two tight sentences with the operation and scope front-loaded and the device-path caveat given prominence. Nothing extraneous.

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

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

With no output schema, the description usefully explains the return shape (per-base-APK device paths) and clarifies they are device-side paths. The only gap is the contradictory read-only claim, which undermines completeness of the behavioral picture.

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

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

Schema coverage is 100%, so serial, scope enum, and analysis_project_id are already fully documented. The description reinforces the scope concept but adds no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb+resource ('List installed packages') and adds scope ('one device', 'each base APK's device path'), which an agent can act on. It does not explicitly distinguish itself from sibling resolve_adb_packages or inspect_adb_package, leaving the agent to infer the difference.

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

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

The word 'optionally scoped' and the note that paths are 'device filesystem paths, not host-local' imply when the tool is useful, but there is no explicit when-to-use versus resolve_adb_packages or inspect_adb_package, and no prerequisites beyond the required serial.

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

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

The description asserts 'Read-only' while annotations declare readOnlyHint=false, a direct contradiction of the structured safety signal. Beyond that, it adds no behavioral context such as permission requirements, performance cost, or whether the listing is a point-in-time snapshot.

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, with the core behavior and field list front-loaded. The trailing 'Read-only.' is minimal but is also the source of the annotation conflict, and 'pairing with instrumentation lanes' is vague filler.

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

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

With no output schema, the field enumeration is a genuine plus, and the schema fully covers the two parameters. However, the description never reconciles its read-only claim with the annotations, and gives no indication that a device serial is required to scope the call.

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

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

Schema description coverage is 100%, so both `serial` and `analysis_project_id` are already documented, including the pattern and the caveat about not proving target identity. The description adds nothing about parameters, so baseline 3 applies.

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

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

States a specific verb and resource ('List running processes') and anchors it with the `ps -A` equivalence, then enumerates the returned fields. It implicitly distinguishes itself from siblings like list_adb_devices and list_adb_packages by naming processes, though it doesn't call out 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?

'Useful for pairing with instrumentation lanes' is a hint at context but not a real when-to-use rule. No exclusions, no prerequisites (e.g. device must be connected), and no named alternative for related queries.

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

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

The description asserts 'Read-only', but the annotations declare readOnlyHint=false, a direct and material inconsistency about whether the call can mutate state. It also says nothing about the openWorldHint=true behavior or what happens for an offline/unauthorized device, leaving the behavioral profile actively misleading.

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

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

Two tight sentences, front-loading what is enumerated and following with the shell equivalent. Nothing extraneous, nothing buried.

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

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

For a two-parameter, non-destructive list tool with full schema coverage and no output schema, the description conveys enough about the return shape ('with their interfaces') to call it correctly. The missing piece is the read-only claim conflicting with annotations rather than absent volume.

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%, with both `serial` and `analysis_project_id` fully documented in-schema, so the baseline of 3 applies. The description adds no additional meaning about parameter format or effect.

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

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

States a specific verb and resource ('List the device's binder services with their interfaces') and anchors it to the underlying adb command (`service list`), so the agent knows exactly what the call does. Against siblings like list_adb_features, list_adb_packages, and list_adb_processes, the binder-service domain is unmistakable.

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

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

The description never says when to reach for this versus neighboring list_adb_* tools, nor does it state prerequisites such as requiring a connected device. Beyond the parenthetical shell equivalent, the agent must infer the usage context entirely.

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

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

The annotations already cover idempotence, openness, and destructiveness, so the description's burden is lower, but it adds nothing about whether listing triggers side effects or returns empty results. Notably the annotations say readOnlyHint=false while "List" implies a pure read — the description does not explain this tension (e.g. that results are retained in an investigation).

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 waste or filler. It is efficient, though its brevity comes at the cost of not defining the resource.

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

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

With no output schema and an undefined resource noun, the description leaves the agent unsure what a returned document is or how to interpret results. For a tool in a crowded listing family, this is incomplete despite the simple one-parameter schema.

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

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

Schema description coverage is 100% and the single optional parameter analysis_project_id is fully documented in the schema, so baseline 3 applies. The description adds no extra meaning about the parameter or about default behavior when it is omitted.

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

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

States a verb (List) and a resource (documents) and scopes it to the current Ghidra ELF session, which is more than the name alone provides. However, "documents" is never defined, so an agent cannot tell whether these are analysis reports, notes, findings, or binary artifacts, nor how they differ from siblings like list_evidence or list_names.

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, when not to, or which sibling to prefer. With dozens of listing siblings (list_names, list_procedures, list_segments, list_evidence), the absence of any routing hint leaves the agent to guess.

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

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

Annotations already establish read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful context that results are bounded/retained metadata and that the tool performs no analysis or device contact. It does not explain pagination behavior, retention limits, or what the metadata records contain.

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

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

The description is two compact clauses with the core action front-loaded. Every phrase adds information or a constraint, with no filler or redundant restatement of the name.

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 read-only list tool with rich safety annotations, the description is adequate at a high level. However, with no output schema and zero schema description coverage, it leaves important details missing: what metadata fields are returned, how limit/offset behave, and what 'bounded retained' means in practice.

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 carry parameter meaning, but it only loosely covers two filters: 'investigation' for project_id and 'exact operation' for operation. It does not explain limit, offset, pagination bounds, or defaults. The mapping from 'investigation' to project_id is also not explicit.

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 and resource: list retained tool-result metadata. It also clarifies that this is metadata-only, with no analysis or device contact, which meaningfully separates it from content-reading siblings like read_evidence. It does not explicitly name or compare against the closest sibling, so it stops short of 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?

The description says filters are optional and rules out analysis/device contact, but it does not state when an agent should choose this tool over read_evidence or other list tools. There is no positive usage context or alternative-selection guidance, leaving the agent to infer the scenario.

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

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

The description contributes the scoping fact that it operates against the currently active ELF analysis, which annotations do not convey. It does not disclose result size, ordering, pagination, or what happens with the address/document filters, and there is mild tension between the read-flavored verb "List" and readOnlyHint=false — though that is a property of the annotations rather than a contradictory claim in the text.

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

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

A single front-loaded sentence with zero filler. It is efficient, but the brevity is the same brevity that leaves the filters and usage unaddressed, so it is concise without being quite well-proportioned to the tool's actual complexity.

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

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

Three optional parameters, no output schema, and no annotation detail on returns, yet the description never explains what a symbol name record looks like, whether results are paginated, or how address/document narrow the listing. For a filtered enumeration tool the agent lacks the information needed to use 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 only 33% — just analysis_project_id is documented — and the description says nothing about any of the three parameters. The semantics of the address filter (pattern accepts hex or module+offset) and document scoping are entirely opaque from the text, leaving the agent to infer behavior from raw regex patterns.

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 (list) and resource (symbol names) scoped to "the active ELF analysis", which an agent can understand without opening the schema. However, it doesn't distinguish itself from adjacent siblings such as address_name, list_strings, or list_procedures, so the agent must guess which name-listing tool applies.

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 when-to-use or when-not-to-use guidance, no mention of prerequisites (e.g., an open binary session), and no named alternative for the overlapping address_name / list_procedures tools. The only contextual cue is the phrase "active ELF analysis", which implies a session must already exist.

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

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

Annotations declare destructiveHint=false and idempotentHint=true, so the safety profile is largely covered; the description adds the session prerequisite. However, readOnlyHint=false is unexplained — the description frames this as a pure read, while the schema's analysis_project_id reveals a retention side effect that the description never mentions. With no output schema, nothing is said about the shape of results.

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, zero waste, with the action stated first and the prerequisite immediately after. Nothing could be removed without losing information.

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

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

With no output schema, the description should indicate what a listed 'function' includes (name, address, size) and what the 'document' parameter does. The prerequisite is covered, but return content and one parameter remain opaque, leaving the definition minimally viable for a two-parameter listing 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 only 50%: analysis_project_id is documented in the schema, but 'document' has no description anywhere. The description says nothing about either parameter, so the undocumented one is left entirely to guesswork — it does not compensate for the coverage 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+resource ('List functions') and ties it to the 'active ELF analysis' scope, which is more than a restatement of the name. It does not distinguish itself from near-siblings like search_procedures or list_names, and it silently swaps terminology ('functions' vs 'procedures'), so an agent must infer they are the same entity.

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?

'Open the .so with open_binary first' gives an explicit prerequisite and implies the session must already have an active binary. It never says when to prefer this over search_procedures (e.g. unfiltered enumeration vs. lookup), so alternatives remain unaddressed.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered; the description's 'does not attach to or execute' adds specificity about the boundary of the read. It says nothing about preconditions (must the target device be online, is frida-server required) or about latency/failure modes for an openWorldHint tool that reaches a live device.

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, zero filler, with the core action front-loaded and the negative boundary statement placed after it. Every sentence carries information an agent needs.

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

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

For a two-parameter read with no output schema, the definition covers what the tool does, its scope, and its non-goal, which is nearly enough to invoke it correctly. The remaining gap is that the shape of the result (PID list, app identifiers, empty-result behavior) is only implied by 'choose an exact PID or app' rather than described.

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 50%: analysis_project_id is documented in-schema, but device_id has no description at all. The description's 'on one explicit device' hints that device_id must be a concrete identifier rather than a wildcard, which is useful, but it does not supply format, accepted values, or where such an ID comes from.

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

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

States a specific verb and resource ('List Frida process/application targets') plus a scope qualifier ('on one explicit device'), and names the downstream purpose ('choose an exact PID or app'). The 'Frida' qualifier implicitly separates it from the ADB-flavored siblings (list_adb_processes, list_adb_devices), though no sibling is named explicitly.

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

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

The phrase 'to choose an exact PID or app' gives a clear use condition (enumeration prior to targeting), and 'This does not attach to or execute a target' rules out a misreading of its role. It stops short of naming an alternative for the adjacent case, e.g. when to use ADB-based process listing instead.

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

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

Annotations declare readOnlyHint=false even though the description's verb 'List' reads as a pure read, and the description never explains the non-read-only aspect (results can be retained into an analysis project) or what happens when no active analysis exists. With idempotentHint=true and destructiveHint=false already covered structurally, the description adds no behavioral context of its own.

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 waste, but the brevity comes from under-specification rather than efficiency. Nothing is redundant, yet almost nothing earns its place beyond naming the resource.

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

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

For a two-parameter listing tool with no output schema, the description is thin but not misleading; the main gaps are the undocumented 'document' parameter and the missing note about needing an active ELF analysis to exist first.

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 only 50%: 'document' has no schema description and the description says nothing about it, so it is undocumented in both places. The 'analysis_project_id' retention semantics are also unaddressed, and 'active' is not clarified as to whether it selects the document implicitly.

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

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

It gives a specific verb and resource ('List memory segments') scoped to 'the active ELF analysis', which distinguishes it from the many procedure/string/name listing siblings. There is no explicit sibling differentiation or explanation of what a 'segment' means here, but the object being listed is unambiguous.

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

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

The description gives no when-to-use guidance, no prerequisites (e.g. an open binary session or analysis run is presumably required), and no alternatives. An agent must infer from the phrase 'active ELF analysis' that a binary/analysis context must already exist.

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

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

Annotations declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=false, but the description never explains the surprising non-read-only flag or its likely cause (the analysis_project_id retention side effect). It discloses nothing about result volume, truncation, pagination, or ordering for what is inherently an unbounded listing.

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 or repetition. Its compactness reflects under-specification rather than tight editing, but nothing in the text wastes space.

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

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

For a zero-required-parameter, no-output-schema listing tool with two undocumented filters, the description should say what gets returned and how the optional filters narrow it. It leaves the agent unable to predict output shape or the effect of address/document, and does not reconcile the non-read-only annotation.

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 33%: only analysis_project_id is documented in the schema, while the address filter (hex or module:offset pattern) and document selector are undocumented. The description mentions no parameters at all, so it does not compensate for the gap or clarify whether address filters strings by location.

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 and resource ("List recognized strings") scoped to "the active ELF analysis", so the agent knows this is a bulk enumeration over the currently open binary. It never names the sibling search_strings, so the boundary between listing all strings and filtering them is left to inference.

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

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

There is no statement of when to choose this over search_strings, list_names, read_bytes, or xrefs, nor any prerequisite such as needing an open binary session. The phrase "active ELF analysis" only implicitly hints at a prior open_binary session.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior, so the bar is lower. The description still adds real value: it lists what the result reports (runtime address, module RVA, ELF VA, possible file offset) and warns that file identity is unverified unless a matching digest is supplied.

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

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

Four tight sentences with no filler, front-loading the core mapping action before the caveats. Well-structured and appropriately sized.

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

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

With annotations covering the safety profile and no output schema, the description usefully explains the returned fields and the identity caveat. The remaining gap is coverage of several input parameters, but overall it's complete enough to call correctly.

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

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

Schema description coverage is only 13%, so the description must compensate, and it only partially does. It clarifies page_size (required, target page size), the digest's role for identity, and the address concepts, but leaves module_base, runtime_address, ghidra_image_base, and normalize_thumb_pointer unexplained beyond their schemas.

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

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

States a specific verb ('map an observed module-relative address') and resource (an explicit local ELF's PT_LOAD segments), plus the follow-up context (REA/Ghidra). It doesn't explicitly contrast with the very similar sibling address_to_file_offset, so it falls short of 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?

'for REA/Ghidra follow-up' gives a situational hint and it states the page-size requirement, but it never says when to pick this over address_to_file_offset or address_name, nor when it's inapplicable.

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

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

The description adds a useful semantic caveat: the marker is a timing anchor and not evidence of app-side cause and effect. With annotations already declaring non-read-only, non-idempotent, open-world, and destructive behavior, the description does not need to restate safety hints, but it also does not explain the practical mutation or duplication implications.

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

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

The description is two compact sentences, front-loads the action, and immediately qualifies the marker's meaning. Every sentence adds useful information without repetition.

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

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

For a simple trace-marker tool with annotations and no output schema, the description explains purpose and an important caveat. It remains incomplete around when to choose it over sibling trace tools and what the optional project parameter is for.

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 only 33%, and the description helps by indicating that the label is caller-provided and that the trace must be active. It does not explain the optional analysis_project_id or add constraints beyond the schema for trace_id and label.

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 ('Record') and resource ('caller-labelled marker in an active trace'), so the core action is clear. It does not explicitly distinguish this tool from trace-related siblings such as get_trace_events, stop_trace, or inspect_trace.

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 an active trace' implies the tool should be used during an ongoing trace, which gives some usage context. However, it names no alternatives and does not explicitly say when to use this versus start_trace, stop_trace, or get_trace_events.

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

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

Annotations already declare destructiveHint=false and idempotentHint=true, so the description's real contribution is the copy-not-execute guarantee ('input is copied, never executed or modified') and the session lifecycle behavior ('replaces the active ELF session after closing it'), neither of which is derivable from annotations. It stops short of describing analysis cost, size limits, or what state the replaced session loses.

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

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

Three short sentences, front-loaded with the action and scope, followed by the safety guarantee and the session-lifecycle note. No filler, and each sentence carries distinct information.

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

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

For a session-creating tool with no output schema and fully described parameters, the description covers action, scope, safety, and side effects on existing state. The only gap is that it never indicates what the call yields (e.g., session identity) or that analysis may take time, which matters for a Ghidra import.

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

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

Schema coverage is 100% with only two parameters, so the schema already documents both 'path' and 'analysis_project_id'. The description only reinforces the 'one local file' constraint on path and adds nothing about the project-id parameter; baseline 3 applies.

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

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

States a specific verb and resource: open one local ELF executable or shared library (.so) into an isolated Ghidra session. The 'one local ELF' scope implicitly separates it from import_artifact and inspect_native_load_image, but no sibling is named 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?

Usage is implied by the phrase 'in an isolated Ghidra session', which tells the agent this is the entry point for ELF analysis, and the session-replacement sentence hints at the consequence of calling it. However, there is no explicit when-to-use versus import_artifact / binary_session / close_binary, and no stated prerequisites.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true; the description adds genuinely non-redundant behavior: automatic before/after UI capture, pre-input validation of every device/run binding, and the explicit caveat that markers are not causal. It still does not say what happens on partial failure or that tap_node depends on a prior snapshot for node_id validity.

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

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

Three dense sentences, front-loaded with the capability list before the tracing semantics. Nearly every clause carries information, though the 'Every device/run binding is checked before input' sentence is slightly cryptic without naming which bindings.

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 destructive, non-idempotent, 7-parameter input tool with no output schema, the description covers action kinds and tracing but omits the package targeting parameter entirely and does not indicate what the captured before/after UI returns or how to retrieve it (presumably an artifact id). That leaves an agent guessing on two call-critical points.

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

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

With only 14% schema description coverage across 7 parameters, the description must compensate, and it does partially: trace_id/trace_ids (max four) and run_id are explained semantically, and the action variants are listed. But 'serial', 'package' (the target-app binding, which materially changes behavior) and the snapshot_id/node_id provenance for tap_node are left unexplained, so meaningful gaps remain.

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

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

The description opens with a specific verb plus an exhaustive enumeration of the action kinds the single tool supports (explicit tap, validated snapshot-node tap, swipe, keyevent, ASCII text input, bounded wait), which maps directly onto the oneOf action schema. It distinguishes itself from siblings like capture_ui and read_ui_snapshot by being the mutation/input tool and noting it captures before/after UI itself.

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

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

It gives real guidance on trace_id/trace_ids/run_id (marking input across processes, retaining results) and warns that markers establish a time window, not causality. However, it offers no guidance on choosing between the action variants (e.g., when to prefer tap_node over a coordinate tap, or when a bounded wait is appropriate versus re-snapshotting), and no alternatives among siblings are named.

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

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

Annotations already declare openWorldHint=false, idempotentHint=true and destructiveHint=false, so the safety profile is largely covered. The description adds nothing beyond purpose: it doesn't note that this is a non-executing static lookup, whether the target binary must be open first, or what happens when the name/address is ambiguous or absent. Note the tension with readOnlyHint=false, which suggests a mutating operation while the description reads as a pure query.

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 tight sentence with no filler and the key operation front-loaded. It is efficient, though its terseness is part of why the parameter gaps remain unfilled.

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 3-parameter tool with one-third schema coverage and no output schema, the description is under-specified: it does not clarify the document parameter or accepted input forms, nor does it state the shape of the result beyond 'entry address'. The tool name/description alone leave real call-time uncertainty.

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 only 33%: only analysis_project_id carries a schema description. The description does not say whether 'procedure' takes a bare symbol name, a mangled name, a hex address, or which syntax is accepted, and it never explains the 'document' parameter (which binary/session to resolve against). With the majority of parameters undocumented in both places, the description should compensate and does not.

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 (resolve procedure name/address to entry address) and constrains the domain to ELF binaries. It is clear on its own, but does not distinguish itself from nearby siblings such as address_name (the inverse mapping), procedure_info, resolve_containing_procedure, or map_native_address, so an agent must guess at 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?

No when-to-use guidance, no prerequisites, and no named alternatives. The agent is not told whether to reach for this rather than address_name, procedure_info, or resolve_containing_procedure when it has a name and wants an address.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is largely covered. The description adds that the operation targets the 'active' analysis session, hinting at a prerequisite binary context, but does not explain why readOnlyHint=false for what sounds like a pure query, nor what happens if no session is active.

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 borders on under-specification rather than ideal conciseness.

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

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

With no output schema, an ambiguous name ('procedure_assembly' vs. 'disassemble'), 33% schema coverage, and no mention of the open-session prerequisite, the description leaves too much for the agent to infer for a 3-parameter tool with a crowded sibling set.

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 only 33% — only analysis_project_id is documented. The description's phrase 'one function' loosely maps to the required `procedure` parameter, but neither `procedure` (name? address? ID?) nor the `document` parameter is clarified, so the description does not compensate for the coverage 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 and resource: 'Disassemble one function in the active ELF analysis.' An agent knows it produces disassembly for a single procedure. However, it does not distinguish this from near-siblings like procedure_pseudo_code, read_function_instructions, or procedure_info, which all operate on the same object.

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 choose disassembly over pseudo-code, instruction reading, or function analysis. The only clue is 'active ELF analysis', which implies a prior open_binary/binary_session, but this is never stated as a prerequisite or as a condition for selection.

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

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

The annotations already state destructive=false, idempotent=true, and openWorld=false; the description adds the useful 'static' qualifier, meaning compile-time/direct callees rather than dynamic targets. However, it does not explain why readOnlyHint=false for a 'list' operation, presumably because results can be retained via analysis_project_id.

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 one-sentence description is front-loaded and contains no wasted words. Its terseness contributes to the contextual gaps rather than being verbose, but the sentence itself is efficiently structured.

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

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

For a three-parameter static-analysis query with no output schema, the definition is too sparse. It omits what 'document' identifies, what the returned callee list looks like, and whether results are direct/static only, leaving the agent to infer important call behavior.

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

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

With only 33% schema description coverage, the description should compensate, but it only weakly implies that 'procedure' is an ELF function name. It says nothing about the 'document' parameter or when to supply analysis_project_id beyond what the schema already documents.

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 clear verb and resource: list static callees of an ELF function. The word 'callees' inherently distinguishes it from the sibling procedure_callers, though it does not explicitly name alternatives or qualify the 'document' 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 procedure_callers, procedure_references, or resolve_native_call_targets. The static qualifier implies a call-graph query, but the agent is left to infer selection criteria.

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

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

Annotations already declare idempotent, non-destructive, closed-world behavior, so the description only needs to add context. 'Static' hints that dynamic/indirect call edges are excluded, but it never says whether indirect calls, PLT stubs, or tail calls are included, nor how results are retained via analysis_project_id.

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. It is efficient, though the extreme brevity edges toward under-specification rather than disciplined conciseness.

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 3-parameter analysis tool with no output schema, the description says nothing about the shape of a caller record, pagination, or failure modes when the procedure is not found. An agent cannot predict what it will get back or how to format the procedure argument.

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 only 33%: only analysis_project_id is documented. The required 'procedure' parameter is ambiguous (symbol name? mangled name? address?) and 'document' has no explanation at all, yet the description mentions neither, so it fails to compensate for the coverage 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 and resource ('List static callers') scoped to an ELF function, which an agent can distinguish from procedure_callees by the word 'callers'. It stops short of naming the inverse sibling or clarifying that only static (not runtime) call edges are reported.

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 procedure_callees, xrefs, or procedure_references, all of which plausibly answer related questions. The agent must infer the distinction from 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?

Annotations already declare idempotentHint=true, destructiveHint=false, openWorldHint=false, but the description adds no behavioral context: it does not explain why readOnlyHint is false for an 'Inspect' tool (presumably because analysis_project_id persists the result), what happens on failure, or what state must exist. For a tool whose annotation profile is not self-evidently consistent with its name, that omission is a real 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 short sentence with no wasted words and the resource front-loaded after the verb. The problem is under-specification rather than verbosity, so it earns adequacy but not full marks.

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 three parameters, no output schema, only 33% schema coverage, and a dense cluster of procedure-related siblings, a nine-word description is far too thin. Return-value details can be excused by the absence of an output schema only if the description compensates elsewhere, which it does not.

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 only 33%: 'document' and 'procedure' are bare strings with no schema description, and the one-liner adds nothing about them. It does not say whether 'document' is a handle/path and what null (the default) means, nor whether 'procedure' takes a symbol name, address, or either — the most consequential thing an agent needs.

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 (Inspect) and a specific resource (an ELF function/procedure), and enumerates what it returns: signature, body, and metadata. It stops short of distinguishing itself from the many overlapping siblings (procedure_pseudo_code, procedure_assembly, analyze_function, procedure_callers), so an agent must infer that 'metadata' is the differentiator.

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 when-to-use, when-not-to-use, or alternative routing guidance at all. With siblings like procedure_assembly, procedure_pseudo_code, procedure_callers, and analyze_function all operating on the same procedure, the agent gets no help choosing among them, and no prerequisite (e.g. an open binary session) is 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?

Annotations declare readOnlyHint=false, which is counterintuitive for a decompile operation, and the description says nothing about what is written or why. It also omits latency/cost expectations for decompilation and does not explain the interaction with analysis_project_id beyond what the schema already says.

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

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

Two sentences, zero filler, with the core action front-loaded before the disambiguation rule. Nothing to trim.

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

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

With no output schema, the description should at least characterize the returned pseudo-code (text blob, per-function scope) and cover the undocumented `document` parameter. It is adequate to invoke correctly but leaves meaningful unknowns.

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 33%, and the description compensates partially by revealing that `procedure` accepts an entry address (not just a name). The `document` parameter is undocumented in both schema and description, so the gap is only half-closed.

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 ("Decompile one ELF function") plus the output form ("Ghidra C-like pseudo-code"), which implicitly separates it from procedure_assembly and read_function_instructions. It does not explicitly name those siblings, so differentiation is inferable 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?

Gives one concrete conditional rule: use an entry address from list_procedures when a name is ambiguous between a function body and a thunk. That is real routing guidance, but there is no guidance on when to prefer decompilation over procedure_assembly, procedure_info, or analyze_function.

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

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

The annotations already declare non-destructive, idempotent, non-open-world, but not read-only behavior. The description does not explain the non-read-only side effect, including the optional analysis_project_id retention behavior, nor does it describe return semantics or operational 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 filler and no redundant restatement. It is efficient, though its brevity contributes to gaps covered under other dimensions.

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

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

For a tool with four parameters, no output schema, and low schema description coverage, the description is too thin. It omits procedure/document semantics, side effects, return behavior, and sibling tool selection guidance.

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 only 25%, with only analysis_project_id documented in the schema. The description repeats the direction enum and mentions ELF functions, but it does not explain procedure format, the document parameter, or the retention meaning of analysis_project_id, so it does not compensate for the low coverage.

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

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

The description gives a specific verb and resource: trace static references for an ELF function, and indicates incoming/outgoing direction. It is clear what the tool does, but it does not distinguish itself from close siblings such as procedure_callers, procedure_callees, or xrefs.

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 one-sentence description implies that the tool is used for reference tracing, but it gives no explicit when-to-use guidance, no prerequisites, and no alternatives. An agent cannot tell from this whether to choose procedure_references over procedure_callers, procedure_callees, or xrefs.

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

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

Beyond annotations, it discloses that the local copy must not already exist and that the operation is read-only with respect to the device, clarifying why readOnlyHint is false overall. It also mentions SHA-256 digesting, adding useful behavioral context, though it does not describe failure handling or exact return values.

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

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

Two sentences, front-loaded with the action and result. Every clause adds relevant scope, precondition, or behavior without wasted wording.

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 definition covers the core action, input constraints, device-side safety, and SHA-256 behavior, which is sufficient to invoke the tool. With no output schema, it could better describe the returned artifact or digest, and it omits the optional analysis_project_id semantics.

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

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

Schema description coverage is 100%, so the schema already documents serial, device_path, output_directory, and analysis_project_id. The description adds example file types and confirms the output-directory precondition, but does not explain the optional analysis_project_id or add syntax beyond the schema.

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

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

The description states a specific verb and resource: pull one absolute device path into a caller-selected output directory. It distinguishes the tool from package-oriented siblings by naming database, shared-preferences XML, or any readable file, and adds SHA-256 digesting as part of the action.

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

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

It gives clear usage context: a single absolute device path, a caller-selected local directory, and the precondition that the local copy must not already exist. It does not explicitly name alternatives such as pull_adb_package or state when not to use this tool, so it falls short of full routing guidance.

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