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

No annotations are provided, so the description carries the full burden. 'Comprehensive analysis' is vague: it does not state what is returned, defaults for the many include_* flags, whether it is read-only, or any cost/latency characteristics of batching.

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, front-loaded with the verb and scope. It is efficient, though for a tool with such a rich option set it is arguably too terse to be fully useful.

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 complex batch tool with a large per-query option schema, no output schema, and no annotations, the one-line description is not sufficient. It omits what the analysis yields, how results are aggregated across queries, and defaults for the include_* section flags.

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 every parameter (including the include_* flags and instance_id routing guidance) is documented in the schema itself. The description adds nothing beyond the schema, which is the correct baseline when the schema does the heavy lifting.

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

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

States a specific verb (analyze) and resource (target functions), and 'one or more' signals a batch variant of the per-function analysis. It does not name analyze_function explicitly, 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?

Only 'one or more target functions' hints at when to use this over analyze_function; there are no explicit when/when-not conditions, no mention of alternatives, and no 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?

No annotations are provided, so the description carries the full behavioral burden. It never states that this is a read-only operation, whether it is expensive/slow on large address sets, any limit on the number of addrs, or whether results are cached. For an analysis tool with zero annotation coverage this 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 front-loaded sentence with a clear verb-resource pair and an enumeration of return content; nothing is wasted. It is terse to the point of omitting useful guidance, 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?

The description does tell the agent what comes back (per-function summaries, internal call graph, shared data), which is helpful without an output schema. However, given no annotations and no usage constraints, the definition is only minimally sufficient for a tool that takes an arbitrary set of addresses.

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 in the schema, including the routing purpose of instance_id. The description adds no format or constraint details (e.g. how many addresses are reasonable, whether addresses must belong to one component), so it lands at 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 (Analyze) and resource (related functions as a group), and enumerates the three outputs, which separates it from the singular analyze_function and the bulk analyze_batch. It does not directly name those siblings, so the differentiation is inferable rather than explicit.

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

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

No when-to-use guidance is given. With siblings like analyze_function, analyze_batch, and callgraph in the list, the agent must guess why it would pick this grouped analysis over a single-function analysis or a call-graph query. Only the phrase 'as a group' implies a selection condition.

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

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

With no annotations, the description carries the full behavioral burden, and it partially does so by flagging 'Compact' and (via the schema) the token-saving default for disassembly. However, it never states that this is a read-only operation, whether results are cached, or what the response shape looks like, leaving meaningful gaps.

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

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

A single compact sentence that leads with the scope ('Compact single-function analysis') and then lists the returned artifacts. Nothing is wasted, though the noun-list style is terse enough that it reads more like a schema than guidance.

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

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

For a 3-parameter read-only analysis tool with full schema coverage but no output schema, the enumeration of returned artifacts largely substitutes for a return-value spec, and the compact/token caveat covers the one behavioral nuance. Missing sibling differentiation and any explicit invocation prerequisites keep it short of a 5.

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 schema documents all three parameters including the token-saving intent of include_asm and the instance routing requirement. The description adds no syntax, address-format, or routing 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+resource ('single-function analysis') and enumerates exactly what it returns: pseudocode, strings, constants, callers, callees, xrefs, blocks. It does not differentiate itself from near siblings like decompile, analyze_batch, or analyze_component, so an agent cannot tell from the text alone why this one fits rather than those.

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 guidance and no mention of alternatives, despite siblings such as analyze_batch (for multiple functions) and decompile (for single-purpose output) being obvious candidates. The word 'single-function' loosely implies scope, but nothing tells the agent when to prefer this over the alternatives.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It mentions deduping exact text by default, but that same detail is already in the schema. It does not disclose permissions required, whether it modifies the database persistently, how it interacts with existing comments, or whether a save is needed 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?

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for a concise tool summary.

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 mutation tool with no annotations, no output schema, and a required routing parameter, the description is too sparse. It omits when to use the tool, the necessity of providing `instance_id` or calling `instance_list`, and any post-append persistence implications.

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 50%. The description maps loosely to `addr`, `comment`, and `dedupe` via 'at addresses,' 'comments,' and 'deduping,' but adds little beyond the nested schema descriptions. The required `instance_id` routing parameter is not mentioned in the description, leaving a gap the schema partially fills.

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: 'Append comments at addresses.' It also notes deduping behavior. However, it does not explicitly differentiate from the sibling tool `set_comments`, which would help an agent choose correctly.

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 alternatives like `set_comments`, nor are prerequisites (e.g., required `instance_id`, calling `instance_list` first) mentioned in the description. Usage is only implied by the verb 'append.'

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

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

No annotations are provided, so the description carries the full behavioral burden and largely drops it. It does not state that the call is read-only/non-mutating, does not mention the required IDA instance routing or instance_list prerequisite, and says nothing about output shape, ordering, or behavior when max_blocks truncates a function.

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 wastes nothing. It is terse to the point of under-specification, but that is a completeness problem rather than a structure problem.

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

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

For a four-parameter tool with no annotations and no output schema, the description is far too thin. It never explains that addrs accepts multiple addresses or functions, what a returned block contains, or the routing prerequisite for instance_id, all of which the agent needs to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents addrs, offset, max_blocks, and instance_id in detail, which sets the baseline at 3. The description's mention of 'offset/max_blocks pagination' adds a light framing of their combined purpose but no syntax or semantics 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: returns function CFG basic blocks, which is more precise than a generic 'analyze' tool. It does not, however, distinguish itself from adjacent siblings such as disasm, analyze_function, or func_profile, so an agent must infer the boundary 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?

The description gives no when-to-use or when-not-to-use guidance and names no alternative. The only usage signal is implicit in the word 'CFG', leaving the agent to guess how this differs from disasm 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?

With no annotations provided, the description carries the full behavioral burden. It discloses the returned fields and a key side effect: dependent tools return errors and prompt retries when the cache is not ready. It does not cover permissions or whether the call itself mutates state, but for a status query it adds meaningful operational 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?

The description is two sentences, front-loaded with the purpose and return fields, then quickly states the conditional failure behavior. Every sentence carries useful information with no redundancy.

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

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

There is no output schema and no annotations, so the description must explain return values and behavior. It does so adequately by listing the status fields and describing the dependent-tool failure mode. It could mention how to resolve a non-ready cache (e.g., refresh_cache) for fuller completeness.

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

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

The input schema has 100% description coverage and fully documents the single required instance_id parameter, including guidance to use instance_list first. The description adds no parameter-level detail beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb and resource: querying the local SQLite static cache status of a specified IDA instance. It also enumerates return fields (status, last_updated, table counts). However, it does not explicitly differentiate from the sibling refresh_cache tool, which is the closest alternative.

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

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

The description implies when the tool matters by explaining that dependent tools (find_regex, entity_query, list_funcs, etc.) fail when status is not 'ready'. It does not explicitly say when to call cache_status versus alternatives, nor does it mention refresh_cache as a remedy, leaving usage context 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that results are unique and capped, but omits read-only safety, permission requirements, mutation behavior, error handling, and other operational traits.

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. Appropriately sized for a simple query 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?

