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

No annotations are provided, so the description must convey behavioral traits. It discloses acceptance of both internal a_id and GUI-visible a_crc (8-char hex), which is useful. However, it does not mention that the tool is read-only, what 'detailed information' includes, or error cases like invalid IDs.

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: two sentences that cover purpose and parameter format without any unnecessary words. Every sentence adds value.

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

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

For a simple info retrieval tool with an output schema, the description adequately covers the essential use case. It could mention that the agent must exist or what happens on invalid IDs, but the presence of an output schema mitigates the need for extensive return 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?

With 0% schema description coverage, the description adds significant meaning by explaining the parameter 'agent_id' can be an internal a_id or an 8-char hex a_crc. This clarifies the accepted formats beyond the schema's bare string type.

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 clearly states 'Get detailed information about a specific agent by ID', specifying both the action and the resource. It differentiates from siblings like 'list_agents' by focusing on a single agent and mentions two accepted ID formats, making the tool's specificity clear.

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

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

The description does not explicitly state when to use this tool vs alternatives like 'list_agents' or 'kill_agent'. The context supports usage by needing an agent ID, but no guidance on exclusion or when-not-to-use is 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only mentions 'no elevated privileges needed' for one subcommand but fails to describe side effects, permissions required, or output format for most commands.

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 dense block of text with multiple subcommands and examples. It is not concise; it could be structured into sections or bullet points. Every sentence contains useful information, but the lack of formatting reduces clarity.

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

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

Given the tool's complexity (multiple subcommands) and the existence of an output schema, the description is incomplete. It does not mention return values, error states, or how to use the output. The agent must infer parameter usage from examples, which is insufficient.

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 0% coverage, so the description must compensate. It indirectly defines the 'command' parameter by listing subcommand names and shows usage via examples, but it does not explicitly describe parameter types, allowed values, or how 'args' relates to the syntax.

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

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

The description clearly states 'AD-BOF: Active Directory exploitation commands' and lists numerous subcommands, making the tool's purpose evident. However, it does not differentiate itself from sibling tools like bof_ldap or bof_adcs, which also target AD operations.

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 provided on when to use this tool versus alternatives. The description lacks any selection criteria or context that would help an agent decide between bof_ad and other bof_* tools.

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 provided, so the description must disclose behavior. It mentions attack types (e.g., PKINIT + UnPAC-the-hash, Shadow Credentials) and gives example commands, but lacks details on side effects, authorization needs, or safety.

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 well-structured with bullet points and examples, efficiently conveying multiple subcommands. It front-loads the purpose and avoids unnecessary verbosity, though it is somewhat lengthy due to the number of examples.

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

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

Given the complexity of ADCS attacks and the presence of an output schema, the description covers main use cases and examples. However, it lacks context on error handling, prerequisites, and when to use sibling tools, leaving some 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?

The input schema has generic parameters (agent_id, command, args) with 0% description coverage. The description compensates by showing how to structure the command and args via examples, but does not formally map the subcommand parameters to 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 clearly states the tool's purpose: 'ADCS-BOF: Active Directory Certificate Services attacks.' It lists specific subcommands like certi auth, enum, request, request_on_behalf, shadow with examples, making it distinct from sibling BOF tools.

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

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

No explicit guidance on when to use this tool versus alternatives. While the description shows what each subcommand does, it does not indicate prerequisites, scenarios, or when other tools might be more appropriate.

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

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

The description discloses some requirements (e.g., admin/SYSTEM privileges) and side effects (auto-saves to credentials tab). However, with no annotations, it could be more thorough about safety, data persistence, and error behavior.

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

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

The description is lengthy and dense with multiple subcommand details. It lacks a concise front-loaded summary, and the structure, while organized, could be more streamlined.

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

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

The description covers subcommands and their arguments well, but it omits details about the output schema (though not required) and the 'agent_id' parameter. It is complete enough for the tool's complexity but has 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?

Since schema coverage is 0%, the description effectively explains the 'command' and 'args' parameters through examples and usage strings. It adds meaning beyond the schema, though a direct mapping to parameters would be clearer.

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 clearly states the tool is for Windows credential extraction and lists specific subcommands. However, it does not differentiate from sibling tools like bof_kerbeus or bof_lateral, which may also deal with credentials.

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 provided on when to use this tool versus alternatives. The description only lists subcommands without explaining the appropriate context for each or when to choose this tool over others.

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 burden. It states the tool performs privilege escalation and UAC bypass, which are potentially destructive actions, but does not disclose side effects (e.g., system instability, detection risk) or prerequisites (e.g., admin rights, specific OS versions).

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 somewhat lengthy but well-structured with a one-line summary followed by a bullet list of subcommands and examples. It could be slightly more concise without losing essential information.

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

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

Given the tool's complexity (multiple subcommands), the description covers each with explanations and examples. An output schema exists, so return values are handled. However, it lacks behavioral context like potential side effects or permission 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?

Despite 0% schema description coverage, the description thoroughly explains the 'command' and 'args' parameters with examples for each subcommand, effectively compensating for the missing schema descriptions and clarifying parameter usage.

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

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

The opening line 'Elevation-BOF: Local privilege escalation to SYSTEM' clearly states the tool's purpose (escalation to SYSTEM) and distinguishes it from sibling tools like bof_ad or bof_execution which target different domains.

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 lists specific subcommands with examples but does not explicitly state when to use this tool versus alternatives, nor when not to use it (e.g., if already SYSTEM or lacking privileges). The examples provide some implicit guidance, but no clear usage boundaries.

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 burden. It mentions 'in-process (no fork-and-run)' but does not disclose potential destructive behavior, permissions, or side effects. The description is insufficient for transparency.

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 front-loaded with a clear title, but the examples take space. It is somewhat verbose and could be more streamlined while retaining necessary detail.

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

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

With 3 parameters and no schema descriptions, the description should provide more comprehensive guidance. It covers two subcommands but lacks details on error handling, return values, or additional options. The output schema is present but not described.

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

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

Schema coverage is 0% meaning no parameter descriptions. The description adds context for the 'command' parameter via examples, but does not explain 'agent_id' or 'args' individually. While partially compensating, it leaves gaps.

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

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

The description clearly states it's for in-process payload execution and lists two subcommands with examples. It identifies the tool as BOF execution, distinguishing it from other execution tools, but could be more specific about the overall 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?

Examples demonstrate usage for each subcommand, but there is no explicit guidance on when to use this tool versus siblings like execute_raw or execute_shell. The description lacks when-not-to-use and alternative suggestions.

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 fully disclose behavior. It mentions requirements for certain subcommands and lists technique numbers, but it does not discuss potential side effects, destructive actions, permissions, or error handling.

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 well-structured with separate sections for each subcommand and examples, making it easy to parse. However, it is somewhat lengthy and includes redundant formatting like line breaks that could be tightened.

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

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

