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 but only states the basic action. It doesn't mention critical traits such as whether execution is safe/read-only, potential side effects (e.g., modifying game state), authentication needs, rate limits, or error handling, leaving significant gaps for an 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 a single, efficient sentence with zero wasted words, clearly front-loading the core action. It's appropriately sized for a simple tool, making it easy for an agent to parse quickly.

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 executing code in a Roblox context, the description is incomplete. With no annotations and no output schema, it lacks details on behavioral risks, return values, or error cases. Siblings suggest a debugging/analysis context, but this isn't addressed, leaving the agent under-informed.

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

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

The schema description coverage is 100%, with the parameter 'code' well-documented in the schema as 'The Lua code to execute.' The description adds no additional meaning beyond this, such as syntax examples or constraints, so it meets the baseline for high schema coverage without compensating value.

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 ('Execute') and target ('a Lua script in the Roblox context'), making the purpose understandable. However, it doesn't differentiate from siblings like 'read_script' (which might retrieve code) or 'fire_remote' (which might trigger events), leaving room for confusion in tool selection.

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. For example, it doesn't specify if this is for testing scripts, modifying game state, or debugging, nor does it mention prerequisites like required permissions or risks compared to siblings like 'remote_spy_start'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool finds instances but doesn't describe what 'instances' are in this context (e.g., game objects, scripts), the search scope (e.g., partial matches, case sensitivity), return format, or potential limitations (e.g., performance impact). This is inadequate for a search tool with no annotation support.

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, efficient sentence: 'Find instances by ClassName or Name pattern.' It is front-loaded with the core purpose, has zero redundant words, and is appropriately sized for the tool's complexity. Every part of the sentence contributes essential information without waste.

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 (search functionality with 3 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'instances' are, the search behavior (e.g., wildcards, exact matches), or the return structure. For a tool with no structured support, more context is needed to guide effective 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?

The input schema has 100% description coverage, with clear parameter definitions (e.g., 'query' as 'Name or pattern to search for'). The description adds minimal value beyond the schema by mentioning 'ClassName or Name pattern,' which aligns with the 'query' and 'className' parameters. Since schema coverage is high, the baseline score of 3 is appropriate, as the description doesn't significantly enhance parameter understanding.

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: 'Find instances by ClassName or Name pattern.' It specifies the verb ('Find') and resource ('instances'), and mentions the search criteria (ClassName or Name pattern). However, it doesn't explicitly differentiate from sibling tools like 'get_children' or 'getgc_find', which might also retrieve instance-related data, leaving some ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context (e.g., when searching by ClassName vs. Name), or exclusions. Given sibling tools like 'get_children' and 'getgc_find', the lack of comparative guidance is a significant gap, leaving the agent to infer 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 carries the full burden of behavioral disclosure. It states the action ('fire' or 'invoke') but lacks details on permissions required, side effects (e.g., whether it modifies game state), error handling, or response behavior. This is inadequate for a tool that likely involves remote execution.

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, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and wastes no space, making it highly 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 complexity of remote invocation (likely involving game scripting or debugging), no annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like safety, return values, or error conditions, which are crucial for effective tool use in this 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 100%, so the input schema already documents both parameters ('path' and 'args') adequately. The description adds no additional meaning beyond what the schema provides, such as examples of valid paths or argument types, meeting the baseline for high 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 ('fire' or 'invoke') and the resource ('RemoteEvent' or 'RemoteFunction'), making the purpose specific and understandable. However, it doesn't explicitly differentiate this tool from its siblings like 'execute_script' or 'remote_spy_start', which might also involve remote interactions in some contexts.

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. It doesn't mention any prerequisites, exclusions, or specific contexts (e.g., for debugging vs. production), leaving the agent to infer usage based on the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but lacks details on permissions, rate limits, error handling, or the format of returned data (e.g., structure type, pagination). For a read operation with zero annotation coverage, this is a significant gap 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 a single, efficient sentence that directly states the tool's function without unnecessary words. It's front-loaded and appropriately sized for its purpose, with every part contributing to understanding.

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 retrieving hierarchical data in Roblox, no annotations, and no output schema, the description is incomplete. It doesn't explain the return format (e.g., list of instances, nested structure), error conditions, or how it interacts with sibling tools, leaving gaps for effective agent 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?

The input schema has 100% description coverage, with the 'path' parameter well-documented in the schema. The description adds minimal value by implying the tool retrieves children based on an instance path, but doesn't provide additional syntax, examples beyond the schema's default, or clarify edge cases, meeting the baseline for high 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 'Get' and the resource 'structure of the Roblox DataModel (children of a specific instance)', making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'find_instances' or 'get_properties', which might also retrieve instance-related data, so it misses full sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context for selecting it over siblings like 'find_instances' or 'get_properties', or any exclusions, leaving the agent to infer usage based on the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves connections but doesn't explain what 'connections' entail (e.g., data structures, permissions), whether this is a read-only operation, potential side effects, or response format. For a tool with no annotation coverage, this leaves significant gaps in understanding its 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core action and target, making it easy to parse quickly.

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 retrieving 'connections' (which could involve various data types or permissions), no annotations, and no output schema, the description is incomplete. It doesn't explain what 'connections' are, the return format, or any limitations, leaving the agent with insufficient context to use the tool effectively beyond basic parameter 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 schema description coverage is 100%, with both parameters ('path' and 'event') documented in the input schema. The description doesn't add any additional meaning beyond what the schema provides (e.g., clarifying 'path' format or 'event' examples beyond the schema's 'e.g., 'Changed', 'Touched''). Baseline 3 is appropriate as the schema handles the parameter documentation adequately.

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 ('Get all connections') and target ('on a specific event/signal of an instance'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate this tool from its siblings like 'get_children' or 'get_properties', which might also retrieve related data from instances.

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 mentions 'specific event/signal' but doesn't clarify prerequisites, exclusions, or compare it to sibling tools like 'get_hidden_properties' or 'remote_spy_get_logs' that might handle similar data retrieval in different contexts.

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 mentions the tool is 'useful for finding hidden functions,' which hints at a read-only, investigative purpose, but doesn't disclose critical behavioral traits like whether it's safe (non-destructive), requires specific permissions, has rate limits, or what the output format looks like. For a search tool with zero annotation coverage, this is a significant gap 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 a single, efficient sentence that front-loads the core action (searching the Lua garbage collector) and key parameters, with a second clause explaining utility. Every word earns its place, with no redundancy or unnecessary elaboration, making it highly 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 complexity (searching the Lua GC with multiple parameters) and lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., a list of functions/tables, error handling), behavioral constraints, or integration with sibling tools. For a tool with no structured output and zero annotation coverage, more context is needed to be fully helpful.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters (constants, upvalues, name, type) with clear descriptions. The description adds minimal value beyond the schema by mentioning 'constants, upvalues, or name patterns' and the purpose of finding hidden functions, but doesn't provide additional syntax, format details, or examples. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool searches the Lua garbage collector for functions/tables using specific criteria (constants, upvalues, name patterns), with a specific purpose of finding hidden functions. It distinguishes from siblings like 'get_upvalues' (which likely retrieves upvalues rather than searching by them) and 'find_instances' (which might search for instances rather than GC objects). However, it doesn't explicitly contrast with all siblings, keeping it at 4 instead of 5.

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

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

The description implies usage for 'finding hidden functions,' suggesting it's for debugging or reverse-engineering scenarios. It doesn't provide explicit when-to-use vs. when-not-to-use guidance or name alternatives among siblings (e.g., when to use this vs. 'find_instances' or 'get_hidden_properties'). The context is clear but lacks detailed exclusions or comparisons.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves hidden/internal properties, implying a read-only operation, but does not address potential risks (e.g., accessing sensitive data), permissions required, rate limits, or what happens if properties are invalid. For a tool with no annotations, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded with the core action and resource, making it easy to parse. Every part of the sentence earns its place by conveying 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 lack of annotations and output schema, the description is incomplete for a tool that accesses hidden properties. It does not explain what 'gethiddenproperty' entails, the format of returned data, potential errors, or security implications. For a tool with no structured behavioral data, more context is needed to ensure safe and effective 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?

The description does not add meaning beyond what the input schema provides. The schema has 100% description coverage, clearly defining 'path' and 'properties' parameters. The description mentions 'instance' and 'hidden property names,' which align with the schema but do not provide additional context, syntax, or examples. With high schema coverage, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Get hidden/internal properties of an instance using gethiddenproperty.' It specifies the verb ('Get'), resource ('hidden/internal properties'), and method ('using gethiddenproperty'). However, it does not explicitly differentiate from sibling tools like 'get_properties' or 'get_upvalues', which likely retrieve different types of properties.

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. It does not mention any context, prerequisites, or exclusions, such as when to prefer 'get_properties' for non-hidden properties or 'get_upvalues' for upvalues. Without such information, the agent lacks clear usage direction.

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 mentions the return values (Name, ClassName, Path, Properties, Attributes), which adds some behavioral context, but doesn't cover critical aspects like whether this is a read-only operation, permission requirements, error handling, or rate limits. For a tool with no annotations, this leaves significant gaps.

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

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

The description is a single, efficient sentence that front-loads the purpose and lists return values. It's appropriately sized with no wasted words, though it could be slightly more 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 complexity (2 parameters, no output schema, no annotations), the description is minimally adequate. It covers the purpose and return values, but lacks details on usage guidelines, behavioral traits, and doesn't fully compensate for the absence of annotations and output schema.

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

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

The schema description coverage is 100%, so the schema already documents both parameters ('path' and 'properties') fully. The description doesn't add any additional meaning beyond what's in the schema, such as examples or constraints, but it doesn't need to since the schema is comprehensive.

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 'properties and attributes of an instance', specifying what the tool does. It distinguishes from siblings like 'get_children' or 'get_hidden_properties' by focusing on properties and attributes, but doesn't explicitly differentiate from them.

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 'get_hidden_properties' or 'find_instances'. The description lacks context about prerequisites, exclusions, or comparisons to sibling 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 are provided, so the description carries full burden. It doesn't disclose behavioral traits such as whether this is a read-only operation, potential performance impacts, error conditions, or what the output looks like. The mention of 'getgc or other means' hints at context but lacks specifics on dependencies or limitations.

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 front-loaded with the core action ('Get upvalues of a function'), making it efficient. However, the phrase 'found via getgc or other means' could be more precise, slightly reducing clarity without adding 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?

Given no annotations, no output schema, and a single parameter with full schema coverage, the description is incomplete. It doesn't explain what 'upvalues' are, how to interpret results, or provide context for use with siblings like getgc_find. For a tool in a debugging/inspection context, this leaves significant gaps.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter 'functionIndex' with its description. The description adds no additional meaning beyond what the schema provides, such as format details or usage examples. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description states the tool retrieves upvalues of a function, which is a clear purpose, but it's vague about what 'upvalues' are and doesn't differentiate from siblings like get_properties or get_hidden_properties. It mentions 'found via getgc or other means' but doesn't specify if this is the only source or how it relates to 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?

No explicit guidance on when to use this tool versus alternatives. It references 'getgc or other means' but doesn't explain when to prefer this over siblings like get_properties or get_hidden_properties for function inspection. The agent must infer usage from context 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 provided, the description carries the full burden of behavioral disclosure. It adds useful context about decompilation requirements for specific script types, which goes beyond a basic read operation. However, it doesn't cover other behavioral traits like error handling, performance implications, or what happens if the path is invalid, leaving some transparency gaps.

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

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

The description is a single sentence that efficiently conveys the core action and a key constraint, with no wasted words. It's appropriately sized and front-loaded, making it easy to parse. However, it could be slightly more structured by separating the main purpose from the prerequisite, but it's still highly concise.

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

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

Given the tool's complexity (a read operation with a decompilation nuance), no annotations, no output schema, and 100% schema coverage, the description is adequate but incomplete. It covers the purpose and a key behavioral aspect, but lacks details on return values, error cases, or integration with siblings, making it minimally viable but with clear 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 100% description coverage, with the 'path' parameter fully documented in the schema. The description doesn't add any additional meaning or details about the parameter beyond what the schema provides, such as format examples or constraints. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the verb ('Read') and resource ('source code of a script'), making the purpose specific and understandable. It distinguishes from siblings like 'execute_script' or 'get_properties' by focusing on source code retrieval. However, it doesn't explicitly differentiate from all siblings, such as 'get_hidden_properties' which might also involve reading data, so it's not a perfect 5.

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

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

The description implies usage by mentioning a prerequisite ('Requires executor support for decompilation if it's a LocalScript/ModuleScript not created by you'), which provides some context for when to use it. However, it doesn't explicitly state when to choose this tool over alternatives like 'get_properties' or 'find_instances', nor does it outline exclusions or detailed scenarios, so it's only adequate with gaps.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but lacks critical details: it doesn't specify if this is a read-only operation, what format the logs are returned in, whether there are rate limits, or if authentication is required. This leaves significant gaps for an agent to understand the tool's 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, making it easy to parse quickly.

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 a logging tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'remote spy logs' contain, how they are structured, or what the return values look like, leaving the agent with incomplete context for proper 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 input schema has 100% description coverage, with the 'limit' parameter clearly documented in the schema. The description adds no additional parameter information beyond what the schema provides, so it meets the baseline score of 3 for high schema coverage without extra value.

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 'collected remote spy logs', making the purpose understandable. However, it doesn't differentiate from sibling tools like 'remote_spy_start' or 'remote_spy_stop', which are related to controlling the spy functionality rather than retrieving logs.

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. It doesn't mention prerequisites (e.g., whether 'remote_spy_start' must be called first), exclusions, or comparisons to other tools like 'get_connections' that might retrieve different types of data.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While it states the tool 'Logs all remote traffic,' it doesn't explain where logs are stored, how to access them (though 'remote_spy_get_logs' is a sibling), performance impact, permission requirements, or whether this is a continuous background process. The description is insufficient for a tool that presumably initiates system monitoring.

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 just two sentences that directly state the tool's purpose and primary function. Every word earns its place with zero wasted text, making it 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?

For a tool that initiates system monitoring with no annotations and no output schema, the description is incomplete. It doesn't explain the monitoring scope beyond 'remote traffic,' how logs are structured, whether there are rate limits, how to stop monitoring (though 'remote_spy_stop' exists), or what happens if monitoring is already active. The context signals show minimal parameter complexity, but the behavioral implications require more explanation.

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

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

Schema description coverage is 100%, so the schema already documents the single optional 'filter' parameter. The description doesn't add any parameter-specific information beyond what the schema provides, such as examples of filter patterns or how filtering affects logging behavior. Baseline 3 is appropriate when schema does the documentation work.

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 spying') and target ('RemoteEvent and RemoteFunction calls'), providing a specific verb+resource combination. However, it doesn't explicitly distinguish this tool from its sibling 'remote_spy_stop' beyond the action difference, missing an opportunity for clearer sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'remote_spy_stop' or other monitoring tools. It mentions 'Logs all remote traffic' which implies a monitoring context but doesn't specify prerequisites, timing considerations, 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?

With no annotations provided, the description carries full burden for behavioral disclosure. 'Stop' implies a state change operation, but the description doesn't specify whether this is destructive (e.g., terminates spy processes), has side effects, requires specific permissions, or what happens upon execution (e.g., confirmation message, error if not running). This leaves significant behavioral gaps 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 a single, direct sentence with zero wasted words. It's appropriately sized for a simple tool with no parameters, front-loading the core action without fluff or redundant explanations.

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 (a state-changing operation with siblings like remote_spy_start and remote_spy_get_logs), no annotations, and no output schema, the description is incomplete. It doesn't explain the tool's role in the remote spy workflow, what 'stopping' entails, or what to expect after execution, leaving the agent with insufficient context for reliable 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?

The tool has 0 parameters with 100% schema description coverage (empty schema), so no parameter documentation is needed. The description appropriately doesn't discuss parameters, earning a baseline score of 4 for not introducing unnecessary information while matching the schema's completeness.

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') and the target resource ('the remote spy'), which is a specific verb+resource combination. However, it doesn't explicitly differentiate this tool from its sibling 'remote_spy_start' beyond the obvious action difference, missing an opportunity to clarify their relationship within the remote spy functionality.

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. It doesn't mention prerequisites (e.g., that remote_spy_start must be running first), exclusions, or relationships with sibling tools like remote_spy_get_logs. The agent must infer usage context from the tool name alone.

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