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

With no annotations, the description carries the full burden of explaining behavior. It transparently documents the input format (each call has an 'op' key), the list of supported operations, the per-call response structure including error handling, and the fact that one failure does not abort the rest. It doesn't mention side effects of specific inner operations (like set), but the overall behavior is well conveyed.

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 slightly long due to the enumerated operation examples, but this length is justified because the schema is minimal. It is well-structured with a clear opening, a brief rationale, and then a formatted list of examples followed by the response format. The information is front-loaded with the main purpose stated first.

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

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

Given the absence of an output schema and the minimal input schema, the description provides sufficient context for an agent to understand both the input and output formats. It explains the return contract (each result is {op, ok, result} or error) and covers error handling. It doesn't enumerate every possible operation, but the examples are representative and cover the common cases, making the tool usable.

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 only defines 'calls' as an array of objects with additionalProperties true, providing no structural detail. The description fills this gap completely by specifying that each object must contain an 'op' field and showing concrete examples for each supported operation. This is essential for correct usage and is done in a clear, actionable way.

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 core function: 'Run several bridge operations in ONE round trip.' It explicitly differentiates this from individual operations by emphasizing the batch nature and the efficiency gain, making it distinct from the sibling tools like get_property or call_function.

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 practical guidance on when to use the batch tool by explaining the overhead of individual calls ('A round trip costs a poll plus latency...') and noting that it is safe for exploration due to partial failure. It could be more explicit in saying 'use this instead of calling each operation individually,' but the rationale is clear enough.

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 reports the output fields but does not disclose whether the tool has side effects. Since no annotations are provided, the description carries the burden of indicating that this is a read-only status check, which it fails to do explicitly. It also does not clarify if any permissions are required beyond reporting them.

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, with the primary purpose front-loaded in the first sentence. It is concise, with no fluff or redundant details, and each word contributes to understanding the tool's function and output.

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 provides enough context for a status-check tool: it names the outputs (game found, mod version, permissions, round-trip time) and the overall purpose. Since there is no output schema, specifying the return fields is sufficient. It lacks a note on typical use cases, but for a simple status tool, this is adequate.

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, and the schema coverage is 100% (vacuously). The description does not add any parameter-specific meaning, which is acceptable given there are none. Per the baseline rule for high schema coverage, a 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: checking whether a UE4SS game is running and the UEBridge mod is answering. It also enumerates the reported fields, making the tool's function unambiguous. However, it could be slightly more direct by starting with 'Checks' or 'Reports status', but it is still clear.

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

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

No explicit guidance is given on when to use this tool versus alternatives like inspect_object or world_info. The description does not mention conditions or scenarios, leaving the agent to infer that this is a preliminary health check. This is a notable gap given the 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?

The refusal condition ('Refused when allow_writes = false') reveals that the tool may perform write operations, which is useful behavioral info. However, it does not elaborate on side effects, error behavior, or whether it is read-only in other cases.

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, two sentences, with no redundant information. It directly states the purpose and a key constraint.

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 core action and a refusal condition, but lacks details on expected output format, error handling, or prerequisites for calling functions. It is adequate for a simple call but not fully comprehensive.

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 phrase 'positional JSON args' clarifies the 'args' parameter, but 'ref' and 'function' are not explicitly explained. Since the schema has no descriptions, the description only partially compensates for parameter 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 action: calling a UFunction on an object with positional JSON arguments and returning the result. It distinguishes itself from sibling tools like get_property or set_property by focusing on function invocation.

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 mentions a refusal condition based on allow_writes, but does not explicitly guide when to use this tool over alternatives such as eval_lua or list_functions. The condition gives some context but lacks direct comparative 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 must carry the full burden of disclosing side effects. It transparently states that 'Output is not captured' and that the tool is refused under a specific condition, which are important behavioral traits. It does not mention other potential side effects (e.g., persistence or state changes), but the disclosed information is valuable.

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, front-loading the core action and immediately providing critical caveats (output not captured, refusal condition). No unnecessary words or redundancy.

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

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