The tool is complex with multiple injection methods. The description covers the main subcommands but lacks details on some pool party techniques and does not mention the output schema or return format, despite one existing. This leaves some gaps for an AI agent.

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%, meaning no parameter descriptions in the schema. The description adds meaning via command examples showing how to use 'command' and 'args' (e.g., inject-cfg 808 /tmp/shellcode.bin), but it does not explicitly define each parameter's purpose or format.

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

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

The description clearly states 'Shellcode injection into target processes' and lists specific subcommands for different methods. This makes the tool's purpose explicit, though it does not differentiate from sibling tools like bof_execution which may also involve execution.

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

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

The description provides examples and notes on when to use each subcommand (e.g., inject-32to64 requires 32-bit agent) but does not offer guidance on when to choose this tool over sibling tools or 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 full burden. It discloses some behaviors (e.g., 'without elevation via GSS-API' for tgtdeleg) but does not mention required permissions, destructive potential, rate limits, or side effects like ticket purging or password changes.

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 lengthy due to many subcommands but is well-organized with each line representing a command. It front-loads the overall purpose, but contains more detail than strictly necessary, reducing 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?

Given the complexity of Kerberos operations and the 3-parameter schema, the description covers the subcommands thoroughly. However, it lacks details on return values (though output schema exists), error conditions, and agent_id semantics, leaving 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 coverage is 0%, but the description adds significant value for 'command' and 'args' by listing all subcommands with required arguments and examples. However, 'agent_id' is not explained beyond its schema definition.

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 begins with 'Kerbeus-BOF: Kerberos ticket operations and attacks', clearly stating the tool's purpose. It lists many specific subcommands, making it distinct from sibling BOF tools like bof_ad or bof_creds.

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 Kerberos operations but does not explicitly state when to use this tool over alternatives. No 'when not to use' or comparisons to siblings are provided; context is clear but not directive.

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 disclose behavioral traits. It mentions 'requires admin' for runas-session but lacks details on destructive actions, prerequisites (e.g., admin for psexec), side effects (service creation), or safety profile. This leaves significant gaps for an AI agent.

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 well-structured with subcommands and examples, fitting the tool's complexity. Every sentence adds value, with no wasted content. It is front-loaded with the purpose and then detailed usage.

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

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

Given the tool has an output schema (not shown) and many sibling tools, the description covers subcommands adequately but omits general context like success/failure indications, async behavior, timeouts, and error handling. An agent may need to infer behavior from examples.

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

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

Schema coverage is 0%, so the description must fully explain parameters. While examples illustrate how 'command' and 'args' are used (e.g., 'jump psexec ...'), it does not define 'agent_id' or clarify that 'command' must be one of the listed subcommands. Partial compensation but insufficient.

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?

Description clearly states 'Spawn sessions and execute commands on remote targets' and enumerates subcommands for lateral movement. While it distinguishes from sibling tools like bof_execution implicitly through content, it does not explicitly differentiate, so a 4 is appropriate.

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

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

The description provides subcommand syntax and examples, implying when to use each variant (e.g., psexec vs scshell). However, it does not explicitly advise against using this tool for local execution or when alternatives like bof_execution are better, offering only implied 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 must cover behavioral traits. It mentions read/write/delete operations but does not disclose potential risks, required privileges, or side effects (e.g., destructive changes to AD). This omission is significant for a powerful 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?

The description is long but well-organized into read, write, and delete sections with bullet-point subcommands. It front-loads the core purpose and uses a clear structure. However, it could be more concise by summarizing categories without listing every subcommand.

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

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

Given the tool's complexity and the presence of an output schema, the description covers the range of LDAP operations. However, it lacks details on error handling, prerequisites, and how parameters interact with subcommands. The output schema may compensate for return values, but the description is incomplete for full usage.

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

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

Schema coverage is 0%, so the description must compensate. It lists possible command values for the 'command' parameter but does not explain how 'args' should be used or the format for agent_id. The enumeration of commands provides partial compensation but leaves ambiguity.

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

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

The description clearly states the tool's purpose: 'Full LDAP read/write/delete operations against Active Directory.' It lists specific operations, distinguishing it from sibling tools like bof_ad or bof_execution which cover different areas.

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

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

The description does not explicitly state when to use this tool versus alternatives. It lacks guidance on prerequisites, which operations are safe, or when to use sibling tools like bof_ad for non-LDAP AD tasks.

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 disclose behavioral traits. It lists commands and syntax (e.g., 'mssql clr' for CLR execution, 'mssql xpcmd' for command execution) but does not mention side effects, required permissions, destructiveness, or safety concerns. For a tool that can execute system commands, 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?

The description is long and detailed, listing many subcommands in a list format. It is front-loaded with the general purpose but becomes verbose. While the length is justified by the tool's complexity, it could be more structured (e.g., tables or grouping) to improve readability.

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

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

Given the tool's complexity (many subcommands) and the simple input schema, the description provides a comprehensive list of available commands and their syntax. However, it lacks information about prerequisites, permissions, and potential side effects. The presence of an output schema reduces the need to describe return values, but behavioral gaps remain.

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 3 parameters (agent_id, command, args) with 0% description coverage individually. The description compensates by listing over 20 subcommands that likely correspond to the 'command' parameter, with syntax examples (e.g., 'mssql query <server> <query>'). It adds meaning but does not explicitly map parameters to schema 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 opens with 'MSSQL-BOF: Microsoft SQL Server enumeration and exploitation', clearly stating the tool's purpose. It then lists many subcommands (e.g., 'mssql info', 'mssql query'), making it obvious that this tool is for MSSQL-related tasks, distinguishing it from sibling tools like bof_ad or bof_ldap.

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 MSSQL enumeration and exploitation but does not explicitly state when to use this tool versus alternatives. No 'when not to use' or alternative tool mentions are present. The context of siblings and the name partially guide, but explicit guidelines are lacking.

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 provided. The description does not disclose behavioral traits such as destructiveness, permissions required, side effects, or execution environment. The examples give minimal insight into behavior.

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

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

The description is relatively concise with a one-line summary followed by examples. However, it lacks clear structure (e.g., parameter explanations) and could be better organized for quick scanning.

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

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

Despite having an output schema, the description does not mention return values. It provides usage examples but no complete specification of what the tool returns or handles errors. Incomplete for an AI agent to reliably use.

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 has 3 parameters with 0% description coverage. The description includes subcommand syntax but does not explain agent_id or args parameters. It adds little meaning beyond the schema, leaving interpretation of command structure to the agent.

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 it's a 'PostEx-BOF: Post-exploitation utilities' and lists specific subcommands (firewallrule, screenshot_bof, sauroneye), clearly indicating it executes post-exploitation BOFs. It distinguishes from sibling bof_* tools by being the post-exploitation category, though not 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?

No explicit guidance on when to use this tool versus alternatives like bof_ad, bof_creds, etc. The description only lists subcommands without context on selection criteria.

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

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

No annotations provided. The description mentions PPL bypass for the freeze command, disclosing a critical behavioral trait. However, it fails to cover other aspects such as permissions, side effects, or the meaning of return values, leaving gaps in transparency.

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 overly long and repetitive, with multiple similar examples. It could be significantly condensed without losing information, yet it remains verbose without clear 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?

