adv2mcp

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the description does not need to establish mutability. It adds useful behavioral context: preview_only validates and reports counts without writing, and unknown models are reported because external mounts may supply 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 front-loaded with the core action and then adds only relevant operational details in compact sentences. There is no obvious filler, and each sentence contributes useful context.

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

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

The tool has a complex nested schema, many fields, and destructive behavior, so more parameter and overwrite guidance would be helpful. The description covers purpose, preview mode, welding, and unknown-model handling, and an output schema exists, but it remains incomplete for the full parameter surface.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It mentions positions, angles, color, material, Weld/NoCollide, weld_to_head, and preview_only, but leaves many important parameters and nested fields undocumented, including overwrite, revision, head_id, ground_z, frozen, skin, force_limit, and nocollide behavior.

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: building prop_physics entities with positions, angles, color, material, and constraints. It is clear what the tool creates, though it does not explicitly distinguish itself from siblings such as write_dupe or transform_dupe.

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 usage for build creation and gives some in-tool guidance by mentioning weld_to_head and preview_only. However, it does not state when to use create_build instead of sibling tools like write_dupe, nor does it define exclusions or prerequisites.

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

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

Adds details beyond the read-only annotations: the profile is reloaded on every call, missing profiles block writes, and permission should not be inferred from local installs or screenshots. It does not cover auth or rate limits, but annotations already carry the safety profile.

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

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

Three short sentences, front-loaded with the core action, and each sentence adds a distinct operational point: freshness, write impact, and a safety warning.

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 zero parameters, read-only annotations, and an output schema, the description covers freshness, write blocking, and permission-inference safety. No critical invocation detail is missing.

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

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

There are zero parameters, so the baseline is 4 and the description need not compensate for schema gaps. It adds no parameter semantics because none exist.

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 ('Show') and resource ('server allowed-prop profile'), with reload behavior distinguishing it from a cached status check. It does not explicitly name siblings, but none of the listed sibling tools overlap with policy inspection.

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

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

Implies when to use it: before writes, because missing profiles block writes, and warns against inferring permission from local installation or screenshots. It does not name an alternative or a when-not condition, but the operational context is clear.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so the safety profile is covered; the description adds what is actually reported (game/dupe paths, format versions, filesystem availability), which tells the agent this is a non-mutating environment probe. It stops short of noting whether missing paths or unavailable filesystems are surfaced as warnings versus errors.

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 filler, with the most useful information (what is shown) leading. Nothing could be removed without losing 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?

With zero parameters, read-only annotations, and an output schema carrying the return shape, the description covers what the agent needs to decide to call it. The only gap is the absence of a stated use case (e.g., run this before transforms to verify paths), which would fully close the loop.

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 document and the baseline of 4 applies. The schema correctly declares an empty arguments object, and the description adds no contradictory input 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?

Uses a specific verb ('Show') and enumerates concrete contents: configured game/dupe paths, format versions, and filesystem availability. That distinguishes it from mutation siblings like transform_dupe or write_dupe, though it never explicitly separates it from the adjacent read-only model_info.

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 call this versus alternatives such as model_info or list_dupes, and no prerequisites or preconditions. An agent must infer from the name alone that this is a diagnostic/environment check rather than an operational query.

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 annotations already establish that this is a read-only, non-destructive operation. The description adds useful detail by naming the returned data and mentioning pagination, but it does not cover permissions, error behavior, truncation, or other operational context. With annotations carrying the safety profile and an output schema present, this is adequate but not rich.

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

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

The description is a single front-loaded sentence with no filler. It states the action and returned content immediately, and every phrase contributes to the 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?

An output schema exists, so the description need not explain return values in depth, and the read-only annotations cover safety. However, for a tool with a required 'name' parameter and 0% schema description coverage, the description leaves important parameter meaning and the inspect-vs-read distinction incomplete.

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

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