Given the tool's simple nature and the absence of an output schema, the description covers the essential information: what it does, the key limitation (output not captured), and a condition that affects invocation. It could arguably mention that the command may have arbitrary side effects, but that is implied by 'console command' in a world 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?

The schema fully describes the single parameter 'command' as a string, so the description adds no extra semantic depth. The parameter is self-explanatory given the tool's purpose, and the baseline of 3 is appropriate since schema coverage is 100%.

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 a console command') and the resource ('in the running world'), making the purpose understandable. It does not explicitly differentiate from sibling tools like eval_lua or call_function, but 'console command' is distinct enough in most 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 a condition for refusal ('Refused when allow_writes = false'), which gives some guidance on when the tool might be blocked. However, it does not explicitly state when to use this tool over alternatives or mention any prerequisites, so the guidance is only partial.

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?

It discloses output location and runtime expectations for certain kinds, but does not mention side effects such as file overwriting, required game state, or potential errors. With no annotations, the description bears full responsibility and could be more 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 concise and to the point, with no fluff. The list of kinds is compact, and additional notes about output location and timing are useful without being verbose.

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

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

For a single-parameter tool with no output schema, the description covers the essential aspects: what it does, the parameter's meaning, output location, and timing caveats. It could mention return values or error conditions, but overall it is reasonably 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?

The sole parameter 'kind' is not described in the schema, but the description lists possible values in the text (usmap, jmap, etc.), providing partial semantic coverage. It does not exhaustively enumerate all valid options or explain the effect of each kind.

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 ('Trigger a UE4SS dumper') and lists the specific dump kinds (usmap, jmap, uht, cxx, actors, objects, static_meshes). It is unambiguous and distinct from sibling tools like inspect_object or eval_lua.

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

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

It provides some usage context (output lands in the ue4ss directory, jmap and uht take minutes) but does not explicitly say when to prefer this tool over alternatives or when not to use it. The guidance is implicit rather than explicit.

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

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

With no annotations provided, the description carries the transparency burden. It does disclose that execution runs on the game thread, returns the result, captures print output, and can be refused based on settings. It does not mention potential side effects, error behavior, or timeout consequences, which are important for an arbitrary code 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 reasonably concise and front-loaded with the primary purpose. It includes useful additional details about API availability and refusal conditions without excessive verbosity, though it could be slightly more compact.

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 due to arbitrary Lua execution, and there is no output schema. The description provides some context such as the available API, UEB helper table, print capture, and refusal condition, but it omits return serialization details, timeout behavior, and error handling, leaving gaps for an agent that needs to invoke it safely.

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 implicitly clarifies that 'code' is a Lua chunk, but it does not explain the 'timeout' parameter despite its default value, leaving its semantics and behavior unclear. The description adds only partial meaning beyond the bare parameter 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 a specific action: 'Run a Lua chunk inside the game on the game thread and return what it returns.' It distinguishes this tool from siblings by emphasizing arbitrary Lua execution and capturing print output, which separates it from call_function, console_command, and other focused 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 implies usage for arbitrary Lua scripting when the full UE4SS API or UEB helper table is needed, and it notes the refusal condition when allow_eval is false. However, it does not explicitly compare against sibling tools like call_function or console_command, so when-to-use guidance is only implied rather than direct.

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 mentions the primary behavior (resolving and returning information) but does not disclose any side effects, error cases, permissions required, or other behavioral traits. Since no annotations are provided, the description carries full responsibility but only partially covers 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 concise sentence with no redundant words. It is well-structured and easy to read, containing exactly the essential information without fluff.

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 parameter descriptions and output schema, the description is incomplete. It does not explain what constitutes an object reference, what format the path should take, or what the returned name, class, and address look like, leaving significant gaps for an agent to use the tool correctly.

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

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