Given the tool's complexity (multiple sub-commands) and the lack of parameter documentation, the description is incomplete. The output schema exists but is not mentioned, and the description does not clarify what the tool returns for each sub-command.

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

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

Schema coverage is 0%, and the description does not explain the three parameters (agent_id, command, args). The examples imply that command is a sub-command and args are parameters, but the format is not explicitly defined, leading to ambiguity for an AI agent.

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 lists multiple sub-commands for process enumeration and manipulation but lacks a concise, single purpose statement. It does not differentiate from sibling tools like list_processes or kill_process, making it unclear when to use this tool versus others.

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?

Examples are provided for each sub-command, but there is no explicit guidance on when to use this tool versus alternatives. The description does not state prerequisites or conditions for use, leaving the agent to infer from the examples.

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 fully disclose behavior. It uses 'check' implying non-destructive read, but does not explicitly state it is read-only, lacks permissions or side-effect information, and does not clarify safety or potential impact.

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 well-structured with sections per protocol and clear examples, but it is somewhat verbose for an MCP tool description. It could be more concise while retaining essential information.

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

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

Given the tool's complexity with multiple subcommands and the presence of an output schema, the description covers the core functionality well. It explains what each subcommand does, though it lacks explicit mapping to the generic input schema parameters.

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

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

The schema has 0% description coverage, but the description compensates by showing concrete command and args values (e.g., 'http https://test.dom.local') and mapping to the command parameter. However, it does not explicitly explain the agent_id or args parameters, leaving some ambiguity.

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

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

The description clearly states the tool checks relay attack mitigations on remote services and lists specific protocols (HTTP, LDAP, MSSQL, SMB) with distinct checks. This differentiates it from sibling bof_* tools which target other security aspects.

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

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

The description provides explicit usage examples for each protocol variant (e.g., 'relay-informer http <url>'), giving clear context. However, it does not state when not to use the tool or mention alternative tools, but the examples sufficiently guide usage.

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 burden. It lists commands and their effects but does not disclose whether commands are read-only, destructive, or have side effects. While most commands appear safe, the description fails to explicitly state safety or behavioral 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?

The description is lengthy due to listing many commands, but the list format is clear and each line adds value. However, it could be condensed for readability without losing information.

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

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

While an output schema exists, its content is not shown and the description does not describe return values. For a host reconnaissance tool with many subcommands, the description adequately guides command selection but lacks output format details, which are important for an AI agent.

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 documentation coverage is 0%, but the description compensates heavily by enumerating valid commands and their argument syntax (e.g., 'cacls <path>', 'dir [directory] [/s]'). This provides essential meaning for the 'command' and 'args' parameters beyond the generic 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 clearly states the tool's purpose: 'SAL-BOF: Situational Awareness Local — Windows host reconnaissance.' It lists specific subcommands like arp, ipconfig, netstat, etc., making it distinct from sibling BOF tools that focus on AD, credentials, etc.

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

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

Usage is implied by the list of reconnaissance commands, but no explicit guidance is given on when to use this tool versus alternatives. Sibling tools have different domains (AD, credentials), but the description doesn't state 'use for local host recon' or 'not for network recon.'

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 behaviors for each subcommand, including side effects like 'nbtscan' auto-populating the Targets tab. It does not mention destructive actions, but the tool appears safe. The description could note prerequisites or limitations, but overall it is transparent.

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 well-structured with each subcommand on a new line, including a brief description and example. It is front-loaded with the overall purpose. While it is somewhat lengthy, every sentence adds value, and the format is easy to scan.

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

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

Given the moderate complexity and the existence of an output schema, the description covers essential usage. It provides enough information to invoke commands correctly. It could mention error handling or privilege requirements, but overall it is complete for an agent to use the 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?

The input schema has 0% coverage, so the description compensates by explaining the 'command' parameter values and the 'args' parameter format with examples. The 'agent_id' parameter is not explained, but its purpose is implied. The description adds significant meaning beyond the schema, though a structured breakdown of arguments could improve clarity.

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 clearly states the tool's purpose: 'SAR-BOF: Situational Awareness Remote — Network discovery and enumeration.' It then lists specific subcommands (smartscan, taskhound, quser, nbtscan) with their functions, distinguishing it from sibling tools like bof_ad or bof_ldap which focus on specific domains.

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

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

The description provides clear context for each subcommand with examples, implying when to use each (e.g., 'smartscan' for port scanning, 'taskhound' for scheduled tasks). However, it does not explicitly state when not to use this tool or suggest alternative siblings, but the examples sufficiently guide usage.

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 provided, so description must fully inform. It only states the action and gives an example path. It does not describe side effects (e.g., persistent change), error behavior, permission requirements, or impact on other operations like file reads. Also, it omits the crucial 'agent_id' parameter from the usage text.

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

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

Description is extremely concise with a clear verb, usage line, argument definition, and example. No wasted words. Front-loaded 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?

Despite having an output schema, the description does not explain return values or failure behavior. It omits the agent_id parameter entirely, making the description incomplete for correct invocation. The tool is simple but the description lacks necessary context.

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

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

Schema description coverage is 0%. The description explains 'path' as 'Target directory path', adding some meaning, but completely ignores the 'agent_id' parameter, which is required. This leaves half the parameters undocumented.

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

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

The description clearly states the verb 'Change' and resource 'current working directory of the agent process'. It is distinct from sibling tools like get_working_directory or list_directory which are read-only. The example further clarifies the 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?

No guidance on when or when not to use the tool. No mention of prerequisites, alternatives, or context. Sibling tools exist but no differentiation 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?

The description does not disclose any behavioral traits beyond the basic copy operation. No annotations are provided, so the description carries the full burden. It fails to mention whether the destination file is overwritten, permissions required, error handling, or any side effects. This is insufficient for an agent to understand the tool's full impact.

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 very concise, with a clear first sentence stating the purpose, followed by a usage line and parameter details. There is no unnecessary verbosity. However, the omission of 'agent_id' detracts from its efficiency, as it could have been included in the parameter list succinctly.

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

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

For a tool with 3 required parameters and no annotations, the description is incomplete. It lacks details about return values (despite having an output schema), agent_id parameter, and behavioral traits like overwrite behavior. The context signals indicate low coverage, and the description fails to compensate adequately.

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 description adds meaning for 'src' and 'dst' parameters with types and examples, and suggests an order via 'cp <src> <dst>'. However, it completely omits the required 'agent_id' parameter, which is not described or mentioned. Given schema description coverage is 0%, the description should compensate but fails to address all parameters.

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

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

The description states 'Copy a file on the agent' which clearly conveys the primary action and resource. The usage and example further clarify the intent. However, it does not explicitly differentiate from the sibling tool 'move_file' by stating that the source is not deleted after copying, which would be a minor improvement.

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

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