Schema description coverage is 0%, so the description must explain the three parameters. It hints at pagination through 'paginated positions/angles', but it never explains the required 'name' parameter or clarifies how limit and offset behave beyond the schema titles and defaults.

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: 'Read metadata, model counts and paginated positions/angles from an existing dupe.' It clearly states what the tool returns, but it does not distinguish inspect_dupe from siblings such as read_dupe or list_dupes.

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 only implies usage by saying the dupe must already exist. There is no explicit guidance on when to choose inspect_dupe instead of read_dupe, list_dupes, or other sibling tools, 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?

Annotations already declare the operation is read-only and non-destructive. The description adds meaningful behavioral context beyond that: recursive traversal, filename filtering, and the important performance trait of not decoding every file. Pagination and result ordering remain undisclosed.

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

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

It is a single front-loaded sentence with no redundant phrasing. The key scope and performance detail are stated efficiently.

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 high-level operation and one behavioral trait, and the output schema reduces the need to explain return values. However, with 0% parameter description coverage, omitting limit/offset pagination semantics leaves a meaningful gap for correct invocation.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It only hints that filtering is by filename, likely mapping to 'query', but provides no explanation of 'limit' or 'offset', their pagination behavior, or the 500 maximum.

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

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

The description gives a clear verb and resource: 'List .txt duplications recursively, filtered by filename.' It is distinguishable from read/inspect/write siblings by implying a listing operation, but it does not explicitly name or contrast those 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?

The use case is implied as listing duplicate .txt files, especially with filename filtering and no full file decoding. However, there is no explicit guidance on when to choose this over inspect_dupe, read_dupe, or search_models, nor any stated 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds genuinely non-obvious context the annotations don't carry: bounds are 'unrotated' (so rotation is not baked in) and expressed in Source units. It omits error behavior for an unknown model, keeping it from a 5.

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

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

One front-loaded sentence with zero filler; the key qualifiers ('unrotated', 'Source units') appear before the purpose clause.

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

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

With an output schema present, return values needn't be described, and the description does characterize them. But for a tool taking one required identifier whose schema is undocumented, the missing definition of 'model' is a real gap an agent could stumble on.

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 explain the single required 'model' parameter — but it only hints via the token 'MDL'. It never says whether the argument is a file path, model name, or search key, leaving the agent to guess.

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

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

Specific verb + resource: 'Read unrotated MDL hull bounds and dimensions' tells the agent exactly what comes back, and 'in Source units for accurate prop placement' pins down the intended domain. It is clearly distinct from siblings like search_models or list_dupes, though it never names 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?

'For accurate prop placement' implies the use case (sizing/positioning props in a build) but gives no explicit when-to-use/when-not and never points at an alternative for related queries such as search_models.

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 readOnlyHint/destructiveHint already covering safety, the description adds real behavioral value: output is lossless (nothing truncated), and response size can blow up on large dupes. It doesn't mention failure behavior when the name doesn't resolve or whether the payload can be filtered.

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 with the key constraint (large responses, paginated alternative) placed last where it is most actionable. The middle sentence about typed keys and tags is mildly informational but cheap. No padding or repetition.

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?

An output schema exists, so the description is not obliged to explain return structure — yet it spends its budget on format details while leaving the sole input and the not-found/failure path unspecified. For a single-lookup reader this is adequate but has clear gaps an agent would hit on first call.

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 one required parameter, 'name', with 0% schema description coverage, so the description carries the full burden — and it says nothing about it. It never clarifies whether 'name' is a dupe name, a model name, or an ID, nor any naming/case conventions. The format notes about typed keys and tagged vectors describe output, not the input parameter.

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

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

The description states the return artifact ('a lossless adv2mcp-json-v1 document') but never plainly says it reads a single dupe by name and returns its full unsummarized contents. The resource is only inferable from the tool name, and the format token 'adv2mcp-json-v1' is opaque without prior knowledge. It does implicitly distinguish itself from inspect_dupe by calling out pagination.

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

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