The only parameter 'path' has no description and the schema coverage is 0%. The word 'path' is generic and ambiguous; the description does not explain what kind of path or object reference it expects, leaving the parameter's meaning entirely unclear.

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 resolves an object reference and returns its full name, class, and address, which is a specific and unambiguous purpose that distinguishes it from sibling tools like 'list_functions' or 'get_property'.

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, nor does it mention any conditions or prerequisites for using it. It simply states what it does 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?

There are no annotations describing side effects, read-only status, or potential impacts. The description does not indicate whether the tool queries, modifies, or creates anything, so the agent cannot anticipate behavioral outcomes.

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 to the point, but its brevity sacrifices clarity. It is a single sentence without wasted words, yet it omits essential details and does not follow a clear 'verb + object' structure, making it less effective despite being 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?

The description is incomplete for the given context. It does not mention the output format, return value, or any interaction with the system. Given the sibling tools, it is likely a query but lacks any information about what the caller receives or how to interpret results.

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 indirectly references 'class_name' by mentioning a 'short class name' but provides no detail about the 'limit' parameter. With zero schema descriptions for parameters, the agent has insufficient information about the meaning, constraints, or default behaviors of the inputs.

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

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

The description is a fragment, not a clear verb phrase. It mentions 'instances of a short class name' which implies finding objects, but it does not explicitly state the tool's function. The tool name 'find_objects' provides some clarity, but the description alone is ambiguous.

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

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

No guidance is provided on when to use this tool versus siblings like 'find_object' or 'list_types'. The description does not mention any conditions, prerequisites, or alternatives, leaving the agent to guess the appropriate 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 are provided, so the description carries the transparency burden. It explicitly notes that 'an unknown property name raises rather than returning junk,' which is a key behavioral detail. However, it does not mention whether the operation is purely read-only, though the verb 'read' implies that.

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 filler. Every word adds meaning, and the key behavioral note is included without redundancy.

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

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

For a simple single-property read, the description covers the essential behavior (raising on unknown names). It lacks explicit details about return types or error conditions beyond the note, but given the simplicity of the operation, it is reasonably 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?

The input schema provides no descriptions for 'ref' or 'name', and the description does not explain them. While 'ref' as an object reference and 'name' as a property name are inferable, the lack of explicit definition leaves ambiguity—especially for 'ref,' which could refer to different kinds of references.

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 function: 'Read one property of an object.' It distinguishes from siblings like set_property (mutation) and inspect_object (likely whole-object inspection) by focusing on a single read.

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

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

The description implies when to use this tool—when you need one property of an object—but it does not explicitly contrast with alternatives like inspect_object or mention when a different tool would be preferred. The guidance is minimal but sufficient for the simple case.

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 mentions that SoftObjectProperty values are skipped, which is a notable limitation. However, it does not explicitly state that the operation is read-only or side-effect-free, though this is implied by the inspection nature. No annotations are provided to contradict or supplement this.

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 well-structured, with a clear opening sentence and separate parameter notes. It avoids unnecessary fluff, though it could be slightly more explicit about return format or usage comparisons 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?

There is no output schema, so the description must indicate what the tool returns. It states 'Every reflected property of an object with its current value', which implies a map or listing, but does not specify the exact structure (e.g., dictionary vs list). It also covers the skipping behavior, but lacks details on error handling or edge cases.

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 explains pattern (optional Lua pattern) and include_super (defaults to False), providing examples. It does not explicitly explain ref, though it is clearly the object reference from context. The schema provides titles and defaults, but the description adds meaning for only two of the three 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 it inspects every reflected property of an object with its current value, and it specifies usage on CDOs and actors. This distinguishes it from get_property (single property) and find_object (search for objects), though it does not explicitly mention alternatives.

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

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

It gives some guidance on when to use (on CDOs and actors) and how to filter with pattern, but does not explicitly compare to sibling tools like get_property or dump. The context implies a bulk inspection, but the description does not state when to prefer this over get_property or when to avoid 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 responsibility. It states the tool lists functions but does not clarify whether it has side effects, requires special permissions, or how it handles errors. The read-only nature is implied but not explicit.

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

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