The description provides a usage format and example but offers no guidance on when to use this tool over alternatives like 'move_file' or 'remove_file'. There is no mention of prerequisites, best practices, or scenarios where this tool is preferred, which is a significant 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 must convey behavior. It explains the download operation and file path, and implies asynchronicity by referencing list_downloads. However, it omits details such as error handling, permissions, or confirmation that the file is saved on the teamserver.

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 relatively concise, front-loading the purpose, and includes a usage section with arguments and example. However, the phrase 'Task the agent to download' could be slightly tightened, and the structure is clear with 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?

Given the tool's complexity (2 required params, output schema exists), the description covers the download action and file path but omits prerequisites like agent connectivity and file existence. It references related tools but lacks full completeness for a 2-param mutation tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explains remote_path with example and full path requirement, but fails to describe agent_id, which is also required. Only one of two parameters is semantically enhanced.

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 clearly states 'download a file to the teamserver', specifying the verb, resource, and destination. It distinguishes from siblings like get_downloaded_file or list_downloads, and includes a concrete example.

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

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

The description provides usage context by showing the command format and example. It also references sibling tools list_downloads and get_downloaded_file for post-download steps, though it does not explicitly state when not to use this tool.

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

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

The only behavioral disclosure is 'Windows only'. With no annotations provided, the description carries full burden but fails to mention whether execution is blocking, error handling, or authorization needs. For a code execution tool, far more transparency is required.

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 with two lines: the first line states purpose, the second gives an example. No wasted words; front-loaded with core behavior.

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?

Despite having an output schema, the description omits crucial context: it does not mention that execution targets an agent via agent_id, nor does it discuss output structure, timeouts, or security implications. A PowerShell execution tool needs more 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 description adds meaning for the 'command' parameter by giving an example but does not describe 'agent_id' at all. Since schema description coverage is 0%, the description partially compensates but is incomplete.

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 clearly states 'Execute a PowerShell expression (Windows only)', which is a specific verb and resource. It distinguishes from sibling tools like execute_shell or execute_raw by specifying PowerShell and Windows-only constraint.

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 tool versus alternatives such as execute_shell or execute_raw. The description merely states it executes a PowerShell expression, leaving the agent to infer usage context without explicit when-to-use or when-not-to-use advice.

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 burden. It describes the execution behavior (AxScript engine, console-like parsing), but does not disclose safety aspects (e.g., destruction potential, permissions) or output behavior. Adequate but not comprehensive.

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

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

The description is three sentences, each adding value: purpose, parsing detail, usage guidance. No redundant words, front-loaded with key action.

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 complexity (2 required params, output schema present, many siblings), the description differentiates well but lacks information on prerequisites, error states, or potential side effects. Adequate but not fully 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?

With 0% schema description coverage, the description should compensate. It adds context for the 'cmdline' parameter (parsed as in console), but provides no additional meaning for 'agent_id' beyond its name. Partial coverage leaves gaps.

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

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

Description clearly states the tool executes a raw command string on an agent using the AxScript engine, and explicitly distinguishes itself from sibling tools by saying 'Use for advanced commands not covered by other tools.'

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

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

Explicitly advises when to use (for advanced commands not covered by other tools) and provides context on how the cmdline is parsed ('exactly as if typed in the agent console'), giving clear guidance on usage.

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

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

No annotations exist, so description must fully disclose behavior. It mentions OS-specific shells but omits side effects, output format, synchronous vs async execution, privilege requirements, and error handling. Minimal transparency for a shell execution 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?

The description is brief (two sentences plus example) and front-loaded. However, it could be more structured (e.g., separate parameter descriptions). No unnecessary 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?

Despite an output schema existing (reducing need for return value explanation), the description lacks usage guidelines, behavioral transparency, and complete parameter semantics. It is not comprehensive for a shell execution 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 coverage is 0%, so description must explain parameters. It describes 'command' with examples but completely omits 'agent_id', a required parameter. Adding meaning only for one of two parameters is insufficient.

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 clearly states the tool executes a shell command via cmd.exe or /bin/sh, providing specific verb and resource. Examples like 'whoami /all' reinforce purpose. It distinguishes from siblings like execute_powershell and execute_raw.

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 use for shell commands but does not explicitly state when to use this tool versus alternatives like execute_powershell or run_process. No when-not-to-use guidance or 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?

With no annotations, the description carries the full burden. It discloses the return format (base64-encoded text) but omits details like error handling or prerequisites beyond 'previously downloaded'. Adequate for a simple retrieval 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 concise sentences, each adding value: purpose, return format, and usage hint. No unnecessary 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?

Given the tool's simplicity (1 param, retrieval only) and the presence of an output schema, the description is largely complete. Could mention error behavior but not critical for basic understanding.

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

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

The single parameter 'file_id' lacks schema description, but the tool description adds meaning by linking it to file IDs from 'list_downloads'. This compensates for the 0% schema coverage.

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

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

The description clearly states it retrieves file content from a previously downloaded file, using specific verb 'retrieve' and resource. It distinguishes from siblings like 'download_file' and 'list_downloads'.

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?

Explicitly tells users to use 'list_downloads' to get file IDs, providing clear guidance on how to obtain the required input. Does not specify when not to use, but context 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?

With no annotations provided, the description effectively discloses behavior: it runs a native command and returns username and privilege level. This provides essential behavioral context without contradiction.

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 efficient, using three short sentences that convey purpose, execution method, and return value. No superfluous text.

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

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

The tool has only one required parameter and an output schema exists, so the description does not need to detail return values. However, it lacks usage context such as when to call this versus other tools, or any prerequisites. It is minimally complete but not thorough.

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

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

Schema description coverage is 0%, so the description should compensate. However, it only vaguely mentions 'Runs native getuid beacon command' without explaining the required agent_id parameter. The description adds little meaning beyond the parameter name 'agent_id'.

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

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

The description clearly states the verb 'Get' and the resource 'current user identity on the agent.' It mentions running the native 'getuid' beacon command, which precisely identifies the tool's action. Among many sibling tools, none directly target user identity, so it is well-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 explicit guidance on when to use this tool versus alternatives such as agent_info or other identity-related commands. The description does not mention prerequisites, exclusions, or typical use cases.

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

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

No annotations are provided, so the description bears the full burden. It states the tool prints the working directory and returns the absolute path, but does not explicitly disclose that it is read-only or any potential side effects (e.g., if agent_id is invalid). The description is adequate but lacks explicit safety cues.

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: three short sentences with the first sentence stating the core purpose. Every sentence adds value without verbosity.

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

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

Given that an output schema exists (as noted in context), the description appropriately explains the return value. The tool is simple, and the description covers the essential function. However, the missing explanation of the agent_id parameter slightly reduces 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 one required parameter (agent_id) with 0% schema description coverage. The description does not explain what agent_id represents or how to use it, failing to compensate for the lack of schema descriptions. This is a significant gap.

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

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

The description clearly states the verb 'Print' and the resource 'current working directory' with the scope 'of the agent process'. It is distinct from sibling tools like change_directory and list_directory.

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

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

