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 behavioral intent (filtering, blocking symbols) and the caller-side obligation implied by the result, which is meaningful. However, it never states what the response looks like (allowed/blocked flag? reason?), whether the filter is mod-scoped or global, or whether the call has any side effects — gaps that matter for a verification tool.

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

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

Three short sentences: what it does, when to call it, and a concrete example. Front-loaded with the action, nothing redundant, and the example earns its place by demonstrating the required path format.

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 small two-parameter read-style check with no output schema, the description covers purpose, timing, and input format adequately. The main remaining gap is the shape of the result and the nature of the filter, which would help an agent interpret and act on a blocked answer.

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, and it partially does by giving a concrete format example ("/Script/Engine.GameplayStatics" plus a function name), which is genuinely useful for constructing class_path. It does not clarify that function is optional (only class_path is required) or what happens when function is omitted, leaving half the parameters semantically underspecified.

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

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

States a specific verb (check) and resource (class or function) against a named domain concept (Deep Field's Blueprint filter), which is clearly distinct from all siblings (asset/datatable/mod management tools). The example with class_path and function further pins down what object it operates on. It stops short of 5 only because 'Blueprint filter' is not explained, though the intent is still 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?

"Check before generating Blueprint logic and never use a blocked symbol" gives an explicit when-to-use rule and the consequence of skipping it. No sibling alternative is named, but no sibling plausibly overlaps with this check, so there is little ambiguity to resolve. The absence of any when-not guidance keeps it out of 5 territory.

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

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

No annotations are provided, so the description carries the full burden. It does not say that this mutates the active mod, what permissions are needed, or what override_existing_row does when an existing row collides — a serious gap for a write operation with a destructive override flag.

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

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

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

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

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

For a six-parameter mutation tool with no annotations, no output schema, and zero schema descriptions, this description is far too thin — an agent cannot confidently map values to parameters or predict side effects.

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 all six parameters rely on the description for meaning. It only loosely implies source_row and new_row_name and leaves source_table vs. table, row_asset_class, and override_existing_row entirely unexplained.

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

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

States a specific verb and resource: copy a row into a new row asset in the active mod. This is more informative than a tautology, but it does not distinguish the tool from siblings like duplicate_asset or upsert_datatable_rows, and 'vanilla row' is unexplained jargon.

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

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

Only 'as a starting point' hints at intent; there is no explicit guidance on when to use this instead of duplicate_asset or upsert_datatable_rows, and no prerequisites or exclusions are stated.

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

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

No annotations are provided, so the description carries the full burden. It implies a mutation (project creation) but says nothing about what happens on name collisions, whether an existing project is overwritten, what permissions or editor state are required, or what the tool returns on success/failure. The one useful disclosure is that the tool may be unavailable depending on editor scripting exposure.

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

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

A single front-loaded sentence with the core action first and the caveat second; nothing is wasted. The trailing conditional is slightly muddying but is the only extra content.

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

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

For a creation/mutation tool with no annotations, no output schema, and undocumented parameters, the description is too thin. An agent needs to know template sourcing, substitution behavior, and failure/overwrite semantics before invoking 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% for all three parameters. The description only obliquely connects to 'template'; it never explains what 'name' controls, what values 'template' accepts, or what 'substitutions' does (presumably key/value replacement inside template files). With zero coverage and no compensating text, the agent is guessing.

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

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

States a specific verb and resource: 'Create a mod project from a template'. An agent can tell it produces a new mod project. However, it does not distinguish itself from siblings like duplicate_asset or list_templates, and the trailing conditional ('if the editor exposes templates to scripting') introduces doubt about whether the operation is even available.

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

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

No guidance on when to use this versus duplicate_asset, list_templates, or open_mod_panel. The conditional clause hints at a precondition but is a caveat about editor capability, not a usage rule or an alternative-routing instruction. The agent must infer that list_templates should be called first to obtain a valid template value.

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 only the destination-location constraint; it says nothing about overwrite behavior if the destination exists, permission requirements, reversibility, or what the operation returns for a mutation-style copy.

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

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

Two short sentences with the operation stated first and the constraint second. No padding, though it could have used the space for the missing behavioral details instead.

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

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

With no annotations, no output schema, and 0% schema description coverage, the description is too thin for a mutation tool: overwrite semantics, source/path expectations, and success/failure outcomes are all absent, leaving the agent to guess.

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 for both parameters. It gives useful meaning for 'destination' (must be inside the active mod) but leaves 'source' format/scope (path? asset ID? can it be outside the mod?) unexplained, so partial compensation only.

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

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

States a specific verb ('Copy') and resource ('asset') plus the target scope (the active mod), so the operation is unambiguous. It does not differentiate from siblings like create_mod or list_assets, but the action itself is 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 constraint 'destination must be inside that mod' implies usage context and a precondition, but there is no explicit when-to-use vs alternatives guidance (e.g. versus create_mod or search_assets) and no mention of failure conditions.

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

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

With no annotations, the description carries the full burden. It usefully discloses the returned data (connection, version, open mod), but does not state that it is a read-only, side-effect-free probe, nor what happens or is returned when the editor is not connected.

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 sentence with no waste, front-loading the core purpose and then the returned facts. Nothing would be gained by shortening or restructuring it.

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

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

For a zero-param status tool without an output schema, the description supplies the key return fields, which is helpful. It still omits the not-connected behavior and failure semantics, leaving an agent unsure what a disconnected result looks like.

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

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

The tool takes zero parameters, which is the baseline 4; there is nothing for the description to clarify beyond that, and it introduces no parameter confusion.

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

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

States a specific verb ('Report') and the exact facts returned: connection state, version, and open mod. Clearly distinguishes from siblings like list_mods or open_mod_panel, though it doesn't name them 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?

Usage is implied: a zero-param status probe one calls before working with the editor. There is no explicit guidance on when to prefer it (e.g., as a precondition check before save_all or upsert_datatable_rows) or what to do if disconnected.

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 does usefully disclose that auth codes and API keys are redacted from output, which is real value beyond structured fields, but it never resolves whether 'tail' returns a snapshot of the last N lines or streams/follows the log, nor whether the call can block or fail.

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

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

A single front-loaded sentence with no filler; the redaction caveat is placed where it matters. It is efficient but so terse that the brevity shades into under-specification rather than economy.

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

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

For a simple two-parameter read tool the description is thin: no output shape (log text vs structured entries), no parameter meaning, no indication of log scope or size limits, and no annotations to fall back on. An agent can call it, but cannot call it precisely.

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 both parameters ('lines' default 100, 'contains' default empty) are undocumented in structured data. The description mentions neither, leaving the filter semantics of 'contains' (substring vs regex, case sensitivity, which fields it matches) and the meaning of 'lines' entirely unspecified.

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

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

States a specific verb and resource ('tail the editor log') and adds a redaction note, which is enough for an agent to know exactly what it retrieves. No sibling tool reads logs, so differentiation is implicit rather than stated, and 'tail' leaves the streaming-vs-snapshot semantics slightly fuzzy.

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

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

There is no statement of when to reach for this tool, no prerequisites, and no named alternatives among the 21 siblings (e.g., editor_status or validate_mod for diagnostics). The agent must infer that this is a debugging aid.

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 the description carries the full behavioral burden, yet it says nothing about the recursive=true default (whether it descends into subfolders), the 500-result limit, truncation/pagination behavior, or what happens for a nonexistent path. For a tool whose defaults silently change result scope, that is a meaningful gap.

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

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

A single front-loaded sentence with no filler, and the examples are the highest-value information to lead with. It is efficient, though the brevity shades into under-specification rather than tightness.

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

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

With no annotations, no output schema, and 0% schema coverage, the description needs to explain result shape and the effect of recursive/limit. It covers only the path input, leaving an agent unable to predict what a default call returns.

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% across three parameters; the description only clarifies the meaning and format of `path` through examples. The `limit` and `recursive` parameters — the ones that most affect output — get no explanation at all, so the compensation is partial at best.

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

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

The description names a specific verb and resource ("List assets") and gives two concrete path examples (/Game/Blueprints/Items, /MyMod), which makes the operation unambiguous. It does not distinguish itself from the sibling search_assets, so the agent must infer the boundary from the verb alone.

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

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

There is no statement of when to prefer this over search_assets, list_datatables, or read_asset, and no prerequisites or exclusions. Usage is only implied by the word "List".

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

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

No annotations are provided, so the description carries the full behavioral burden. "List" implies a non-destructive read, but nothing is said about pagination, result limits, scope (all mods vs. current mod), permissions, or return shape.

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

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

A single front-loaded sentence with zero waste; the resource comes first and the filter caveat follows.

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

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

For a one-optional-param list tool with no output schema, the description is minimally adequate, but it never says what a DataTable asset is, whether results span all mods, or what the response contains — details an agent needs before calling.

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 only parameter is a bare "Query" string with an empty default, so the description's phrase "filtered by path substring" is the sole source of meaning. It usefully disambiguates that the filter matches paths rather than names or content, but gives no matching rules (case sensitivity, wildcards).

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

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

The description uses a specific verb and resource ("List DataTable assets") and adds the filtering capability, so an agent can tell it apart from generic siblings like list_assets or read_datatable. It stops short of explicitly naming the alternative tools, so it lands at 4 rather than 5.

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

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

"Optionally filtered" hints at a use case but gives no when-to-use/when-not guidance and never references siblings such as search_assets or list_assets. An agent must infer on its own when this listing tool is preferable to the search or read 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, the description carries the full burden, and it does contribute one real behavioral fact: the tool functions independently of an open editor session. However, it says nothing about whether results come from a filesystem scan, what a project entry contains, or ordering — meaningful gaps for an unannotated tool.

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

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

A single short sentence with the core action front-loaded and the qualifier tucked into a parenthetical. Every word earns its place and there is no filler.

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

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

For a zero-parameter listing tool with no output schema and no annotations, the description covers what it does and the notable editor-independence trait. A brief note on what each returned entry represents would close the remaining gap.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. No parameter-level detail is needed or missing.

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

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

States a specific verb (List) and a specific resource (local mod projects), which is enough to distinguish it from asset-oriented siblings like list_assets and list_datatables. It stops short of explicitly contrasting with the nearest sibling, so a 4 rather than a 5.

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

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

The parenthetical 'works without the editor open' implies a use condition (call it when no editor session exists), but the description never states when to prefer it over siblings such as list_assets or create_mod, nor any exclusions. Usage is inferable but not spelled out.

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

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

With no annotations, the description carries the full burden; 'List' implies a read-only enumeration but does not state whether it is workspace/mod-scoped, whether results are static, or what form they take. It adds the useful framing that these are classes 'a mod can create', but behavioral disclosure is thin.

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

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

A single front-loaded sentence with no filler; the example does real work by disambiguating the kind of value returned.

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

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

For a zero-param discovery tool with no output schema, the description conveys the return content (class names, e.g. RecipeModRowAsset) well enough to call and interpret it. Minor gap: it doesn't confirm the result is a flat list of identifiers.

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

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

The tool takes zero parameters, so the baseline is 4; there is nothing parameter-related the description could add, and it correctly doesn't invent any.

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

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

States a specific verb ('List') and a precise resource ('row asset classes a mod can create'), with a concrete example (RecipeModRowAsset) that makes the distinction from list_assets/list_datatables evident – this returns type/class names, not data. It does not name a sibling directly, so it falls just short of a 5.

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

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

The purpose implies when to use it (discovering which row asset types exist before creating one), but there is no explicit statement of when to use this versus list_assets or list_templates, nor any prerequisites. Usage is inferable only.

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. 'List' implies a safe read and the phrase 'the editor exposes to scripting' usefully bounds the result set, but there is no disclosure of return shape, ordering, or whether the list is static per session.

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

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

A single front-loaded sentence with no filler; every phrase ('mod templates', 'editor exposes', 'to scripting') contributes meaning.

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

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

For a zero-arg read tool there is no output schema, so the description should convey what each returned template looks like (name only? path? metadata?). It identifies the resource but leaves the return shape entirely undocumented, which is a meaningful gap.

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

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

The tool takes zero parameters, so the baseline of 4 applies; the schema is trivially complete and the description adds no conflicting parameter expectations.

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

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

States a specific verb (List) and resource (mod templates) with a qualifier about scope ('the editor exposes to scripting'), which clarifies the subset returned. It is distinguishable from siblings like list_datatables and list_mods, though it never explicitly contrasts with 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?

There is no guidance on when to call this versus list_datatables, list_mods, or list_assets, nor any prerequisite context (e.g., must a mod be loaded first?). Usage is only implied by the verb 'List'.

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

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

With no annotations provided, the description carries the full burden, and it does disclose the most important trait: 'It presses nothing and uploads nothing,' i.e. it is side-effect free and safe. However, it omits other relevant behavior — whether an editor session/connection is required, what happens if the panel is already open, and whether anything is returned.

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

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

Two short sentences with zero waste; the purpose is front-loaded and the safety caveat follows immediately. Every clause earns its place.

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

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

For a no-parameter, no-output-schema UI action, the description covers what it does and that it has no side effects, which is the essential information. Only minor gaps remain, such as the editor-session precondition and idempotency when the panel is already open.

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

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

The tool takes zero parameters and the schema is empty, so there is nothing for the description to disambiguate. Baseline 4 applies 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?

States a specific verb and resource: 'Open the editor's Mod Management Tool'. This is clearly distinct from siblings like create_mod, package_mod, and list_mods, which manipulate data rather than surface UI. It stops short of naming a sibling to contrast with, but the action is unambiguous.

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

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

There is no explicit statement of when to call this versus alternatives, nor any prerequisites (e.g. editor must be running, panel already open). The closest thing to guidance is the negative scoping in the second sentence, which tells the agent what the tool won't do rather than when to choose 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, the description carries the full burden and does disclose real behavior: it writes (saves) the active mod, has a UI side effect (opens the upload panel), and hard-stops before any network upload or mod.io page creation. Not covered: whether a failed validation aborts the save, or whether existing mod data can be overwritten.

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

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

Two short sentences, action front-loaded in the first clause, and the crucial negative constraint ('never creates a mod.io page or uploads anything') placed where it will be read. Zero filler.

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

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

For a zero-parameter, no-output-schema action tool this is nearly complete: an agent knows what it mutates, what it will not do, and that it returns next-step explanation. The only gap is failure semantics — what the agent should do if validation fails.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify; baseline of 4 applies. The description correctly implies a no-argument, single-action invocation.

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

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

Specific verb chain and resource: it saves and validates the active mod, opens the upload panel, and returns next-step guidance. It also carves out a clear scope boundary ('stops before' the upload flow), which separates it from a pure save or pure validate action. It never names save_all or validate_mod, so sibling differentiation is implied rather than explicit.

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

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

Clear context for when to reach for it (when the mod is ready to be packaged), plus an explicit when-not: it never creates a mod.io page or uploads anything, so an agent shouldn't call it expecting publication. It stops short of naming the alternative tools for save-only or validate-only workflows, which would have made this a 5.

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

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

No annotations exist, so the description carries the full burden. It does disclose real behavioral information not present in the schema: results come back as JSON, and DataTable assets return rows instead of a property map. It says nothing about error behavior for a bad path, permissions, or whether non-datatable assets return nested structures.

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

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

Two short sentences, front-loaded with the core action, and the DataTable clause earns its place by flagging a non-obvious return-shape exception. It is lean rather than padded, though terseness comes at the cost of the missing path semantics.

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

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

For a one-parameter read tool with no annotations and no output schema, the description covers the action and the JSON/rows return shape. The unresolved path format and the overlap with read_datatable leave gaps an agent would hit on first 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 single parameter "path" has 0% schema description coverage, so the description was the only place to explain it, and it does not. It never says whether path is relative to the mod root, includes extension, or accepts a name vs. a filesystem path — the main invocation risk for this 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?

"Read an asset's properties as JSON" gives a specific verb and resource that separates it from list_assets, search_assets and set_properties. However, the appended clause "DataTables return their rows" blurs the boundary with the sibling read_datatable, so the scope is clear but not fully disambiguated.

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

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

There is no statement of when to use this tool, when to prefer read_datatable or search_assets, or what preconditions apply. The only guidance is implied by the verb "Read", leaving the agent to infer routing from sibling names 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 behavioral-disclosure burden. It implies a read-only operation and mentions paging behavior, but says nothing about permissions, error behavior, return format, or whether partial row matches are possible.

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

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

Two short sentences with no wasted words, front-loading the core action and then compactly describing the two access modes.

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

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

With no annotations, no output schema, and 0% schema description coverage, the definition is too sparse. An agent still lacks path semantics, return-shape guidance, and behavioral context needed to invoke or interpret the tool confidently.

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

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

Schema description coverage is 0%, so the description must compensate for all four parameters. It adds useful meaning for rows, limit, and offset by describing the row-name versus paging modes, but it never explains the required path parameter or row-name 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 states a specific verb and resource: reading rows from a DataTable. It is clear enough to distinguish this from mutation tools like upsert_datatable_rows, though it does not explicitly compare itself with list_datatables or read_asset.

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

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

The description explains two access patterns—row names or offset/limit paging—but does not say when to use this tool versus alternatives such as list_datatables or read_asset, nor does it mention prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: execution happens in-editor, `unreal` is available, scope is not restricted to the active mod, and write guards exist as a constraint. It stops short of describing execution environment details an agent would want — timeouts, sandboxing, whether mutations persist, and how output is captured (stdout vs return value).

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?

Purpose is front-loaded in the first sentence and the guardrails follow in a compact block; nothing is padded. Slight cost is that the safety caveats occupy as much space as the capability statement, but they earn their place for an arbitrary-code tool.

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

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

No output schema exists, so the description's 'return its output' is the only signal about return values and it doesn't say what form that takes (string of stdout, structured result, error surface). For a tool that executes arbitrary code with one undocumented parameter and no annotations, a bit more on failure/timeout behavior would round it out.

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

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

There is a single required parameter `code` with 0% schema description coverage. The description implicitly tells the agent that `code` is Python executed with `unreal` imported, which is real added meaning, but it says nothing about whether the code is a snippet vs full script, how results are surfaced, or whether print vs expression value matters.

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

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

States a specific verb and resource ('Run Python inside the editor'), adds the key execution detail that `unreal` is pre-imported, and says the result is returned. The framing as an 'escape hatch' with scope 'not limited to the active mod' cleanly separates it from the domain-specific siblings like read_asset or upsert_datatable_rows.

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

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

Gives explicit when-to-use ('for inspection and for gaps in the other tools') and explicit when-not-to-use ('do not bypass the write guards, delete assets, or upload to mod.io without the user asking'). This is the rare case where alternatives and exclusions are both named.

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

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

No annotations are provided, so the description carries the full burden. It reveals the useful scope detail that only *changed* assets are written, but says nothing about whether this is a destructive/irreversible disk write, whether it can fail or partially fail, whether new unsaved assets are included, or what the tool returns.

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

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

A single front-loaded sentence with zero filler; the scope qualifier ("changed," "active mod") is packed into the same clause. Nothing needs trimming.

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

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

With no annotations and no output schema, the description is only minimally sufficient for a state-mutating batch operation. An agent can act on it, but it lacks error behavior, confirmation of what success looks like, and any hint about side effects on disk.

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

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

The tool takes zero parameters, so there is nothing to disambiguate and the baseline of 4 applies. The description correctly implies no user input 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?

"Save every changed asset in the active mod" states a specific verb (save) and resource (changed assets) with a clear scope qualifier (active mod). It is distinguishable from siblings like `set_properties` or `package_mod`, though it never explicitly names how it differs 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?

The description offers no guidance on when to call this versus alternatives or prerequisites. There is no mention of when saving is appropriate (e.g., before `package_mod`/`validate_mod`) or whether unsaved edits must exist first.

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 never confirms this is a read-only operation, says nothing about result ordering, case sensitivity, truncation at the limit, or what happens when query is empty (which by default would return everything under /Game).

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

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

A single dense sentence with the goal front-loaded and no filler. Every clause maps to a real parameter distinction.

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 4-parameter tool with no annotations and no output schema, the description is thin: it omits limit behavior, default scope (/Game, empty query), and any indication of return shape. An agent cannot predict result size or pagination from this text.

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 and it partially does: 'under a path' maps to path, 'package path substring' to query, and 'exact class name' to asset_class, including the important substring-vs-exact distinction. However, the fourth parameter, limit, is never mentioned or explained.

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

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

The description states a specific verb and resource ('Find assets') plus the scoping mechanism ('under a path', 'package path substring and/or exact class name'). This clearly separates it from read-heavy siblings like read_asset or list_assets, though it never names those alternatives 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?

It implies a filtered search and that the two filters can be combined ('and/or'), but gives no when-to-use guidance, no exclusions, and no pointer to list_assets or read_asset as alternatives. An agent must infer whether this or list_assets is the right entry point.

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

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

With no annotations, the description carries the full behavioral burden, and it only discloses the deferred-persistence workflow via save_all. It says nothing about whether properties merge or replace existing ones, what happens on an invalid path, whether unknown keys are rejected, or whether the change is reversible before save.

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

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

Two sentences, zero filler, with the primary action front-loaded and the follow-up requirement placed second. Nothing is padded or redundant.

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

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

There is no output schema and no annotations, while the schema contains an unconstrained nested properties object, so the description would need to explain expected keys and result behavior. It covers only persistence, leaving the most ambiguous part of the tool undocumented.

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% across both parameters, and 'properties' is an open-ended nested object with additionalProperties true whose accepted keys and value types are entirely undocumented. The description adds no parameter meaning beyond repeating the field name in prose, leaving the agent unable to construct a correct call.

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

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

States a specific verb and resource ('Set properties on an asset') scoped to the active mod, which is clearer than a bare name restatement. It does not distinguish itself from siblings like duplicate_asset or clone_row, and leaves 'properties' undefined, so an agent knows roughly what it does but not the scope of what can be set.

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 instruction 'Call save_all afterwards' implies this is a staging mutation that requires an explicit persist step, which is genuinely useful context. However, there is no guidance on when to use this versus other mutation tools, no prerequisites (e.g., asset must exist, mod must be open), and no exclusions.

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

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

No annotations exist, so the description carries the full burden, and it discloses a lot: one asset per row, the resulting asset path, the mandatory save_all follow-up, and the semantic difference between struct defaults and vanilla values. What it does not state is what happens when a row already exists (overwrite semantics are only implied by 'override_existing_row') or whether the write is atomic/validated.

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

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

Front-loaded with the mutation and the save_all follow-up, then progressively narrower detail on row shape and cross-references. Every paragraph carries information, though the clone_row paragraph is dense enough that it could be split or trimmed 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?

Adequate for the rows payload and the save lifecycle, but incomplete for a 3-required-parameter mutation with no annotations and no output schema: `row_asset_class` is unexplained, and there is no statement of what the tool returns or what happens on failure/validation error.

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

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

With 0% schema coverage the description must compensate, and it does well for `rows`: it spells out the entry shape {"row_name", "override_existing_row", "values"}, the snake_case value convention matching read_asset, and the <mod_prefix>_<row_name> reference format. However, `table` and especially the required `row_asset_class` are never explained anywhere, leaving a third of 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?

States a specific verb pair and resource ('Create or update rows in the active mod'), plus the exact storage location each row lands at (/<Mod>/DataTables/<table>/<row_name>). It also explicitly separates itself from clone_row, so an agent can distinguish it from siblings without opening the schema.

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

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

Names the follow-up requirement ('Call save_all afterwards') and routes a specific case to the alternative tool: partial edits of vanilla rows should use clone_row with override_existing_row=True and the same row name rather than this tool. It also flags that omitted fields take struct defaults, not vanilla values — a real usage pitfall.

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 at all, the description must carry the full behavioral burden and does not. It doesn't say whether validation merely reports problems or also mutates anything, whether it blocks on large mods, whether it requires a saved/loaded mod state, or how results are surfaced (log vs. return value).

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

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

A single front-loaded sentence with no filler; the scope constraint ('active mod') arrives immediately. Nothing in it is redundant.

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

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

This is a diagnostic tool whose entire value is its output, yet there is no output schema, no annotations, and the description says nothing about what the validators produce (error list, counts, log entries) or how the agent should consume it. For a zero-annotation, zero-output-schema tool, that is a significant gap.

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

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

The tool takes zero parameters, so there is nothing to disambiguate; the description correctly implies no input is needed because it acts on the active mod. Baseline 4 applies 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 names a specific verb (run validators) and a specific resource (the editor's asset validators over the active mod), so the agent knows exactly what the operation does. It does not, however, distinguish itself from nearby siblings such as package_mod or save_all, which also act on the active mod and involve validation-adjacent steps.

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?

'Over the active mod' implies the precondition that a mod must be open/active, but the description never states when to call this versus package_mod (which likely also validates) or what to do with the results. Usage is inferable but no explicit when/when-not or alternative is given.

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