There is no output schema, so the description should ideally clarify return structure or ordering. It states the return content ('unique callees per function') but lacks detail about result format or pagination beyond the limit cap.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the notion of 'unique callees' but the parameters (addrs, limit, instance_id) are already fully documented in 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 ('Return') and resource ('unique callees per function'), plus the cap behavior. It's clear what it does, but it does not explicitly differentiate from siblings like callgraph or xrefs_to.

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

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

Provides no when-to-use guidance, no alternatives, and no preconditions beyond what the schema already states (instance_id routing). An agent is left to infer when this tool is preferable to callgraph or xrefs_to.

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

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

With no annotations, the description carries the full burden but only mentions that the graph is 'bounded' with limits. It does not disclose whether the operation is read-only, whether it modifies the IDB, what happens when limits are reached, or the return format.

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 appropriately sized for a brief summary, though the overall definition is under-specified for the tool's complexity.

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

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

Given six parameters, two required, no annotations, no output schema, and a crowded sibling landscape, the description is far too sparse. It omits the required instance_id routing, usage context, and any behavioral traits, leaving major gaps that the schema alone cannot fill for an agent selecting a tool.

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

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

Schema description coverage is 100%, so the schema fully documents all six parameters including defaults and maxes. The description alludes to depth/node/edge limits, which map to three parameters, but adds no new meaning beyond what the schema already provides.

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

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

States a specific verb 'Build' and resource 'callgraph', with modifier 'bounded from roots'. It distinguishes itself from simple list tools like callees by implying traversal, but does not explicitly name or differentiate from any sibling tool.

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

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

The description offers no when-to-use guidance, no prerequisites, and no alternatives. It simply states what the tool does, leaving the agent to infer when a bounded callgraph traversal is preferable to related tools like callees.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation ('create') but says nothing about permissions, whether existing declarations are overwritten, reversibility, error behavior, or that requests are routed to a specific IDA instance. That is thin for a write operation with zero annotation coverage.

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, which is good structure. But it is under-specified rather than genuinely concise, packing in too little for a mutation tool with two required parameters.

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

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

No output schema and no annotations, with 50% parameter coverage and a bare one-line description. For a tool that mutates a database's stack layout, the agent lacks enough context on scope, routing, and side effects to call 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 50%: the nested item fields (addr, offset, name, ty) are documented in the schema, and instance_id carries a detailed routing note. The top-level description adds nothing about the 'items' shape, batch/Single item acceptance (anyOf), or instance_id routing, so it fails to compensate for the uncovered half.

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: 'Create stack variables' from 'typed stack declarations'. An agent understands the core action (defining stack variables on a function). However, it does not distinguish itself from close siblings like stack_frame, delete_stack, or set_type, so it's clear but not fully differentiated.

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

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

No when-to-use guidance, no prerequisites, and no reference to alternatives such as stack_frame or delete_stack. The agent gets no signal about which stack-manipulation tool to pick or in what context this one 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses very little. It does not say whether existing types are overwritten, whether declarations persist without an idb_save call, what happens on parse errors, or what the operation returns. 'Local type library' hints at scope but leaves the mutation semantics unexplained.

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

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

A single front-loaded sentence with no filler, which is appropriately sized for the surface it covers. It is efficient, though the brevity here reflects under-specification rather than tight writing.

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 mutation tool with zero annotation coverage, no output schema, and several closely related type-mutation siblings, the description is too thin. An agent cannot tell from the text alone when to reach for declare_type versus set_type or type_apply_batch, nor what the effect on the IDB will be.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no information about decls beyond restating 'C type definitions', and notably does not explain the anyOf shape (single string vs array of strings) or whether multiple declarations are applied atomically.

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+resource: declaring C type definitions into the local type library. An agent knows what kind of operation this is. However, it does not distinguish itself from close siblings like set_type, type_apply_batch, or enum_upsert, so the boundary of its purpose is left implicit.

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

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

There is no when-to-use guidance at all. The sibling list contains set_type, type_apply_batch, infer_types, and enum_upsert, and the description never says when declaring types here is preferable to those alternatives or what prerequisites apply beyond the schema's note about instance_id.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses return fields (addr, code) and the failure mode (error), which goes beyond a bare decompile claim. However it says nothing about permissions, cost, or whether it is a safe read-only operation, leaving gaps given zero annotation coverage.

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 operation, followed by input and output expectations. No filler, though the terseness leaves little room for context.

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

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

With no output schema, the description helpfully states the return shape (addr, code) and error behavior, and the schema richly documents the instance_id routing requirement including a pointer to instance_list. Complete enough for an agent to call it correctly, though usage-vs-sibling context is absent.

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 (addr, instance_id, include_addresses) are already fully documented in the schema, including accepted address formats. The description adds no parameter detail beyond what the schema supplies, 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+resource ('反编译函数为伪代码', decompile a function to C-style pseudocode) and names the output format, which distinguishes it from the assembly-producing sibling disasm. It does not name siblings directly, but the C-style pseudocode deliverable gives an agent enough to tell it apart.

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, no mention of when to prefer decompile over disasm or analyze_function, and no preconditions stated. The accepted input forms (address or symbol) are given, but that is input format, not usage guidance.

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

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

No annotations are provided, so the description carries the full burden. It implies a mutation of the IDB (marking bytes as code), but does not disclose side effects, permission/routing requirements, reversibility, or interaction with existing disassembly. This is a significant gap for a database-mutating tool.

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

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

A single tight sentence with the action front-loaded and zero filler. Efficient, though the minimalism contributes to the coverage gaps elsewhere.

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 mutation tool with no annotations and no output schema, the description should clarify what 'convert' modifies, whether it changes disassembly, and any routing steps. It leaves the agent guessing about effects and requirements.

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%; the schema already documents the items subfields (addr, end) and the instance_id routing parameter. The description's 'at address(es)' loosely maps to items but adds no syntax, format, or batching detail beyond the schema. Baseline 3 is appropriate given the schema handles the specifics.

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 (convert) and resource (bytes to code instructions) with address scoping. An agent can tell this marks code at addresses, distinct from define_func which creates a function. It does not explicitly name or contrast with sibling tools like define_func or undefine, 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 gives no when-to-use, when-not-to-use, prerequisites, or alternatives (e.g., define_func, patch_asm, undefine). The agent must infer usage purely from the name and the surrounding tool list.

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

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

With no annotations the description carries the full burden, and it does disclose one genuine behavioral trait: IDA infers bounds by default and only uses explicit bounds when 'end' is given. That is a useful default-behavior note, but the description says nothing about permissions, IDB mutation effects, reversibility, or failure behavior for what is a mutating tool.

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

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

A single front-loaded sentence pairs the verb+resource first and the behavioral caveat second, with zero filler. Its brevity reflects under-specification rather than verbosity, but the structure itself is efficient.

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 mutation tool with no annotations, no output schema, and half its parameters undocumented, the description is too thin. It omits what changes in the IDB, what constitutes success, and any prerequisites, leaving an agent without enough context to invoke it confidently.

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

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

Schema coverage is 50%, so the description should compensate; it only partially does by referencing the 'end' parameter's effect. The 'addr' parameter and the 'start:end' syntax are left to the schema rather than clarified in the description, adding little beyond structured fields.

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

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

The description states a specific verb+resource ('Define functions'), which is clearly distinct from the broader sibling define_code. It does not, however, explicitly contrast itself with nearby siblings such as define_code or undefine, so the differentiation is implicit 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?