The description is extremely concise and free of unnecessary words. It delivers the essential information in a single sentence without dilution.

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, the description is adequate for the basic action but lacks important context. It does not explain the 'ref' parameter, what the output format is, or how the results relate to the class hierarchy, leaving gaps for an agent attempting to use it.

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 'ref' has no description in the schema, and the tool description does not explain what it represents. A user cannot infer whether it is an object reference, a string identifier, or something else, making the parameter effectively 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 tool lists callable functions on an object, with scope 'across its class chain'. The verb 'list' and resource 'functions' are specific. The only ambiguity is what 'ref' refers to, but the core purpose is understandable.

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

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

There is no guidance on when to use this tool versus alternatives like call_function or inspect_object. The description does not mention any conditions, prerequisites, 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?

With no annotations present, the description carries the full burden. It transparently mentions the walk over GUObjectArray and the approximate runtime, giving useful side-effect information. No contradictions are present.

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 filler or redundant information. It efficiently communicates the 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?

The description gives sufficient context for basic invocation: what it lists, how the pattern works, and a performance caveat. The limit parameter's meaning is not fully elaborated, but the default value mitigates ambiguity. Overall, it is adequately 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?

The description explains the 'pattern' parameter as a Lua pattern and clarifies that empty matches all. The 'limit' parameter is not described, though its default of 200 provides some context. Overall, partial parameter 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 indicates a listing operation for loaded reflected types, with a specific name-matching pattern. It distinguishes from siblings like find_object or dump by focusing on type enumeration, though the verb is implicit.

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

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

It provides guidance on the empty pattern meaning 'all' and notes the performance cost (~400 ms), implying when to use it. However, it does not explicitly contrast with alternatives like find_object or list_functions, so the usage context is only partially 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 carries the full burden. It discloses side effects (writes are never undone), return values ({previous, current}), error behavior (unknown property raises), and inhibition conditions (allow_writes = false). This is thorough and 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 concise and to the point, covering essential behavioral aspects in a few sentences. It avoids unnecessary fluff and front-loads the core action and return type.

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 the tool's primary purpose, side effects, error conditions, and return shape. It doesn't need to explain more for a simple property setter. A minor gap is not stating what a 'ref' is, but given sibling tools like inspect_object and find_object, the context is likely familiar. Overall, the tool is well-contextualized.

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 lacks any parameter descriptions, and the description provides limited clarification. It implies ref is an object reference, name is a property name, and value is the value (with type restrictions), but these are not explicitly defined. The description does not adequately compensate for the 0% schema coverage, leaving ambiguity for parameter meanings.

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 (write one property), the resource (an object), and the allowed types (number, bool, string). It distinguishes from sibling tools like get_property by explicitly focusing on writing, making the purpose unambiguous.

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

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

The description gives clear usage context: it mentions that writes are irreversible, unknown property names raise errors, and refusal occurs when allow_writes is false. While it doesn't explicitly state 'use when you want to modify a property,' this is implied by the verb 'write' and the contrast with get_property. Minor gap in not naming alternative tools explicitly, but adequate.

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 full burden for behavioral transparency. It does not indicate whether the tool is read-only, what side effects it has, or whether it returns current state or modifies anything. The bare list of items gives no clue about 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 extremely short and free of fluff, but it is so terse that it sacrifices clarity. It fits in one sentence but fails to convey meaningful information about the tool's function.

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 lists game-related entities but does not explain what the tool does with them—whether it retrieves, modifies, or reports their status. It lacks context about return format or purpose, making it incomplete for an agent deciding to call it.

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

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

The tool has zero parameters, so there are no parameter semantics to describe. The baseline of 4 applies because the absence of parameters is clear and no description is 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?

The description is a noun phrase listing game objects (world, player controller, pawn, game instance, game mode) but does not state what the tool does with them. It lacks a verb like 'get' or 'list', making the purpose ambiguous compared to sibling tools like inspect_object or get_property.

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 dump, get_property, or inspect_object. The description does not explain scenarios where world_info is preferred.

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