It gives a concrete routing rule: large dupes produce large responses, so use inspect_dupe when pagination matters. That names the alternative and the condition selecting it. It stops short of explicitly saying when this tool is the right choice (e.g. 'use when you need the complete dupe, not a summary').

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

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

Annotations already establish this as a read-only, non-destructive operation, and the description adds non-obvious behavior: all query words must match, allowed_only=false has different permission implications, and captured profiles may include Workshop models absent from the local VPK index. It still omits any explanation of refresh/caching 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 three compact sentences with the main scope stated first, followed by the mode caveat and an important index caveat. Every sentence adds useful information without repetition.

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?

An output schema exists and annotations cover safety, but the tool has five undocumented parameters. The description covers the most important search semantics but leaves refresh and pagination behavior unexplained, so it is only minimally complete.

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

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

Schema description coverage is 0% for five parameters, so the description must compensate, but it only explains allowed_only and query matching semantics. It says nothing about limit, offset, or refresh, leaving most parameters semantically 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 names a specific verb and resource: it finds models, and clarifies the default scope is server-allowed models. It does not explicitly distinguish itself from sibling tools such as model_info, so it falls short of a 5.

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

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

It gives clear usage context for the key mode switch: default behavior searches server-allowed models, while allowed_only=false searches installed models without implying permission. It does not mention when to use sibling tools like model_info instead, so it is strong but not complete.

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

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

Annotations already declare this as a destructive write operation. The description adds useful behavioral context: it saves a new file unless explicitly overwriting, and it limits supported inputs to single-body prop_physics with Weld/NoCollide. It could say more about overwrite consequences or failure modes, but it adds real value beyond annotations.

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

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

The description is three short sentences with no filler, and the core action is front-loaded. The constraint and save-behavior details are appropriately placed afterward.

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?

An output schema exists, so return values need not be described. The description covers purpose, input constraints, and default write behavior, but with six parameters at 0% schema coverage, it is not complete enough about source, destination, revision, or transform semantics.

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 six undocumented parameters. It only loosely maps to yaw/offset via 'rotate' and 'translate,' and mentions overwrite behavior, but source, destination, and revision are unexplained, leaving most parameter semantics opaque.

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 operation: rotating prop builds around a copy origin and translating local positions. It adds a key constraint (single-body prop_physics with Weld/NoCollide only), which helps distinguish it from generic file-writing siblings, though it does not explicitly name 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 a meaningful applicability constraint ('Supports single-body prop_physics with Weld/NoCollide only') and notes default save behavior. However, it does not explain when to use this tool versus siblings like write_dupe or create_build, so usage guidance is implied rather than explicit.

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

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

Annotations already declare destructiveHint=true, and the description adds genuinely non-redundant context: overwrites create backups, unknown addon data is preserved losslessly, and revision falls back to source document or server default. That materially softens and explains the destructive risk. It does not cover auth/permissions or failure behavior, so not a 5.

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

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

Three tight sentences, front-loaded with the core action, then the lossless guarantee, then defaults and overwrite safety. No filler and no repetition of the tool name.

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?

An output schema exists so return values need no explanation, and the description covers the risky behaviors an agent must know before calling. The only gap is the unexplained required 'name' parameter and any failure/permission conditions, which keeps it from a 5.

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

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

Schema description coverage is 0%, so the description must carry the load. It explains 'document' (lossless, preserves unknown addon data), 'revision' (defaults to source document or server default), and implies 'overwrite' (creates backups), but the required 'name' parameter is never addressed at all.

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 ('Save a lossless document') and ties it to the counterpart sibling read_dupe, making the read/write pairing obvious. It is clear what the tool does, though it never says what a 'dupe' actually is or where the document is written.

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 strongly by 'returned by read_dupe', which tells the agent to use this only for documents that came from that sibling. There is no explicit when-not, no mention of overwrite vs create-new decision criteria, and no alternative tool named.

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