The description includes a usage example ('Usage: pwd') but does not explicitly state when to use this tool versus alternatives or when not to use it. It provides minimal context for decision-making.

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 cover behavior. It only states it kills a job, omitting prerequisites, side effects, or whether the action is reversible. The destructive nature is implied but not elaborated.

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 concise and front-loaded, with no unnecessary words. However, it could include more parameter context without becoming 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?

The tool has two required parameters and likely an output, but the description is incomplete: it misses agent_id, behavioral details, and any return value information. Given the complexity, it fails to provide a complete picture.

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

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

Schema coverage is 0% (no descriptions). The description mentions task_id and its source (jobs_list output) but completely omits agent_id, a required parameter. This is a significant gap.

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

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

The description clearly states the action ('Kill'), the target ('background job'), and the means ('by task ID on an agent'). It is specific and distinguishes from sibling tools like kill_agent or kill_process.

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 indicates the task_id comes from jobs_list output, implying usage context. It does not explicitly exclude alternatives but is clear enough for typical use.

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 provided, and the description does not disclose behavioral traits such as authentication needs, rate limits, or whether it returns all jobs or requires pagination. It only implies a read 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?

The description is a single sentence that is concise and front-loaded with key information. It could be slightly more detailed without losing brevity.

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 list tool with one parameter and an output schema, the description is minimally adequate. However, it lacks context on job types, return value structure, or potential limitations.

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

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

Schema description coverage is 0%, and the description adds no meaning beyond the parameter name 'agent_id'. It implies the parameter identifies the agent but lacks format or constraints.

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 clearly states the tool lists long-running background jobs on an agent. It distinguishes from sibling tools like 'jobs_kill' and other listing tools by specifying the resource 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 guidance on when to use this tool vs alternatives. The description only states its function without context on prerequisites or scenarios.

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 discloses the key behavioral trait: removing the C2 record without killing the implant. It could mention reversibility or side effects, but the core behavior is well-stated.

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

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

Two sentences, no fluff, front-loaded with the purpose. Every sentence earns its place, and the limitation is clearly stated in the second sentence.

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

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

For a simple tool with one parameter and an output schema (not shown), the description is adequate. It covers the core action and limitation. Prerequisites or output format are not explained, but the output schema likely handles that.

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

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

The description does not add any meaning to the parameter 'agent_id' beyond what the schema provides. Since schema_description_coverage is 0%, the description should compensate, but it offers no guidance on how agent_id is used or formatted.

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

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

The description uses a specific verb 'Remove' and resource 'agent session', and clearly distinguishes from sibling tools by stating 'does NOT kill the implant process', which differentiates it from kill_process and jobs_kill.

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 explicitly states what the tool does and what it does not do, providing clear context for when to use it. However, it does not explicitly name alternatives or provide exclusion scenarios.

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

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

The description implies a destructive action (kill) but does not disclose what happens on success or failure, required permissions, or reversibility. Without annotations, the description should provide more behavioral context.

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

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

The description is concise with two sentences, but the second sentence is formatted as an argument docstring rather than a natural continuation. Still, it is efficient and front-loaded.

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

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

Despite having an output schema, the tool lacks usage guidelines, behavioral details, and full parameter descriptions. For a destructive tool with two required parameters and no annotations, the description is insufficient.

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

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

With 0% schema description coverage, the description must compensate. It explains the 'pid' parameter but omits 'agent_id', leaving one of two parameters undocumented. The context signals confirm low coverage.

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

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

The description clearly states the verb 'kill' and the resource 'a running process by PID', which is specific and distinguishes from siblings like 'run_process' and 'jobs_kill'.

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 provided on when to use this tool versus alternatives, such as when to kill a process vs. kill a job or run a new process. No prerequisites or exclusions are mentioned.

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 correctly implies read-only behavior by stating 'list' and enumerating return fields. It does not discuss permissions or side effects, but for a simple listing tool this is sufficient.

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 concise sentences: the first front-loads the action, the second lists output fields. No redundant information.

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

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

The tool has no parameters and an output schema is present. The description completely covers purpose and return format, leaving no gaps for a simple list operation.

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

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

There are zero parameters, and schema coverage is 100%. The description adds value by specifying the return fields, which is the main semantic burden for a parameterless tool.

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 clearly states the verb ('List') and resource ('all active agents'), and the return fields distinguish it from sibling tools like agent_info or kill_agent.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives (e.g., agent_info for details on a single agent). The context is implied but not stated.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as side effects, authorization requirements, or rate limits. The term 'harvested' is vague, and the description does not confirm whether the operation is read-only or has any other implications.

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

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

The description is a single, concise sentence with no wasted words. It is front-loaded with the key action and resource.

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

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

While the purpose is clear and an output schema exists, the description lacks usage context and behavioral transparency. It does not explain what constitutes 'harvested credentials' or provide any situational guidance.

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

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

The tool has no parameters, so schema coverage is trivially 100%. The description adds no parameter details, which is acceptable since the schema fully covers all inputs. Baseline for zero parameters is 4.

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 clearly states the action ('list'), the resource ('credentials'), and the scope ('harvested across all agents'). It distinguishes from sibling tools like bof_creds, which likely handle credentials at a more granular level.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., bof_creds). There is no context for when it is appropriate or inappropriate to call.

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

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

No annotations are provided, so the description must disclose behavioral traits. It implies a read operation on the agent's filesystem and handles both directories and files. However, it does not mention if it is destructive, requires special permissions, or the behavior for invalid paths. The safety profile is unclear but assumed safe.

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 with the purpose. The usage section is structured with arguments and example. Every sentence adds value, though the usage format partially repeats schema info. It earns a 4 for efficiency.

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

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

Given the output schema exists (presumably documenting return values), the description adequately covers the core functionality. However, it fails to explain the required 'agent_id' parameter, which is essential for invoking the tool. This omission reduces completeness.

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

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

Schema coverage is 0%, so the description must compensate. It describes the 'path' parameter with type, default, and usage, but completely omits the required 'agent_id' parameter. This leaves a critical gap for the agent to understand how to specify the target agent.

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 clearly states the tool lists directory contents or file details on the agent. It differentiates from siblings like 'change_directory' and 'list_disks' by specifying 'contents' and 'on the agent'. However, it could be more explicit about the format of output (e.g., just names or additional metadata).

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

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

The description provides a usage example and syntax but does not explicitly state when to use this tool versus alternatives (e.g., 'list_disks' for drives, 'read_file' for file content). No guidance on when not to use it or 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 burden. It states the tool lists drives, implying a read-only operation, but does not explicitly confirm safety (e.g., no destructive side effects). It also does not disclose any authentication requirements or error conditions. The description is adequate for a simple listing tool but lacks explicit behavioral details.

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 very concise (two lines) and front-loads the purpose. Every sentence serves a purpose: the first states the function, the second gives usage syntax and return description. It is appropriately sized for a simple tool, earning a high score for 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?