There is no when-to-use, when-not-to-use, or alternative-tool guidance. The only conditional clause concerns the optional 'end' behavior, not tool selection, leaving the agent to infer all usage context.

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

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

With no annotations, the description carries the full behavioral burden, and it discloses almost nothing. It does not state that deletion is destructive/irreversible, whether it removes only the definition or also associated comments/types, what happens if the named variable does not exist, or any permission requirements.

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

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

A single short sentence with the verb and resource front-loaded and zero filler. Nothing bloated or redundant.

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

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

For a destructive mutation with no annotations, no output schema, and only half the parameters documented, the description is too thin. It should at minimum flag the destructive/irreversible nature and any coupled effects on dependent declarations.

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 50%; the items property itself is undocumented while nested fields (addr, name) and instance_id carry descriptions. The description's mention of 'offset' does not map cleanly to the schema's 'addr' field ('Function address'), which introduces ambiguity rather than resolving it.

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

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

States a specific verb (Delete) and resource (stack variables), plus the identification modes (name or offset), so the agent knows precisely what the tool targets. It does not differentiate itself from stack-manipulation siblings like declare_stack or stack_frame, which is the only gap.

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 alternatives guidance. The agent must infer that this is the inverse of declare_stack and when deletion is appropriate versus re-declaration, with nothing stated explicitly.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the return shape (addr, asm line list, cursor) and that offset/pagination and total-count options exist, which is useful. It does not state that this is a read-only, side-effect-free operation, nor describe truncation behavior at the 5000/50000 instruction limits.

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 short clauses, front-loaded with the core action and followed by input, output, and paging details. Nothing is padded, though the listing style is terse rather than prose.

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 disassembly tool with no output schema, the description usefully enumerates the return fields and the pagination mechanism, and the schema covers every parameter including instance routing. Only the failure/truncation semantics are 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%, so all five parameters are already documented in the schema (including the instance_id routing note). The description adds only the accepted address/symbol forms and confirms pagination, which largely duplicates the schema; 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+resource ('反汇编函数为汇编指令' – disassemble a function into assembly instructions) and names the accepted input forms (address or symbol name). An agent can distinguish this from sibling 'decompile' since raw instruction output is clearly implied. It stops short of explicitly contrasting itself with that sibling.

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

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

Usage is only implied: the raw-instruction framing suggests use when assembly rather than source-level output is needed, and the mention of offset/pagination hints at iterative reads. There is no explicit when-to-use, when-not-to-use, or named alternative such as 'decompile'.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Query' implies a read, but it never states read-only semantics, whether results are paginated by default, what the response shape is, or any limits. For a tool with no annotation coverage this is a meaningful omission.

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. It earns its brevity, though the extreme terseness leaves important behavior unstated rather than being a model of efficient completeness.

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 accepting batch/nested query objects across five entity kinds, with no output schema and no annotations, one sentence is not enough. Return values, pagination behavior, and how the typed queries compose are all left to the schema and inference.

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 every query field (kind, regex, filter, sort_by, min/max_addr, etc.) and the instance_id. The description's mention of filters/projection/pagination merely echoes the schema categories without adding syntax or semantics, 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 gives a verb (Query) and a resource (IDB entities) plus the categories of capability (filters, projection, pagination), so the basic purpose is legible. However, 'typed filters' is vague jargon and it does nothing to separate this generic tool from the many sibling query tools (func_query, imports_query, xref_query, type_query, list_globals). An agent cannot tell from the description alone which query tool to reach for.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance at all. With a dense family of sibling query tools, the absence of routing guidance is a real gap; the agent must fall back on guesswork or the schema.

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

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

No annotations, so the description carries full burden. It usefully discloses idempotency and non-destructive member upsert (reinforced by the schema's 'without destructive replacement'), but says nothing about permissions, how conflicting member values are resolved, or what happens to members omitted from the call.

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, and the idempotency guarantee is stated immediately. It is arguably too terse given this is a mutating operation, but it is 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?

For an upsert tool with no annotations and no output schema, the definition leaves real gaps: nothing about failure modes, partial-failure behavior, or what the result reports. The rich schema covers inputs well, but the operational semantics of the write remain underspecified.

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 every parameter is documented nominally (queries, name, members, bitfield, instance_id). The description adds no parameter-level meaning 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 (create/extend), resource (local enums), and a behavior (idempotent). 'Local enums' scopes it apart from general type tools like declare_type or set_type, but it never names a sibling, so the agent must infer the boundary 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?

There is no when-to-use guidance, no exclusions, and no mention of the sibling type-management tools (declare_type, set_type, type_apply_batch) that an agent would naturally weigh against this one. The only routing hint is in the instance_id schema text, not the description.

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

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

Annotations are absent, so the description carries the full burden. It adds useful disclosure that the json format bundles asm/code/xrefs, but says nothing about read-only nature, size/limit behavior, or how c_header/prototypes differ in output.

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 formats with no filler. It is terse to the point of being sparse but every clause earns its place.

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

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

No output schema exists, yet the description only partially compensates, explaining what json contains but not what c_header or prototypes return, nor read-only/auth behavior. Adequate but with clear gaps for a tool with three documented params.

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 addrs, format, and instance_id including the routing note. The description restates the input as address or symbol name and the format list, adding no semantics beyond the schema; baseline 3 is appropriate.

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

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

Specific verb (export) plus resource (function data) with the supported formats named, so the agent knows exactly what the tool produces. It does not, however, differentiate itself from siblings like decompile, disasm, or list_funcs that also surface function content.

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

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

No when-to-use guidance and no alternatives named; the agent must infer that this is the export tool versus decompile/disasm on its own. There are no exclusions or conditions that would route it away from a sibling.

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

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

With no annotations, the description carries the full behavioral burden. It discloses pagination via offset/limit, which is useful, but says nothing about what is returned, error behavior, or the required instance routing/auth context (only in the schema). For a search tool over multiple target types this is a significant gap.

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

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

A single front-loaded sentence with no filler. It is efficient, though arguably too terse given the tool's five parameters and multiple search modes.

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 5-parameter search tool with no annotations and no output schema, the description is minimally adequate. The rich schema carries parameter detail, but the description omits return-shape expectations and disambiguation from closely named siblings.

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

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

Schema description coverage is 100%, so the schema already documents type, limit, offset, targets, and instance_id. The description adds only a terse mention of pagination and target categories, which the schema states more precisely. 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 verb (search) and resource scope (strings/immediates/refs), which is more specific than the generic name 'find'. However, with siblings like find_bytes, find_regex, search_text, and func_query, the description never explicitly says how this tool differs from those alternatives, leaving the agent to infer differentiation from the target-type list.

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

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

No when-to-use, when-not-to-use, or named alternatives are given. The target types hint at the domain, but there is no guidance on choosing 'find' over find_bytes/find_regex/search_text, nor any prerequisites despite instance_id being required.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It notes wildcard support and pagination, but both are already documented in the schema; it says nothing about whether the operation is read-only, how results are returned, or any instance-routing requirements.

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

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

The single sentence is tightly structured and front-loads the core action. It wastes no words, though its brevity leans toward under-specification rather than earned 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 and no annotations, the description does not explain the return format or result shape, nor does it mention the required instance_id routing requirement highlighted in the schema. For a search tool with several sibling alternatives, this leaves meaningful 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%, so all four parameters are documented in the input schema. The description only alludes to offset/limit pagination, which the schema already explains, so it adds no parameter meaning beyond the structured field documentation. 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 ('Search') and resource ('byte patterns'), and adds that wildcard '??' is supported. This distinguishes it from textual search siblings, but it does not explicitly differentiate itself from related byte-reader tools like get_bytes or pattern-search alternatives like find_regex.

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

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

No guidance is given on when to use this tool versus siblings such as find_regex, find, search_text, or get_bytes. The description only implies usage from the verb, with no conditions, prerequisites, or alternatives.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the return shape and case-insensitive matching, but does not state that the operation is read-only, whether it searches all binary data or only IDA-recognized strings, or any other execution constraints.

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

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

The description is four short, front-loaded clauses that each add a distinct piece of information: search method, return fields, case behavior, and use case. There is no filler.

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

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

For a low-complexity read-only search tool with rich parameter descriptions but no output schema or annotations, the description gives the essential result fields and matching behavior. It could be slightly more complete by clarifying the search scope and read-only nature, but no critical information 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 schema already documents pattern, instance_id, limit, and offset. The description adds no parameter-specific syntax or format details beyond what the schema provides, making the baseline score of 3 appropriate.

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

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

The description states a clear verb (search), resource (binary strings), method (regex), return fields (addr, string), and case-insensitivity, so an agent can tell it apart from byte-search or general-search siblings. It does not explicitly name the closest alternative tools, so it falls just short of the top score.

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 provides a clear intended use case: finding hardcoded strings. It does not state when not to use it or name alternatives such as find_bytes or search_text, so no exclusions are provided.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does explain the algorithm and output selection ('returns the shortest ones'), which is genuinely useful, but says nothing about permissions, rate limits, or failure modes (e.g., what happens when an address has no xrefs). Adequate but incomplete.

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 action, then the mechanism, then the ideal use case. No wasted text. Slightly more compact than strictly necessary but well structured.

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

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

No output schema and no annotations, so the description must cover behavior and returns. It explains the returned artifact (shortest signatures per address) and the format options come from the schema, leaving the definition reasonably self-sufficient, though it omits what is returned when no xrefs are found.

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 all five parameters (top, addrs, format, max_length, instance_id) including defaults and enum-like format values. The description adds no parameter-level detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb and resource ('find signatures for code locations that reference an address') and clarifies the mechanism (finds code xrefs TO each address, generates a signature at each site). It implicitly distinguishes itself from direct signature siblings like make_signature by noting it serves addresses 'that can't be signatured directly,' though it does not name 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?

Provides clear usage context: 'Ideal for creating signatures for data addresses, vtable entries, or string references that can't be signatured directly.' This steers the agent toward the right scenario, but it stops short of naming alternatives (e.g., make_signature/make_signature_for_function) or stating when not to use it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It hints at output shape (summary metrics, sampled details) but says nothing about read-only nature, cost/performance of profiling multiple functions, sampling behavior, or limits. For a profiling tool over potentially many functions, this is a notable gap.

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

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

A single, front-loaded sentence with no waste. It is efficient, though its brevity is partly responsible for the gaps 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?

With no annotations, no output schema, and a rich nested query parameter, the description should do more to explain return contents and sampling. As written it is too thin for the complexity of the tool and its ambiguous positioning among many function-related siblings.

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

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

Schema description coverage is 100%, and the queries object documents every field (addr, filter, sort_by, include_lists, etc.), so the baseline is 3. The description adds no meaning beyond what the schema already spells out.

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 (profile) and resource (functions) plus a high-level sense of the output (summary metrics + sampled details). However, it does not distinguish itself from closely related siblings like analyze_function, func_query, or list_funcs, leaving the agent unclear on when this profiling view is preferred.

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 analyze_function, func_query, or list_funcs. No prerequisites or exclusions are provided. The only usage-related clue is embedded in the instance_id schema description, not the tool description itself.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: not that this is a read-only query, not pagination semantics (count=0 meaning all, offset), and not the result shape. For a query tool with zero annotation coverage this is a significant gap.

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

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

A single front-loaded sentence with no waste. It is efficient, though the brevity arguably sacrifices needed detail rather than trimming fat.

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

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

The tool has a complex nested anyOf schema (array or single object queries), no output schema, and no annotations, yet the description says nothing about return format or the array-vs-object flexibility. It is too thin for the tool's complexity.

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

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

Schema description coverage is 100%, with each nested filter (count, offset, sort_by, min/max_size, name_regex, has_type) individually documented, so the baseline is 3. The description adds no syntax or format 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 ("Query functions") and explicitly distinguishes itself from the sibling list_funcs by claiming richer filtering. It does not enumerate which filters make it richer, but the schema covers that.

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 "richer filtering than list_funcs" implies when to prefer this tool, but there is no explicit when-to-use/when-not guidance or statement of prerequisites beyond the instance_id note in the schema. 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?

No annotations are provided, so the description carries the burden. It implies a read-only operation and discloses the return shape ('返回 addr,data(hex)'), which is useful. But it says nothing about permission/auth needs, read limits, or behavior on unmapped addresses, leaving real gaps for an unannotated tool.

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

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

Three short, front-loaded sentences: purpose first, then input format, then return. Dense and waste-free, though the input-format sentence largely restates the 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 low-complexity two-parameter read tool with no output schema, the description covers purpose, accepted input forms, and the return shape (addr + hex data). The instance_id routing requirement is handled by the schema. Nothing critical 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's format examples for 'addr:size' duplicate what the schema already documents for the regions parameter, adding no meaning beyond the structured field.

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: '从内存读取原始字节' (read raw bytes from memory). This clearly distinguishes it from get_int, get_string, and find_bytes by the raw-byte scope. However, it does not explicitly contrast with those siblings, so a 4 rather than 5.

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

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

Usage is only implied by the purpose — read raw memory regions. There is no explicit guidance on when to prefer this over get_int/get_string/disasm, nor any stated prerequisites beyond the schema-embedded instance_id note. Adequate but with a clear gap.

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

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

With no annotations, the description carries the full burden but does disclose two meaningful behaviors: automatic hex-vs-name detection and the requirement that IDA already defines the global type. It does not say what happens when the type is undefined (error vs raw read) or how the value is rendered, so key failure behavior is missing.

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

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

Three short, front-loaded sentences covering purpose, input handling, and prerequisite with zero filler; the core action is stated first.

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 2-parameter read tool with no annotations and no output schema, the definition covers purpose and a prerequisite but omits return-value shape and error behavior, which the absent output schema would otherwise have to carry.

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 with examples in the schema, establishing a baseline of 3. The description's auto-detection note adds marginal interpretation guidance for `queries` but no new syntax or constraint beyond what the schema shows.

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 (read a global variable's value) plus the two accepted input forms. It is clearly distinguishable from list_globals (enumeration) and patch/put_int (mutation), though it doesn't explicitly name those 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?

Provides one real prerequisite – the global's type must already be defined in the IDA database – which is useful usage context. However, it gives no explicit guidance on when to prefer this over get_int/get_bytes for reading a global, so the when-to-use decision is left implied.

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

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

No annotations are provided, so the description carries the full burden. It states the return fields (addr,ty,value) and supported integer types, but says nothing about read-only safety, error handling for invalid addresses, or any side effects. For a read tool the risk is low, yet key behavioral context is still missing.

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

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

The description is short and front-loaded: purpose first, then supported types, then return values. Every sentence contributes, though it could be slightly more structured (e.g., separating usage from output). No wasted words.

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

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

For a simple integer-reading tool with 100% schema coverage and no output schema, the description covers the core operation and return format adequately. However, it omits when-to-use guidance relative to sibling tools and does not mention any behavioral caveats. It is minimally sufficient but not rich.

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 both parameters in detail (including type examples and address format). The description repeats type information but adds no new semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: '从指定地址按类型读整数' (read integer from specified address by type). It distinguishes this from sibling readers like get_bytes or get_string by focusing on typed integer reads, and it names the return fields addr,ty,value. An agent can tell it apart easily.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as get_bytes, get_string, or int_convert. There are no prerequisites, exclusions, or routing hints. The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full burden; it usefully discloses that C and wide-char strings are both handled and that a missing string yields an error. However, it omits read length/truncation limits, encoding details, and any auth or rate considerations, leaving real behavioral gaps.

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

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

A single compact sentence front-loads the action, then the return shape, then the error case – no wasted words. It is efficient, though very terse for a tool that could benefit from a touch more routing context.

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

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

For a 2-parameter tool with no output schema, the description does state the return values (addr, value), which is helpful. It leaves the error payload format and the string-length behavior unspecified, so it is adequate rather than complete.

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

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

Schema description coverage is 100%, so both parameters (addrs with hex/decimal/comma-separated syntax, and instance_id) are already fully documented in the schema. The description adds nothing beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb and resource: read the IDA-recognized string (C/wide char) at an address. It is clearly distinguishable from siblings like get_bytes, get_int, and get_global_value. It stops short of explicitly naming a sibling to route against, so not a 5.

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

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

No when-to-use or when-not-to-use guidance is given. There is no mention of when to prefer this over get_bytes or get_int, nor any prerequisite beyond the schema's instance_id note. The error-on-missing-string note is behavioral, not a usage rule.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says the IDB is saved to disk but does not disclose whether this overwrites an existing file, requires a selected instance, is reversible, or what happens on failure – significant gaps for a write operation.

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

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

A single, front-loaded sentence with no filler; the optional path clause is placed after the core action. It is appropriately sized, though very sparse.

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 save tool with no annotations and no output schema, the description covers the essential action but omits prerequisites (active instance) and post-save behavior. It is minimally adequate rather than complete.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema, including the default path behavior. The description's phrase 'optionally to a provided path' merely restates what the schema already conveys, so the baseline of 3 applies.

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

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

The description states a specific verb (Save) and resource (active IDB) with a clear target (disk), so an agent can tell what the tool does. It does not explicitly differentiate itself from siblings, though no sibling shares the save-to-disk behavior.

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 save, whether an active/selected instance is required, or how this relates to cache tools like refresh_cache and cache_status. Usage is only implied by the name and purpose.

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

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

No annotations are provided, so the description carries the full behavioral burden. It helpfully discloses the return fields (addr, imported_name, module) even though no output schema exists, and the read-only nature is implied by '列出'. It says nothing about pagination interactions between count/offset or instance-routing behavior, leaving real gaps for an unannotated tool.

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

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

Three short, densely packed sentences with zero filler. The core purpose is front-loaded and the return fields and use case follow immediately, so nothing needs trimming.

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 listing tool with full schema coverage and documented return fields, this is nearly complete. The one missing piece is disambiguation from the similarly named `imports_query` sibling, which matters given the crowded sibling list.

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 (including count=0 meaning all, offset origin, and the instance_id routing note). The description adds no parameter-level meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb and resource: 「列出导入表」 (list the import table), which is unambiguous on its own. However, it does not distinguish itself from the sibling tool `imports_query`, which an agent could easily confuse it with. Clear purpose, but no sibling differentiation.

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

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

「用于查动态链接/API 调用」 gives an implied use case (inspecting dynamic linking / API calls) but never states when to prefer this tool over the near-named `imports_query` sibling, nor any exclusions or prerequisites. Usage context 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?

No annotations are provided, so the description carries the full burden, yet it discloses nothing behavioral: no read-only confirmation, no return shape, no pagination/limit semantics, no instance-routing caveats. 'Query' implies a read, but that is inference, not disclosure.

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

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

A single tight sentence with the differentiating claim front-loaded and zero filler. It is arguably under-specified rather than bloated, but on the conciseness axis itself it is efficient.

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 query tool with full schema coverage and no output schema, the parameter story is adequate. However, with no annotations and no explanation of filter syntax or result content, an agent gets only minimal context about what 'richer filtering' yields.

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% (filter, module, count, offset, instance_id all documented in-schema), so the baseline is 3. The description only hints that filter/module exist via 'richer filtering' and adds no syntax or semantics 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 gives a clear verb+resource ('Query imports') and explicitly positions itself against the sibling tool 'imports(offset,count)' by claiming richer filtering. It falls short of 5 because 'richer filtering' is left vague rather than naming the filter/module dimensions the agent would actually use.

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 names the alternative tool ('imports') and the condition that selects this one (need for richer filtering), which is real routing guidance. It lacks any when-not-to-use or detail on what the additional filtering consists of, so it stops short of 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?

No annotations are provided, so the description carries full behavioral burden. 'Apply' implies a mutation of the IDB, but the description never states whether changes are reversible, what 'likely types' are based on, what gets modified, or any permission/scope 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?

A single short, front-loaded sentence with no filler. It is efficient, though its brevity contributes to the behavioral gaps noted elsewhere.

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?

Parameters are fully covered by the schema, but for a mutation tool with no annotations and no output schema, the description leaves key behavioral questions (reversibility, inference basis, scope of modification) unanswered.

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

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

Schema coverage is 100%, with both addrs and instance_id documented in the schema, including a detailed routing note for instance_id. The description adds nothing 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 pair (infer and apply) plus resource (types) and location (target addresses), which is more informative than a bare name restatement. However, it does not differentiate itself from close siblings like set_type, declare_type, or type_apply_batch, so an agent must infer the distinction.

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

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

No guidance on when to use this versus the many type-related siblings (declare_type, set_type, type_apply_batch). The agent gets no signal about automatic-inference vs manual-setting workflows, leaving selection to guesswork.

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

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

No annotations are provided, so the description carries the full behavioral burden for a read tool with batching, pagination, and scan limits. It hints that scans are scoped but omits that a scopeless scan requires allow_broad, that count is capped at 5000, and how offset/count interact for paging. Those facts live only in the schema descriptions, so the sentence adds little.

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, and the filtering capability is stated first. It is efficient, though the brevity borders on under-specification for a tool with this many options.

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 complex tool with an anyOf batch/object input, many nested filters, no output schema, and no annotations, the description leaves key operational details unaddressed: batch semantics, result shape, pagination behavior, and the allow_broad requirement. It is not complete enough to guide correct invocation on its own.

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 top-level parameters and all nested filter fields are documented in the schema itself, establishing a baseline of 3. The description restates the two filter families (mnemonic/operand, scope) but adds no semantics beyond what the schema already supplies.

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 (query instructions) plus the two filtering axes (mnemonic/operand filters, scoped scans). An agent can tell it is a filtered instruction search rather than a plain linear listing. However, it offers no differentiation from close siblings like disasm, find_bytes, or func_query, 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?

There is no when-to-use guidance, no mention of when to prefer this over disasm/find_bytes/func_query, and no note about the scopeless-scan constraint that gates broad searches. The agent must infer usage entirely from the schema.

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

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

No annotations are provided, so the description carries the full burden, but it only implies a safe read via the verb '获取' (get). It does not state read-only nature, error behavior for unknown IDs, or whether the instance must be selected first. For a low-risk single-parameter getter this is adequate but thin.

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 purpose, then the parameter source, then the return fields. No filler and nothing redundant in structure.

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

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

With an output schema present, the enumerated return fields are somewhat redundant but harmless. For a single-required-parameter read tool with no annotations, the description covers input provenance and output nature, leaving only minor gaps such as error handling.

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; it does so by explaining the provenance of instance_id ('来自 instance_list'), which is genuinely useful semantics beyond the bare string type. With only one obvious parameter, this is close to sufficient.

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

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

States a specific verb and resource (get details of a specified instance) and implicitly contrasts with the sibling listing tool by naming instance_list as the source of the ID. It is clear, though it does not explicitly state what makes it distinct from other retrieval tools like list_funcs or imports.

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 implied usage guidance by stating that instance_id comes from instance_list, which tells the agent the prerequisite step. However, it gives no when-not guidance, no mention of what happens with an invalid or stale ID, and no alternatives for other instance-related operations.

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

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

With no annotations provided, the description must carry behavioral disclosure. It usefully notes that no IDB load is required, which is a real workflow constraint, but it never explicitly states that this is a safe read-only operation with no side effects. The returned field list duplicates what the output schema already provides.

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

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

The description is extremely concise and front-loaded: one sentence states the action and scope, followed by a short prerequisite note and return-field list. No words are wasted.

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

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

For a zero-parameter listing tool with an output schema, the return values and basic behavior are covered. However, the description does not help an agent choose between this tool and the similarly named sibling 'list_instances', leaving a significant selection gap given the crowded tool namespace.

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

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

The tool takes zero parameters, so there are no parameter semantics to explain. The description does not need to compensate for any parameter documentation gap, making a baseline of 4 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 ('已连接的 IDA/Hopper 实例') with the scope '所有'. However, it does not distinguish this tool from the sibling 'list_instances', which appears to serve the same purpose.

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 '无需加载 IDB' implies a lightweight, always-available usage context, but the description gives no explicit when-to-use guidance, no exclusions, and no comparison to alternatives like list_instances, instance_info, or select_instance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses output formats (decimal/hex/ascii/binary) and input flexibility, but omits side-effect profile, determinism, error behavior, or instance/auth requirements beyond what the schema already states. This is adequate but leaves notable gaps.

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

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

The description is three short sentences: purpose first, then input/output formats, then usage mandate. It is front-loaded and contains 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?

For a simple conversion tool with no output schema and no annotations, the description covers purpose, input/output formats, and usage. It omits some behavioral details, but the schema's 100% coverage handles instance routing and parameter documentation, making it complete enough overall.

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 mentions input and output formats, but these are already documented in the schema's inputs description, and it adds no extra syntax or semantic detail 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 gives a specific verb+resource ('数值进制转换') and specifies accepted input formats and output formats, so the tool's purpose is clear. However, it does not explicitly differentiate int_convert from sibling tools like get_int or put_int, so it falls short of full sibling routing guidance.

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 when to use the tool ('禁止 LLM 手算进制，必须调用此工具') and frames it as the required path for base conversion. It does not name alternative tools or describe when not to use it, but the directive is clear.

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

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

No annotations are provided, so the description must carry behavioural disclosure. It adds useful pagination semantics and clarifies that '0:50' is a list index rather than an address range, but it does not state read-only safety, result ordering, or return format.

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 terse sentences, front-loaded with the tool's purpose and then key syntax. Every sentence earns its place, with no repetitive or filler content.

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

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

For a 2-parameter list tool with full schema coverage and no output schema, the description covers the core operation and pagination shorthand. It is not fully complete because it omits guidance on choosing among sibling function-querying tools and provides no safety or return-shape context, which matters since no annotations exist.

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 even though the description mentions filter and pagination. The description mostly repeats the schema's own field explanations and adds no semantic detail beyond what the schema already provides.

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

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

The description states a specific verb and resource ('列出函数') and notes glob filtering and pagination. It does not differentiate from sibling tools such as func_query, lookup_funcs, or export_funcs, so it earns a 4 rather than 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 implies usage for glob filtering and pagination, giving an agent some context. However, it does not name alternatives or state when to use this tool instead of related function-querying siblings, leaving selection guidance 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?

No annotations are provided, so the description carries the full burden. It usefully clarifies that '0:20' means offset:count as list indices, not addresses, which prevents a real misuse. However it does not disclose the read-only/no-mutation nature, rate limits, or return shape, leaving a gap for an annotation-free tool.

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

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

Extremely tight and front-loaded: purpose first, then capabilities, then the one clarifying note about pagination semantics. Every clause earns its place with no filler.

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

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

For a 2-parameter read/list tool with no output schema and full schema coverage, the description covers the core operations (glob + pagination). With no annotations, a bit more on the read-only nature and result format would make it fully self-contained.

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 filter/offset/count and instance_id thoroughly. The description mirrors the '0:20' offset:count syntax but adds no syntax or format 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+resource ('列出全局变量' / list global variables) and adds capability scope (glob filtering, pagination). It is distinguishable from get_global_value (single value retrieval) in practice, but the description does not explicitly name or contrast a sibling, 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?

Usage is only implied: it says glob filtering and pagination are supported but never states when to use this tool vs get_global_value or the other *_query/list_* siblings, nor any exclusions. Adequate for a simple listing tool but leaves routing to inference.

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

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

With no annotations and no output schema, the description carries the full burden and does disclose the shape of the result plus the meaning of the 'active' field, which is genuinely useful semantics beyond structured data. It omits permission requirements, whether there is any side effect, and any relation to the instance_id routing requirement, so it is not complete.

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 operation and then the usage context, with no filler. The second sentence slightly restates the 'reachability status' idea already implied in the first, a minor redundancy.

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

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

Covers return fields adequately given there is no output schema, but for a required-instance_id tool it omits how an agent obtains that ID and how this differs from instance_list/instance_info, both of which are live siblings performing overlapping work.

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

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

Schema description coverage is 100% and there is a single required parameter, so the baseline is 3; the description adds nothing about instance_id beyond what the schema says. Notably, the description never mentions that an instance_id must already be known, which is the tool's sole input.

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

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

States a specific verb and resource ('List all discovered IDA Pro instances') and enumerates the returned fields (binary name, port, reachability status). An agent understands the operation immediately, but the description never differentiates this tool from the near-duplicate sibling 'instance_list', leaving ambiguity about which to call.

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 sentence gives context ('Use this to see which IDA databases are currently open and available for analysis'), which implies when to use it. However, it gives no when-not guidance and never addresses the obvious alternative 'instance_list' (or 'instance_info'/'select_instance'), even though the sibling set contains a highly similar name.

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

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

No annotations are provided, so the description carries the full burden. It does disclose useful behavior: accepted input forms and the exact output fields (addr, name, size), plus batch support. However it says nothing about permissions, instance routing requirements, or error behavior on a miss.

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?

Extremely tight four-clause structure: purpose, input formats, output fields, batch note. Front-loaded with the core action and no wasted 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?

With only two required params and no output schema, the description usefully compensates by naming the returned fields (addr, name, size) and noting batch support. The instance_id routing requirement is left to the schema, which is acceptable given its detailed description there.

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 (queries accepts string/comma-list/array/object forms, instance_id routing) are fully documented in the schema. The description's input examples largely mirror the schema, adding little beyond 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+resource in '按地址或名称查找函数' (look up functions by address or name), which is clear. It doesn't explicitly distinguish itself from siblings like list_funcs or func_query, so an agent must infer the difference between a targeted lookup and a listing/query.

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 'input: address or symbol name' phrasing implies when the tool is applicable (you already have an identifier), but it names no alternatives or exclusions. Sibling tools list_funcs/func_query exist and are not referenced.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the generation strategy (shortest unique signature, instruction walking, operand wildcarding), but omits whether signatures are persisted to the IDB or merely returned, and says nothing about failure behavior when no unique signature is found within max_length.

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 with the core action front-loaded and the mechanism/benefit trailing. No filler, though the third sentence is somewhat redundant with the purpose statement.

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

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

For a compute-style tool with no output schema and no annotations, the description explains generation but not the returned shape, failure conditions, or the IDB side-effect question. It is adequate but leaves meaningful gaps given the lack of structured support.

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 all five parameters including the specific enumerations for format. The description's mention of 'wildcarding operands' loosely maps to the wildcard_operands parameter but adds no syntax, defaults, or format meaning 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 ('Create unique byte signatures for addresses') and clarifies the generation mechanism (walking instructions, wildcarding operands). However, it does not differentiate from close siblings make_signature_for_function and make_signature_for_range, leaving the agent to infer that this is the address-level variant.

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 only usage signal is 'Useful for finding stable patterns that survive recompilation,' which is a benefit statement rather than a when-to-use rule. There is no mention of alternatives (the two sibling signature tools) or of when this tool would not be the right choice.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses a two-step behavior ('resolves each name/address to a function, then generates the shortest unique signature'), but says nothing about what happens if resolution fails, whether the IDB is modified, or whether output is capped (the max_length parameter implies truncation/give-up but is not explained here).

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

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

Two tight sentences with the core action front-loaded and the resolution/selection behavior second. No filler and no redundancy with schema fields.

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

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

For a 5-parameter tool with no annotations and no output schema, the description covers the main action but omits what a returned signature looks like, how multi-address input is handled in the response, and error behavior. The instance_id routing note lives only in the schema (in a different language), not in the description.

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

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

Schema coverage is 100%, so the schema already documents all five parameters including formats, max_length default, and wildcard_operands. The description adds one genuinely useful semantic — that each name/address is resolved to a function before signing — but nothing about the format or wildcard options 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+resource ('Create unique byte signatures for function entry points') and adds a scoping qualifier ('starting at the function start'), which distinguishes it in spirit from make_signature_for_range. However, it never names the closest siblings (make_signature, make_signature_for_range) so differentiation is inferential rather than explicit.

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

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

Usage is only implied: the agent can infer this is for generating signatures for whole functions rather than ranges. There is no statement of when to prefer this over make_signature_for_range or find_xref_signatures, and no prerequisites or failure conditions.

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

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

With no annotations, the description carries the full burden, and it does disclose a meaningful trait: the result is NOT guaranteed unique, unlike make_signature. But it omits operational context such as the instance-routing requirement (instance_id must be supplied and chosen via instance_list) and whether the operation is read-only or mutating. Useful but incomplete behavioral disclosure.

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

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

Two tightly written sentences with the core purpose and the differentiating constraint front-loaded ahead of the caveat. Zero filler.

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

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

For a 5-parameter tool with full schema coverage, no output schema, and no annotations, the description covers purpose, scope, and the non-uniqueness caveat adequately. The main residual gap is the instance-routing prerequisite, which the description never surfaces.

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 start, end, format, instance_id, and wildcard_operands. The description only restates the range concept and hints at operand wildcarding ('optional operand wildcarding'), adding little beyond the schema. Baseline 3 applies.

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

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

Specific verb+resource ('Create a byte signature for a specific address range') with a concrete example, and it explicitly distinguishes itself from the sibling make_signature by naming it and stating the key difference (no uniqueness guarantee). An agent can tell this apart from make_signature and make_signature_for_function without opening any schema.

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

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

It gives a clear selection condition: use this when you want to encode a byte range without requiring uniqueness, e.g. a selected region. It names the alternative make_signature and the tradeoff. It does not, however, address when to prefer make_signature_for_function over this tool, leaving one sibling relationship 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?

With no annotations provided, the description carries the full burden, yet it discloses nothing about behavior: no indication that patching mutates the IDB/binary, whether changes are reversible, permission requirements, or failure modes if an address is invalid.

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; the verb and resource come first. It is efficient but arguably under-specified rather than earning high marks for structure.

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 mutation tool with no annotations, no output schema, and half its parameters undocumented, the description is too thin. An agent needs reversibility, scope-of-effect, and instance-routing context that is absent.

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% and the description adds nothing beyond 'hex data', which is already stated in the schema's data field. It does not clarify the anyOf shape (single patch object vs. array of patches) or how multiple patches are applied.

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 (patch) plus resource (bytes at memory addresses) and format (hex data), so the agent knows it writes raw bytes. It does not, however, distinguish itself from the sibling patch_asm, which an agent could easily confuse with it.

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

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

The description gives no when-to-use guidance and names no alternatives. The only routing hint lives in the instance_id schema blurb (call instance_list first), not in the description itself.

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

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

No annotations are provided, so the description carries full behavioral burden, and it discloses almost nothing: it does not say the operation mutates the IDB, whether changes require an explicit `idb_save`, whether patches are reversible, or how failures on invalid addresses are handled. For a mutation tool with zero annotation coverage this is a significant 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?

It is a single six-word sentence with no wasted phrasing and the action is front-loaded. That brevity, however, comes at the cost of under-specification rather than efficient density.

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 mutation tool with no annotations and no output schema, the description is far too thin. It omits the mutation/save lifecycle, batch-vs-single items semantics, and any notion of what the tool returns or how errors surface.

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

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

Schema description coverage is 50%: the nested `addr` and `asm` fields are documented, and the Chinese instance_id description explains its routing purpose and points at instance_list. However, the top-level `items` wrapper (array-or-object union) is undocumented, and the description adds no formatting or semantics 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 gives a specific verb+resource ('Patch assembly instructions') and mentions the address-based target. But it does not distinguish itself from closely related siblings such as `patch`, `put_int`, or `define_code`, which an agent must choose between.

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 alternatives like `patch`, `define_code`, or `put_int`, nor any stated prerequisites. The one routing hint (call instance_list first) lives only in the instance_id schema field, not the description.

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

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

No annotations are provided, so the description carries the full disclosure burden for a mutation tool. It says 'write' but never covers reversibility, permission/routing requirements, batch semantics, or failure behavior, leaving significant gaps.

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 arguably under-specified for a write tool rather than overly verbose.

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 mutation tool with no annotations and no output schema, a one-line description is thin. It omits batch behavior, error/partial-write semantics, and any safety context an agent would need to invoke it confidently.

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

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

Schema description coverage is 100%, so `items`, `ty`, `addr`, `value`, and `instance_id` are already well documented in the schema. The description adds no extra meaning beyond that baseline, so a 3 is warranted.

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 ('Write') and resource ('integer values to memory addresses'), which is clear enough to act on. However it doesn't distinguish itself from neighbors like `patch` or note that it is the write counterpart to sibling `get_int`, and it omits that it accepts a batch of writes.

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 alternatives such as `patch`, `set_type`, or `get_int`. Nothing states prerequisites, ordering, or exclusions.

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

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

No annotations are supplied, so the description carries the full burden. It discloses only the auto-detect-type behavior and says nothing about read-only safety, permission/instance requirements, failure modes when the address or type cannot be resolved, or what is returned, leaving significant behavioral gaps for a memory-reading tool.

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

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

A single front-loaded sentence with zero filler; the action and the auto-detect caveat come first. It is appropriately sized, though extremely terse given how much is left unspecified.

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

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

With no output schema and no annotations, the description should carry more, but it omits the polymorphic nature of 'queries' (array vs single object), the batch semantics, and the return shape. For a tool taking a free-form address and an optional struct type across multiple instances, this 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?

At 50% schema coverage, the description must compensate, and it largely does not. It gestures at the 'addr' and optional 'struct' parameters but adds nothing beyond the schema's own field notes, and it never mentions the required 'instance_id' routing parameter whose usage guidance lives only in 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+resource ('Read struct fields from memory at address') and adds the auto-detection behavior. It is clear what the tool does, though it does not explicitly distinguish itself from nearby siblings like type_inspect or get_global_value, which also surface typed memory contents.

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, no when-not-to-use, and no named alternative. The description does not tell the agent when reading a struct this way beats calling get_bytes, type_inspect, or search_structs, so selection relies entirely on the name.

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

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

With no annotations, the description carries the full load and does so well: it discloses that the call is fire-and-forget (wakes the plugin daemon thread and returns immediately) and that the actual refresh is deferred until IDA reaches idle state. Auth/permission needs and failure modes are not covered, keeping it below 5.

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

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

Two compact sentences, front-loaded with the action and back-loaded with the important async caveat. No filler, though it could be slightly tighter.

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

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

For a single-parameter, no-output-schema tool the description is nearly sufficient: it covers what happens, when the effect actually lands, and that the call returns immediately. It lacks only edge-case behavior (e.g. what happens if the instance never goes idle).

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 schema already documents instance_id thoroughly, including the pointer to instance_list. The description adds nothing about the parameter, so the baseline 3 applies.

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

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

States a specific verb+resource ('request the specified IDA instance to refresh its local SQLite static cache') and even names the concrete artifact (xxx.idb.mcp.sqlite). Clear enough to distinguish from instance_list/cache_status, though it never explicitly names the sibling it is not.

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?

Implies usage via the async caveat (refresh only happens once IDA is idle), but gives no explicit when-to-use vs when-not, and does not mention cache_status as the sibling for inspecting the cache. Guidance is inferable but not 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that renames are batchable and that dry_run/options exist, but says nothing about whether renames persist to the database, permission/auth needs, conflict or partial-failure behavior, or what a rename of an already-named entity does. For a mutation tool this is a significant gap.

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

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

A single front-loaded sentence that names the scope of the operation plus a note on available options. No filler, though the '等选项' phrasing is slightly vague and the brevity edges toward under-specification rather than true concision.

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 nested schema is fully annotated and there is no output schema to explain, so parameter-level completeness is adequate. However, for an un-annotated mutation tool the description omits behavioral context (persistence, auth, failure semantics) that an agent would need to use it safely, leaving a real gap.

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

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

Schema description coverage is 100%, so the schema already documents batch sub-keys (func/data/local/stack), dry_run, stop_on_error and allow_overwrite. The description adds little beyond restating the rename categories, 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 (batch rename) plus the resources it operates on (functions, global/local/stack variables), matching the schema categories. Clear enough for an agent to know this is the symbol-renaming tool, though it does not explicitly distinguish itself from adjacent symbol tools like define_func or set_type.

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 indication of when to use this versus alternatives, no prerequisites, and no exclusion conditions. The only usage hint is the existence of a 'dry_run' option, which is offered rather than explained as a recommended first step.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only lookup but says nothing about result limits, whether matches include members or just names, or how results are ordered/returned.

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

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

A single front-loaded sentence with no filler. It is efficient, though very terse given the amount of behavioral information it omits.

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 search tool with no annotations and no output schema, the description is adequate on scope but silent on return shape and how matches are presented. Minimum viable, not complete.

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

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

Schema description coverage is 100%: the filter glob/substring semantics and the instance_id routing note are fully documented in the schema. The description adds nothing beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb (Search), resource (structs/unions), and scope qualifier (local, by name pattern), which distinguishes it from read_struct, type_query, and entity_query. It does not explicitly name a sibling alternative, 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?

The description gives no when-to-use guidance, no conditions that select this tool over read_struct/type_query/find, and no prerequisites beyond what the schema already states. 'local' hints at scope but does not route the agent among alternatives.

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

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

No annotations and no output schema, so the description carries the full burden. It discloses the pipeline and that hits are classified as disasm/comment, but says nothing about result ordering, permissions, performance/rate characteristics, or what the cursor-based pagination returns. For a paged search tool with zero structured coverage, this is a notable gap.

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

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

Two tight paragraphs with no filler; the core behavior is front-loaded. The internal API names are slightly implementation-flavored but justify the 'native C++ scan' claim, so they still earn their place.

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

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

For an 8-parameter, paged search tool with no output schema and no annotations, the description covers the return shape only in outline (one hit per EA, classified). It omits pagination/ordering expectations and the routing requirement of instance_id, leaving a few gaps an agent must fill from the 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%, so every parameter including limit, regex, start, include, and code_only is already documented in the schema. The description adds no syntax or format detail beyond that, 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?

It states a precise verb+resource ('search the rendered listing') and even names the mechanism (ida_search.find_text over generate_disassembly output). It clearly differentiates from raw-byte search by specifying 'rendered listing', though it stops short of naming the closest siblings (find, find_regex, find_bytes) 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 phrase 'rendered listing' implies this is for disassembly-text/comments rather than raw bytes, which hints at when it beats find_bytes. But there is no explicit when-to-use or when-not-to-use versus find, find_regex, or entity_query, leaving the routing decision mostly to inference.

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

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

No annotations are provided, so the description carries full burden. It discloses the key stateful behavior (subsequent calls are routed/re-routed to the selected instance) and the reset escape hatch (port=0), which are non-obvious and valuable. It stops short of describing failure modes or whether the current selection persists across sessions.

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

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

Front-loads the core action and effect in the first sentence, with reset instructions in a short second paragraph. Slightly repetitive with "call select_instance" recited twice, but there is little waste overall.

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?