Given the tool's low complexity, the description covers the main function and return type. However, it fails to explain the required parameter 'agent_id', which is a significant gap. An output schema exists (as indicated by context), so return values are defined, but the lack of parameter documentation reduces completeness to an average score.

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 one required parameter 'agent_id' with no description coverage (0%). The tool description does not explain what 'agent_id' is or how to use it. Since the parameter is not self-documenting from its name alone (it could be a target agent identifier, but this is not clarified), the description fails to add value 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 clearly states the tool's purpose: 'List mounted drives on the agent system.' The verb 'list' and resource 'mounted drives' are specific and unambiguous. The sibling tools include list_directory, list_processes, etc., which are distinct operations, so this description adequately distinguishes the 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 provides a usage example ('disks') and mentions the return type, but does not explicitly state when to use this tool versus alternatives, nor does it provide any prerequisites or exclusions. While the purpose is clear, guidance on usage context is minimal, earning a mid-range score.

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 description carries full burden. It correctly indicates a read operation but does not disclose permissions, scope, or side effects. However, for a simple list operation, it is adequate.

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, clear sentence with no wasted words. It is front-loaded and 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?

The tool is simple with no parameters and has an output schema. The description provides enough context to understand its purpose without needing to explain return values.

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

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

No parameters are defined, so the description does not need to add parameter information. With 0 parameters, baseline score is 4 as per instructions.

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 clearly states the verb 'list' and the specific resource 'files that have been downloaded from agents to the teamserver', distinguishing it from siblings like 'get_downloaded_file' and 'download_file'.

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 explicit when-to-use or alternatives guidance, but the name and description imply usage for listing all downloaded files. Sibling 'get_downloaded_file' suggests an alternative for specific file retrieval.

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

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

With no annotations, the description carries the full burden. 'List all active listeners' implies a read-only, non-destructive operation, which is sufficient for this simple task. However, no additional behaviors (e.g., requiring admin privileges, limited to certain context) are disclosed, so it is adequate but minimal.

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 extraneous words. Every word contributes to the purpose.

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

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

For a simple list operation with no parameters and an existing output schema, the description provides complete context. It tells the tool's purpose, and the output schema handles return values.

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

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

There are zero parameters, so the description need not add parameter information. The baseline score of 4 applies, as the description is sufficient for a parameterless tool.

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 clearly states the verb ('List'), the resource ('active listeners'), and the scope ('on the teamserver'), making it immediately understandable. It distinguishes itself from sibling list tools like list_agents and list_credentials by focusing on listeners.

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 explicit guidance on when to use this versus alternatives is provided. The description implies that it is for viewing active listeners, but given many sibling list tools, explicit hints (e.g., 'Use list_agents for agents') would be helpful.

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

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

The description accurately reveals that it runs the 'ps list' beacon command and specifies the return fields. No annotations exist, so the description effectively communicates the read-only nature.

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 with three sentences, no unnecessary words, and key information front-loaded.

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

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

The description covers purpose, behavior, and return format, but lacks parameter explanation and usage context. It is adequate for a simple tool but incomplete regarding the required input.

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 only parameter, agent_id, is not mentioned in the description. With 0% schema coverage, the description fails to explain the parameter's meaning or purpose.

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 clearly states the verb 'List' and the resource 'running processes on the agent host', distinguishing it from sibling tools like kill_process or run_process.

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 explicit guidance on when to use this tool versus alternatives. While the purpose is clear, the description does not mention exclusions or alternative tools for related tasks.

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 convey behavioral traits. It implies a read-only operation (listing) with no side effects. However, it does not disclose any additional traits such as authentication needs, rate limits, or whether the results are cached or real-time. For a simple list tool this is adequate but not exhaustive.

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 sentence that immediately conveys the action and resource. There is no extraneous information, and every word is necessary.

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

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

Given the tool's simplicity (no parameters, an output schema exists), the description sufficiently defines the tool's purpose. It could optionally mention the return format or that it retrieves all targets, but the existing output schema likely covers that. Overall, it is complete enough for straightforward usage.

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

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

The tool has zero parameters, so the input schema is fully covered by default. The description adds meaning by specifying what is listed (targets/hosts) and the scope ('all known'), which is beyond the empty schema. A baseline of 4 is appropriate given the 0-parameter case.

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 clearly states the verb 'list' and the resource 'targets/hosts', and specifies the scope ('all known' and 'in the teamserver database'). It is distinct from sibling tools like list_agents or list_listeners, which focus on different entities.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., other list_* tools). There is no mention of prerequisites, exclusions, or context of use, leaving the agent to infer 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 discloses that the tool returns recent commands, timestamps, statuses, and outputs. However, it does not mention any potential side effects, authentication requirements, or limitations like pagination, leaving some behavioral traits undisclosed.

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

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

The description is three sentences long, front-loaded with the main purpose, and every sentence adds value. No wasted words; it is concise and 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?

Given the tool's simplicity (2 parameters, no nested objects, output schema exists), the description covers the core purpose, return fields, and usage advice. It is sufficiently complete for an agent to understand when and how to invoke the tool, though it could mention the output schema or limit format.

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% (no parameter documentation in description). The description implicitly hints at 'agent_id' via 'specific agent' and 'limit' via 'recent', but does not explicitly describe the parameters or their formats, failing to compensate for the low schema coverage.

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

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

The description clearly states the verb 'Show' and resource 'execution history for a specific agent', matching the tool name 'list_task_history'. It distinguishes from sibling tools like 'list_agents' (which lists agents) and 'list_processes' (which lists processes).

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 explicitly advises using the tool 'to avoid repeating commands if results are recent and valid', providing clear usage context. While it doesn't specify when not to use it, the guidance is helpful for optimal usage.

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 provided; description carries burden. It mentions 'active' but doesn't disclose permissions, side effects, or what 'active' entails. Simple read operation, so minimal 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?

Single sentence, no wasted words. Adequately concise but could add a bit more context without becoming 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?

Simple tool with output schema (not shown). Description covers basic purpose but lacks details on return format or example usage. Adequate but not thorough.

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?

No parameters (0 params), schema coverage 100%. Baseline 4 applies. Description adds no parameter info, but none needed.

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?

Description clearly states verb 'List', resource 'active tunnels', and specifies types (SOCKS proxies, port forwards). Distinct from sibling tools like start_socks4, stop_tunnel.

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 explicit when-to-use or when-not-to-use guidance. Context implies it's for inspecting tunnels, but description lacks direct guidance on 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 provided, the description must fully disclose behavior. It only states that findings are logged to local session notes but does not mention if the operation appends or overwrites, error behavior, or any side effects.

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 concise: one sentence for purpose followed by a bullet-list of arguments. Every sentence is necessary and front-loaded. No extraneous information.

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

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

For a simple logging tool with 4 string parameters, the description adequately covers the parameters' meanings. However, it does not mention the return value (though an output schema exists but is not shown) or error handling, leaving some ambiguity about what the agent can expect after invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It provides clear, meaningful explanations for all four parameters (agent_id, category, content, context), including examples for category. It adds substantial value beyond the schema's bare titles.

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 clearly states the verb 'log' and the resource 'finding' with examples of what qualifies as a finding (credential, secret, important file) and the destination (local session notes). However, it does not explicitly differentiate from sibling tool 'save_writeup', which could be used for similar note-taking purposes.

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

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

No guidance is provided on when to use this tool versus alternatives like 'save_writeup' or 'list_credentials'. The description lacks context about prerequisites or scenarios where this tool is appropriate.

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

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

No annotations provided, so the description carries full burden. It only states the creation action but does not disclose error handling, overwrite behavior, or 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?

The description is very concise with a clear first sentence. However, the usage line is somewhat redundant with the parameter description.

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?

Despite having an output schema, the description does not mention return values or error states. It is incomplete for a tool that may have side effects or require agent context.

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?

Describes only the 'path' parameter, ignoring the required 'agent_id' parameter. Schema description coverage is 0%, and the description does not compensate for the omitted parameter.

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

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

The description clearly states 'Create a directory on the agent' with a specific verb and resource. It is distinct from sibling tools like list_directory or change_directory.

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

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

No guidance on when to use this tool versus alternatives (e.g., when to use make_directory vs. other file operations). No prerequisites or exclusion criteria 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 provided, so description carries full burden. It mentions move/rename but omits details like overwrite behavior, permissions, or return value. Also fails to mention the required agent_id parameter.

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

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

Description is concise with usage, arguments, and example. Slightly repetitive of schema info but overall 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?

Despite output schema and simple purpose, description fails to address agent_id, error conditions, or overwrite behavior. Incomplete for a tool with multiple required 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 coverage is 0%, and description only adds meaning for src and dst (source/destination paths). The required agent_id parameter is undocumented in the description.

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

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

The description clearly states the verb 'move' and resource 'file', and distinguishes from sibling tools like copy_file (duplicate) and remove_file (delete).

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 usage syntax and example but does not explicitly state when to use this tool over alternatives like copy_file or remove_file. Lacks contextual 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?

With no annotations, the description carries the full burden. It explains the forward mapping and notes it returns a tunnel ID, but lacks details on side effects, error handling, or required permissions. The behavior is described adequately but not comprehensively.

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 sentence plus a concise format specification. There is no extraneous information, and it is well-structured for quick comprehension.

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 6 parameters and no annotations, the description covers the core concept but omits parameter descriptions for agent_id and description, and does not address edge cases or return value details beyond mentioning the tunnel ID. It is adequate but leaves 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 coverage is 0%, so the description must compensate. It explains the roles of lhost/lport as local and target_host/target_port as remote, but does not individually describe agent_id or description. This adds some meaning beyond the schema but is incomplete.

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 clearly identifies the tool's function: starting a local port forward through an agent, with a specific direction format (lhost:lport → thost:tport). It distinguishes itself from sibling tools like reverse_port_forward and stop_tunnel by specifying 'local port forward' and returning the tunnel ID.

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 port forwarding but does not explicitly state when to use this tool versus alternatives like reverse_port_forward or when not to use it. No guidance on prerequisites or context is 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 burden. It discloses the truncation to 2048 bytes, which is a key behavioral trait. However, it does not address errors (e.g., file not found) or output format, leaving gaps in understanding.

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 concise with four lines, front-loading the key purpose. The usage and example are clear, though the 'cat <path>' notation might be mildly confusing. Overall, 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?

The output schema exists, so return values are not needed. However, the description misses the agent_id parameter and does not cover error cases or edge conditions. Given the presence of many sibling file tools, more context would help.

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

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

With 0% schema description coverage, the description must compensate. It explains the 'path' parameter (absolute path) but completely ignores the 'agent_id' parameter, which is required. This is a significant omission.

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 it reads the first 2048 bytes of a file, which is a specific verb and resource. It distinguishes itself from sibling tools like download_file (full content) and copy_file. However, it omits the agent_id parameter, which is part of the tool's identity.

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

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

The description provides a usage example but does not explicitly state when to use this tool versus alternatives like list_directory or download_file. There is no guidance on when not to use it or what prerequisites are needed.

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

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

The description implies destructive behavior (removal) but does not elaborate on permanence, recursion, or error handling. While the action is clear, additional details like 'permanently deletes' or 'requires write permissions' would improve transparency.

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 concise and front-loaded with purpose, followed by a usage example. However, the structure could be improved by including all parameters in the description.

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

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

Given the tool's simplicity and the existence of an output schema (not shown), the description covers the basic action. However, the omission of the agent_id parameter and lack of details on success/error behavior reduce 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 description documents the 'path' parameter with type and example, but completely omits the 'agent_id' parameter, which is required by the schema. With 0% schema coverage, the description fails to compensate for undocumented parameters.

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

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

The description clearly states the tool's purpose: 'Remove a file or folder on the agent.' The verb 'Remove' and resource 'file or folder' are specific, and it distinguishes from sibling tools like copy_file or move_file.

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 tool versus alternatives such as move_file or list_directory. The description only provides syntax, not context for selection.

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

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

No annotations are provided, so the description carries full burden. It explains the basic flow but omits important behavioral traits: what happens if agent_id is invalid, whether the agent must be active, error handling, connection lifetime, or side effects on the agent. The description does not disclose whether the tool is destructive or requires special permissions.

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

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

The description is concise at two sentences, front-loading the verb and resource. Each sentence adds value: action/mechanism and return value. However, it could be restructured to include parameter explanations without adding much length.

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?

Despite having an output schema, the description minimally covers context. It does not explain the lifecycle of tunnels, connection limits, error scenarios, or how the tunnel ID is used (e.g., with stop_tunnel). For a tool with 5 parameters and network state modification, more contextual detail is necessary for confident use.

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%, meaning the schema provides no parameter documentation. The description does not explain any of the five parameters. It mentions 'port' and 'thost:tport' without mapping to parameter names. The required parameters agent_id, port, target_host, target_port, and optional description are left entirely to the agent's inference.

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 clearly states the action 'Start a reverse port forward' and explains the mechanism: agent listens on a port and forwards to a target host:port from the teamserver. It also specifies the return value (tunnel ID), which helps distinguish it from forward port forwarding (port_forward) and SOCKS proxies (start_socks4/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 does not provide any guidance on when to use this tool versus alternatives like port_forward or start_socks. It lacks when-not-to-use conditions or prerequisite context (e.g., agent must be online). With several sibling tools for tunneling and proxying, clearer usage differentiation is needed.

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

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

No annotations are provided, and the description fails to disclose critical behavioral traits such as security implications (e.g., running arbitrary programs), potential for system impact, or need for permissions. This is a serious gap for a tool that executes processes.

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 brief and uses bullet points for parameters, making it scannable. However, the first line is slightly redundant with the tool's name, and the format could be tightened slightly.

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

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

Given the tool's nature (executing programs on a host), the description is insufficient. It lacks details on return values (despite an output schema), error handling, timeouts, or security contexts. The simplicity of the tool is not matched by adequate completeness for safe use.

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

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

With 0% schema description coverage, the description compensates well by explaining each parameter's CLI flag and providing an example for 'args'. The meanings of 'suspend', 'with_output', and 'impersonate' are clarified beyond their schema titles.

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 clearly states the verb ('Run') and resource ('program on the agent host'), using a specific invocation ('ps run'). It distinguishes itself from siblings like execute_shell, execute_raw, bof_process by implying it's for running arbitrary executables with arguments.

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 tool versus alternatives (e.g., execute_shell for command execution). There is no mention of prerequisites, limitations, or when not to use it, leaving the agent without context for selection.

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

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

No annotations are provided, so the description must convey behavioral traits. It only says 'Save,' implying a write operation, but does not disclose whether it overwrites existing entries, requires specific permissions, or has any side effects. The description lacks detail on consequences or 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?

The description is two sentences, concise and to the point. It first states the action and example, then states the purpose. No unnecessary words, but it could be slightly more structured by defining each parameter.

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

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

Given the simple schema (3 required string parameters) and no annotations, the description provides minimum viable completeness. It explains the overall purpose and usage but leaves gaps in parameter roles and output behavior. The existence of an output schema (not shown) might compensate, but the description alone is incomplete.

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

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

With 0% schema description coverage, the description should compensate, but it only adds minimal context. The parameters agent_id, title, and writeup are not explained beyond the example. The description mentions 'writeup' and 'action' but does not clarify the role of agent_id or title semantics.

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 clearly states the function: 'Save a short writeup or explanation of an action' with a concrete example ('how you elevated privileges'). It distinguishes the tool from siblings like log_finding by specifying it's for recording successful techniques for later review, but does not explicitly differentiate it from similar tools.

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

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

The description provides context on when to use the tool: after an action to record a technique. It says 'Use this to record successful techniques for later review,' which implies usage but does not specify when not to use or mention alternatives like log_finding.

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 states the basic action. It does not disclose behavioral aspects like immediacy of effect, side effects, or required permissions.

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

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

Two sentences with no unnecessary words. The purpose is front-loaded, and the format is highly 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?

The tool has an output schema, so return values are not required. For a simple configuration change, the description is minimally adequate but lacks context on interaction with other tools or agent state.

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

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

Schema coverage is 0%, so the description must compensate. It lists sleep_seconds and jitter_percent with types and a default, but does not explain their meaning or valid ranges beyond what is 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?

The description clearly states the tool changes the agent's sleep interval and jitter, using a specific verb+resource. It distinguishes itself from sibling tools which cover different actions like listing, execution, or file operations.

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 provided on when to use this tool, prerequisites, or when not to use it. The description lacks explicit context for usage decisions.

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 partially covers behavior by stating it starts a proxy tunnel and returns a tunnel ID, but does not disclose potential side effects, authentication needs, or constraints like requiring a live agent.

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 concise sentences with no extraneous information, front-loaded with the action and key result.

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 4 parameters, no annotations, and no parameter descriptions in schema, the description is too minimal. It does not cover parameter semantics nor provide enough context for correct invocation.

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

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

The input schema has 0% description coverage, and the description does not explain any parameters (agent_id, lhost, lport, description). Users have no guidance on what values are valid or how they affect the operation.

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 clearly states the verb 'Start' and resource 'SOCKS4 proxy tunnel', specifies it binds a listener on the teamserver host, and distinguishes from siblings like start_socks5 by mentioning SOCKS4 protocol.

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 SOCKS4 tunneling but provides no explicit guidance on when to use this tool versus alternatives like start_socks5, nor any exclusions or 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?

With no annotations, the description bears full responsibility for behavioral disclosure. It only states that a listener is bound on the teamserver host and returns a tunnel ID, but omits side effects (e.g., does it modify agent configuration?), authorization requirements, potential blocking behavior, or error conditions (e.g., port already in use).

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 concise at two sentences without redundancy. However, it could pack more value without increasing length significantly, e.g., mentioning the output format or common pitfalls.

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?

Despite having 7 parameters and a complex operation (starting a proxy tunnel), the description is minimal. It does not explain the return value format (tunnel ID), error handling, or prerequisites like agent connectivity. The presence of an output schema is noted but not included, so the agent cannot rely on it for completeness.

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

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

Schema description coverage is 0%, and the description does not explain any parameter. While 'agent_id', 'lhost', and 'lport' are somewhat self-explanatory, critical details like whether 'lhost' refers to the teamserver or agent interface, or the purpose of 'use_auth', 'socks_username', and 'socks_password' are left entirely to the agent's inference from the schema names.

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 clearly states the tool starts a SOCKS5 proxy tunnel, specifying the verb 'start' and the resource 'SOCKS5 proxy tunnel'. It distinguishes from the sibling tool 'start_socks4' by specifying the protocol version. The action and outcome are well-defined.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'start_socks4' or other tunneling tools. It does not mention prerequisites (e.g., agent must be online) or situations where this tool should not be used.

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 responsibility. It only states that the tool stops an active tunnel, but does not disclose side effects, required permissions, or what happens if the tunnel is not found. This is insufficient for a mutation 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?

The description is concise with two sentences, front-loading the action and providing a key reference. Every word earns its place without unnecessary detail.

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

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

Given the simplicity of the tool (single parameter, no annotations), the description covers the essential purpose and prerequisite. However, it could include brief information about error handling or the output schema for 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 parameter 'tunnel_id' is explained only as 'its ID' in the description. Schema description coverage is 0%, so the description should compensate further. It partially does by linking to list_tunnels, but it does not specify the format or examples of the ID.

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

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

The description clearly states the action 'Stop an active tunnel' and specifies the required parameter 'tunnel_id'. It also distinguishes the tool from its sibling 'list_tunnels' by referencing 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 provides a clear prerequisite: 'Use list_tunnels to find tunnel IDs.' This guides the agent on when to use this tool. However, it does not explicitly mention when not to use it or discuss any 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, and the description lacks behavioral details such as authorization requirements, side effects, or whether the operation is reversible. For a tool with no annotations, the description should compensate but does not.

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 concise sentences with no waste. The first sentence states the purpose, and the second clarifies parameter format. Information is front-loaded.

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

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

Given the tool's simplicity and presence of an output schema, the description does not mention return values or output format. It adequately covers the basic action but misses some completeness for a standalone 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?

The description adds meaning to the 'agent_ids' parameter by specifying it is a comma-separated list, which is beyond the schema's plain string type. However, the 'tag' parameter is not explained, so coverage is incomplete.

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 clearly states the tool sets a text tag on agents for organization, using a specific verb ('Set') and resource ('agents'). It distinguishes itself from sibling tools which are primarily execution, file, and process management tools.

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

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

No guidance is provided on when to use this tool versus alternatives, or any prerequisites or exclusions. The description merely states the function without 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?

No annotations provided, so the description bears full burden. It indicates a read operation with no side effects, but lacks details on return format, authentication needs, or rate limits. Adequate but not enriched.

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

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

Single sentence, 8 words, no wasted text. Front-loaded with the action and resource.