VRChat MCP Server

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

With no annotations, the description carries full burden but only states it 'adds' without detailing behavioral traits. It doesn't disclose permissions needed, rate limits, whether it's idempotent, or what happens on success/failure, leaving significant gaps for a mutation tool.

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

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

The description is a single, efficient sentence with no wasted words, making it front-loaded and easy to parse. It directly conveys the core action without unnecessary elaboration.

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 mutation tool with no annotations and no output schema, the description is inadequate. It lacks details on behavior, error handling, or return values, failing to provide enough context given the tool's complexity and missing structured data.

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

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

Schema description coverage is 100%, so the schema fully documents parameters. The description adds no extra meaning beyond the schema's details on 'type', 'favoriteId', and 'tags', resulting in a baseline score of 3 as it doesn't compensate but schema does the work.

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

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

The description clearly states the action ('Add') and resource ('favorite'), specifying it creates a new favorite. However, it doesn't differentiate from sibling tools like 'vrchat_list_favorites' or 'vrchat_list_favorited_worlds' beyond the basic verb, missing explicit scope comparison.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid ID from other tools), exclusions, or comparisons to siblings like 'vrchat_send_friend_request' for friends, leaving usage context implied.

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

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

No annotations are provided, so the description carries full burden. 'Create' implies a write/mutation operation, but the description doesn't disclose behavioral traits like authentication requirements, rate limits, whether the instance is immediately joinable, or what happens on failure. For a creation tool with 11 parameters, this is a significant gap.

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

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

The description is a single, clear sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately understandable despite its brevity.

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

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

For a creation tool with 11 parameters, 0% schema description coverage, no annotations, and no output schema, the description is incomplete. It doesn't explain what an 'instance' is in VRChat context, what happens after creation, or provide any parameter guidance. The conciseness comes at the cost of necessary context.

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

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

Schema description coverage is 0%, so the description must compensate but provides no parameter information. It doesn't explain what 'worldId', 'type', 'region', or any other parameters mean, their relationships, or typical values. With 11 parameters (3 with enums), this leaves critical usage information undocumented.

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

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

The description clearly states the action ('Create') and resource ('new instance of a world'), making the purpose immediately understandable. It distinguishes from siblings like 'vrchat_get_instance' (read vs. create) but doesn't explicitly differentiate from other creation-related tools (none exist in the sibling list).

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, when this operation is appropriate, or what happens after creation. With 11 parameters, some guidance on required vs. optional parameters would be helpful.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it 'retrieves' information, implying a read-only operation, but doesn't clarify aspects like authentication requirements (e.g., whether it works without login), rate limits, error conditions (e.g., if no user is logged in), or the format of the returned data. This leaves significant gaps in understanding how the tool behaves in practice.

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

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

The description is a single, efficient sentence that directly states the tool's function without any fluff or redundancy. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place, and there's no wasted verbiage.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimal but incomplete. It doesn't address behavioral aspects like authentication needs or error handling, and without an output schema, it doesn't hint at what information is returned (e.g., user ID, display name, avatar details). For a tool that likely interacts with user state, more context is needed to ensure reliable use.

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

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

The tool has 0 parameters, and the input schema has 100% description coverage (though empty). The description appropriately doesn't discuss parameters, as there are none to explain. It could theoretically mention that no inputs are required, but this is implicit, so a baseline score of 4 is justified for not adding unnecessary information.

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

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

The description clearly states the action ('Retrieve') and the resource ('your own VRChat user information'), making the purpose immediately understandable. It distinguishes itself from siblings like 'vrchat_get_friends_list' or 'vrchat_get_notifications' by specifying it returns the current user's data rather than other entities. However, it doesn't specify what specific information is included (e.g., username, avatar, status), which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication status), compare it to similar tools (e.g., if other tools might return user data in different contexts), or indicate scenarios where it's particularly useful (e.g., checking login status or fetching profile details). This lack of contextual direction leaves the agent to infer usage based on the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It lists retrievable fields but doesn't describe key behaviors: whether this requires authentication, rate limits, pagination handling (implied by offset/n parameters but not explained), or error conditions. The tool likely reads data (implied by 'Retrieve'), but this isn't explicitly stated as safe or read-only.

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 appropriately sized but poorly structured: it starts with a clear purpose sentence, then devotes the rest to a bulleted list of fields without integrating parameter or usage context. The list is exhaustive but could be more concise by grouping related fields or moving details to an output schema. It's front-loaded but loses focus.

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

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

Given the tool's moderate complexity (3 parameters, no annotations, no output schema), the description is incomplete. It details return fields but omits critical context: parameter semantics, authentication needs, pagination behavior, and error handling. Without an output schema, the bulleted list helps, but overall coverage is inadequate for effective agent use.

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

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

The input schema has 3 parameters (offset, n, offline) with 0% schema description coverage, meaning no parameter documentation in the schema. The description adds no information about these parameters—it doesn't explain what they do, their effects (e.g., pagination with offset/n, filtering offline friends), or default values. This fails to compensate for the schema gap.

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

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

The description clearly states the tool's purpose as 'Retrieve a list of VRChat friend information' with a specific verb ('Retrieve') and resource ('VRChat friend information'), which distinguishes it from siblings like vrchat_get_current_user or vrchat_search_avatars. However, it doesn't explicitly differentiate from potential list operations like vrchat_list_favorites, though the focus on friends 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 description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication), compare to siblings like vrchat_send_friend_request for adding friends, or specify scenarios (e.g., checking online status). Usage is implied by the name but not articulated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds valuable context about the limitation on detailed member information based on ownership, which is a behavioral trait not covered by the input schema. However, it doesn't disclose other potential behaviors like error conditions, rate limits, authentication needs, or response format, leaving gaps for a tool with no 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 appropriately sized with two sentences: the first states the purpose clearly, and the second adds crucial context about ownership limitations. Every sentence earns its place by providing essential information without redundancy, making it front-loaded and efficient.

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

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

Given the complexity of retrieving instance information with no annotations and no output schema, the description is partially complete. It covers the purpose and a key behavioral constraint (ownership-based access to details), but lacks information on return values, error handling, or other operational aspects. This leaves some gaps for effective tool use by an AI agent.

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

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

The input schema has 100% description coverage, with clear documentation for 'worldId' and 'instanceId' as valid IDs. The description doesn't add any meaning beyond this, such as explaining what constitutes a valid ID or how to obtain these values. Given the high schema coverage, a baseline score of 3 is appropriate as the schema handles parameter semantics adequately.

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

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

The description clearly states the tool's purpose as 'Get information about a specific instance,' which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'vrchat_get_current_user' or 'vrchat_search_worlds' that might also retrieve information, though the focus on 'instance' is distinct.

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

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

The description provides implied usage guidance through the note about detailed member information being available only to instance owners, which hints at when this tool is most useful. However, it doesn't explicitly state when to use this tool versus alternatives like 'vrchat_search_worlds' or 'vrchat_list_favorites,' nor does it mention prerequisites or exclusions beyond the ownership note.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds valuable context about admin credential requirements, which is crucial for authentication needs. However, it lacks details on rate limits, error handling, or what the return value looks like (e.g., message content format). The description doesn't contradict annotations, but it's incomplete for a tool with no annotation coverage.

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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by important context (admin requirement) and parameter details. Every sentence adds value, with no wasted words. It could be slightly more structured (e.g., bullet points for clarity), but it's efficient and well-organized.

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

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

Given the tool's complexity (3 parameters, no annotations, no output schema), the description is moderately complete. It covers purpose, usage context, and parameter semantics for one parameter, but lacks details on return values (e.g., what data is returned), error cases, or behavioral traits like rate limits. With no output schema, the description should ideally explain the return format, which it doesn't, leaving gaps in completeness.

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

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

Schema description coverage is 100%, so the schema already documents all parameters (userId, messageType, slot) with descriptions and constraints. The description adds some meaning by explaining the 'messageType' enum values (e.g., 'message = Message during a normal invite'), which clarifies semantics beyond the schema's enum list. However, it doesn't add significant value for other parameters, aligning with the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Returns a specific invite message.' It specifies the verb ('Returns') and resource ('invite message'), making it distinct from siblings like 'vrchat_list_invite_messages' (which lists messages) or 'vrchat_request_invite' (which sends invites). However, it doesn't explicitly differentiate from all siblings beyond the core function.

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

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

The description provides clear context for usage: 'Admin Credentials are required to view messages of other users!' This indicates when to use it (for admin-level access) and implies when not to use it (for non-admin users). It doesn't name specific alternatives or provide detailed exclusions, but the context is sufficient for basic guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but only states the basic action. It doesn't mention authentication requirements, rate limits, pagination behavior (beyond what's implied by parameters), error conditions, or what the returned list contains, leaving significant gaps for a tool with 6 parameters.

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, clear sentence that directly states the tool's purpose without any fluff or redundancy. It's appropriately sized and front-loaded, making it highly efficient and easy to parse.

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

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

For a tool with 6 parameters, no annotations, and no output schema, the description is insufficient. It lacks details on authentication, rate limits, return format, error handling, and how it differs from sibling tools, making it incomplete for effective agent use despite the concise structure.

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

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

The schema description coverage is 100%, with each parameter well-documented in the input schema (e.g., 'type' is deprecated, 'sent' must be false). The description adds no additional parameter semantics beyond the schema, so it meets the baseline of 3 where the schema does the heavy lifting.

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

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

The description clearly states the verb 'retrieve' and the resource 'list of VRChat notifications', making the purpose unambiguous. However, it doesn't differentiate this tool from potential siblings like 'vrchat_get_invite_message' or 'vrchat_list_invite_messages' which might also retrieve notification-like data, leaving room for improvement in sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. Given siblings like 'vrchat_get_invite_message' and 'vrchat_list_invite_messages', it doesn't clarify if this is the primary notification retrieval method or if there are specific scenarios where other tools are preferred, offering no usage context.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('Join') but doesn't explain what this entails—whether it requires user permissions, sends notifications, has rate limits, or what happens on success/failure. This leaves significant gaps for an AI agent to understand the tool's behavior.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core action and resource, making it easy to parse quickly.

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

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

Given the tool's complexity (a write operation to join a group), lack of annotations, and no output schema, the description is insufficient. It doesn't cover behavioral aspects like authentication needs, error conditions, or return values, leaving the AI agent with incomplete context for safe and effective use.

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

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

The input schema has 100% description coverage, with the single parameter 'groupId' documented as 'Must be a valid group ID'. The description adds no additional semantic context beyond this, such as where to obtain group IDs or format examples. Baseline 3 is appropriate since the schema already provides adequate parameter documentation.

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

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

The description clearly states the action ('Join') and target resource ('a VRChat group by ID'), making the purpose immediately understandable. However, it doesn't differentiate this tool from potential alternatives like 'vrchat_request_invite' or 'vrchat_send_friend_request' which might also involve joining or connecting to entities in VRChat.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing authentication, being a VRChat user), exclusions (e.g., cannot join private groups), or when to choose other tools like 'vrchat_search_groups' first to find group IDs.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool lists favorited worlds with filters, but doesn't mention whether this is a read-only operation, if it requires authentication, potential rate limits, or what the output format looks like (e.g., pagination, error handling). This leaves significant gaps for an AI agent to understand how to invoke it safely and effectively.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('List favorited worlds') and adds a qualifier ('by query filters'). There is no wasted verbiage or redundancy, making it easy to parse quickly while conveying essential information.

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

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

For a tool with 4 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't address behavioral aspects like authentication needs, rate limits, or output structure (e.g., list format, error cases). Given the complexity of filtering and sorting favorited worlds, more context is needed to guide effective usage beyond what the parameter schema provides.

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

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

The input schema has 100% description coverage, providing clear documentation for all 4 parameters (featured, sort, n, order) with enums and constraints. The description adds minimal value beyond the schema by mentioning 'query filters' generically, but doesn't explain how these parameters interact or typical usage patterns (e.g., combining sort and order). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('List') and resource ('favorited worlds') with a qualifier ('by query filters'), making the purpose immediately understandable. It distinguishes from siblings like 'vrchat_list_favorites' by specifying 'worlds' rather than general favorites, but doesn't explicitly contrast with 'vrchat_search_worlds' which might have overlapping functionality.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'vrchat_list_favorites' (which might list all favorites) or 'vrchat_search_worlds' (which might search worlds more broadly). It mentions 'query filters' but doesn't specify typical use cases or prerequisites for filtering favorited worlds.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool returns a list, implying a read-only operation, but does not cover aspects like authentication requirements, rate limits, pagination behavior (beyond offset parameter), or error handling. This is a significant gap for a tool with parameters and no structured safety hints.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary details. It is front-loaded and wastes no words, making it easy for an agent to parse quickly and understand the core functionality.

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

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

Given the tool has 3 parameters with full schema coverage but no annotations or output schema, the description is minimally adequate. It covers the basic purpose but lacks details on behavioral traits, usage context, and return values, which are important for an agent to invoke it correctly in a broader context with sibling tools.

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

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

Schema description coverage is 100%, so the input schema fully documents the parameters (n, offset, ownerId). The description adds minimal value beyond the schema by mentioning filtering by owner ID, but it does not provide additional context like default behavior for missing ownerId or practical usage examples. Baseline score of 3 is appropriate as the schema handles most of the parameter documentation.

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

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

The description clearly states the verb ('Returns') and resource ('list of favorite groups owned by a user'), making the purpose understandable. However, it does not explicitly differentiate from sibling tools like 'vrchat_list_favorites' or 'vrchat_list_favorited_worlds', which might handle similar list operations but for different resource types, leaving some ambiguity in sibling distinction.

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

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

No explicit guidance is provided on when to use this tool versus alternatives. The description mentions filtering by owner ID, but it does not specify scenarios for using this tool over other list or search tools in the sibling set, such as 'vrchat_list_favorites' or 'vrchat_search_groups', leaving the agent without clear usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but offers minimal information. It implies a read-only operation ('returns'), but doesn't cover aspects like authentication needs, rate limits, pagination behavior (beyond what the schema hints at with 'offset'), error handling, or response format. This leaves significant gaps for a tool with four parameters and no output schema.

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

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

The description is a single, efficient sentence with no wasted words, making it appropriately concise. However, it lacks front-loading of critical details (e.g., scope or differentiation from siblings), which slightly reduces its effectiveness despite the brevity.

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

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

Given the tool's complexity (4 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain the return structure, error conditions, or how it relates to sibling tools, leaving the agent with insufficient context to use it effectively beyond basic parameter passing.

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

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

Schema description coverage is 100%, with each parameter well-documented in the schema (e.g., 'n' for count, 'type' for filtering). The description adds no additional meaning beyond the schema, such as explaining how filters interact or typical use cases for parameters. Baseline 3 is appropriate as the schema handles the heavy lifting, but the description doesn't compensate with extra context.

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 'Returns a list of favorites' states the basic action but is vague about scope and context. It specifies the verb ('returns') and resource ('favorites'), but doesn't distinguish this tool from sibling tools like 'vrchat_list_favorited_worlds' or 'vrchat_list_favorite_groups', leaving ambiguity about what exactly constitutes 'favorites' in this context.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention sibling tools like 'vrchat_list_favorited_worlds' for world-specific favorites or 'vrchat_get_friends_list' for friends, nor does it clarify prerequisites or typical use cases, leaving the agent to infer usage from the tool name alone.

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

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 a critical behavioral trait: 'Admin Credentials are required to view messages of other users!' This addresses authentication needs and access restrictions. However, it lacks details on rate limits, pagination, error handling, or what the returned list includes (e.g., format, fields). The description adds value but doesn't fully compensate for the absence of 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 appropriately sized and front-loaded: the first sentence states the core purpose, and the second adds crucial context (admin requirement). Every sentence earns its place with no wasted words, making it efficient and easy to parse.

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

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

Given the tool's complexity (2 required parameters, no output schema, no annotations), the description is partially complete. It covers purpose and admin requirements but lacks details on return values (since no output schema), error cases, or behavioral nuances like pagination. It's adequate for basic use but has clear gaps for full agent understanding.

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

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

Schema description coverage is 100%, with both parameters ('userId' and 'messageType') well-documented in the schema (e.g., 'userId' requires a valid user ID, 'messageType' has an enum). The description doesn't add any meaning beyond this, such as explaining how 'userId' relates to admin access or clarifying enum values. Baseline score of 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Returns a list of all the users Invite Messages.' It specifies the verb ('returns') and resource ('Invite Messages'), and distinguishes it from sibling tools like 'vrchat_get_invite_message' (singular) by indicating it fetches multiple messages. However, it doesn't explicitly differentiate from other list tools like 'vrchat_list_favorites' beyond the resource type.

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

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

The description provides clear context for when to use this tool: 'Admin Credentials are required to view messages of other users!' This implies it's for administrative purposes and not for general user access. However, it doesn't explicitly state when not to use it or name alternatives (e.g., vs. 'vrchat_get_invite_message' for a single message), though the context is sufficient for informed usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: the need for user permission, restrictions about private instances, and the return value ('Returns the Notification of type requestInvite that was sent'). It doesn't mention rate limits or error conditions, but covers essential operational constraints.

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 efficiently structured with three sentences: purpose statement, two important usage guidelines, and return value information. Every sentence adds essential value with zero wasted content, and critical information ('IMPORTANT') is appropriately front-loaded.

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

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

For a mutation tool with no annotations and no output schema, the description provides good contextual coverage: purpose, usage constraints, and return value. It doesn't explain error cases or authentication requirements, but covers the essential operational context given the tool's complexity.

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

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

Schema description coverage is 100%, providing complete parameter documentation. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline expectation without enhancing parameter understanding.

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

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

The description clearly states the specific action ('Request an invite from a user') and resource ('user'), distinguishing it from sibling tools like 'vrchat_send_friend_request' or 'vrchat_join_group'. It precisely defines the tool's function without being vague or tautological.

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

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

The description provides explicit usage guidance: 'Always obtain explicit permission from the user before sending an invite request' and 'invite requests cannot be sent to users in private instances'. This clearly defines when to use (with permission, not in private instances) and includes important 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 provided, the description carries the full burden of behavioral disclosure. It adds some useful context about search limitations (own/featured avatars only) and user permissions, but doesn't describe important behavioral aspects like pagination behavior (offset parameter), rate limits, authentication requirements, or what the response format looks like.

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 appropriately sized with three clear sentences. The first sentence states the purpose, the second and third provide important usage constraints. There's no wasted text, though it could be slightly more structured with bullet points for the constraints.

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

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

Given the complexity (13 parameters, no schema descriptions, no output schema, no annotations), the description is incomplete. It covers basic purpose and some usage constraints but doesn't address parameter meanings, return values, error conditions, or important behavioral aspects needed for a search tool with many filtering options.

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

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

With 0% schema description coverage and 13 parameters, the description provides no information about any parameters. It mentions 'query filters' generically but doesn't explain what specific filters are available, their purposes, or how they interact. The description fails to compensate for the complete lack of parameter documentation in the schema.

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

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

The description clearly states the tool's purpose as 'Search and list avatars by query filters', which is a specific verb+resource combination. However, it doesn't explicitly differentiate this tool from sibling tools like 'vrchat_search_groups' or 'vrchat_search_worlds' beyond the resource type, missing full sibling differentiation.

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

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

The description provides clear context about when to use this tool: 'You can only search your own or featured avatars. It is not possible as a normal user to search other people's avatars.' This gives important usage boundaries but doesn't explicitly mention when to choose this tool over alternatives like 'vrchat_select_avatar' or other search 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 provided, the description carries full burden but offers minimal behavioral insight. It implies a read-only search operation but doesn't disclose critical traits like authentication requirements, rate limits, pagination behavior (beyond offset/n parameters), error conditions, or what the output looks like (no output schema). This leaves significant gaps for an agent to understand tool behavior.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately front-loaded with the core functionality, making it easy for an agent to parse quickly. Every word earns its place in conveying the essential action.

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

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

Given the tool's moderate complexity (search with pagination), lack of annotations, and absence of an output schema, the description is insufficiently complete. It doesn't address authentication needs, result format, error handling, or how this tool fits within the broader VRChat API context. The agent would struggle to use this effectively without additional behavioral context.

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

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

Schema description coverage is 100%, providing clear documentation for all three parameters. The description adds marginal value by specifying that the query searches 'Group Name or Group shortCode', which slightly elaborates beyond the schema's 'Query to search for, can be either Group Name or Group shortCode'. This meets the baseline for high schema coverage without significant enhancement.

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

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

The description clearly states the action ('Search') and target resource ('VRChat groups'), specifying searchable attributes ('by name or shortCode'). It distinguishes from siblings like 'vrchat_list_favorite_groups' by focusing on search rather than listing, though it doesn't explicitly contrast with 'vrchat_search_avatars' or 'vrchat_search_worlds' which share the search pattern.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication), differentiate from similar search tools (e.g., 'vrchat_search_avatars'), or indicate scenarios where other tools like 'vrchat_join_group' might be more appropriate after finding a group.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'search and list' but doesn't specify whether this is a read-only operation, what permissions might be needed, how results are paginated (beyond the 'offset' parameter), or what the output format looks like. For a search tool with 10 parameters, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's appropriately sized and front-loaded with the core purpose.

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

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

Given the complexity (10 parameters, no annotations, no output schema), the description is insufficient. It doesn't explain what a 'world' represents in VRChat context, what fields are returned, how results are structured, or any rate limits/authentication requirements. For a search tool with many filtering options, more context is needed.

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

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

Schema description coverage is 100%, so the schema already documents all 10 parameters thoroughly with descriptions and enums. The description adds minimal value beyond stating 'by query filters,' which is already implied by the parameter names. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose as 'Search and list worlds by query filters,' which specifies both the action (search/list) and resource (worlds). It distinguishes from siblings like 'vrchat_search_avatars' and 'vrchat_search_groups' by focusing on worlds, but doesn't explicitly differentiate from 'vrchat_list_favorited_worlds' or other world-related tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'vrchat_list_favorited_worlds' for finding worlds, or whether it's for general discovery versus specific user scenarios. No exclusions or prerequisites 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?

With no annotations, the description carries full burden but only states the action without disclosing behavioral traits like whether switching is immediate, requires authentication, has side effects, or returns confirmation. It's minimal and lacks operational details.

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

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

The description is a single, efficient sentence that directly states the tool's function without redundancy. It's front-loaded and appropriately sized, with no wasted words.

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

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

Given the complexity of an avatar-switching tool with no annotations or output schema, the description is insufficient. It doesn't cover success/failure outcomes, error handling, or integration with sibling tools, leaving gaps in operational context.

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

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

Schema description coverage is 100%, so the schema fully documents the 'avatarId' parameter. The description adds no extra meaning beyond implying selection, which aligns with the schema but doesn't enhance understanding, meeting the baseline for high coverage.

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

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

The description clearly states the action ('select and switch') and resource ('specific avatar by its ID'), making the purpose evident. However, it doesn't differentiate from sibling tools like 'vrchat_search_avatars' or 'vrchat_add_favorite', which reduces specificity.

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

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

No guidance is provided on when to use this tool versus alternatives, such as whether it's for personal avatar changes or requires specific permissions. The description lacks context about prerequisites or exclusions, leaving usage unclear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action but lacks critical details: whether this requires authentication, if there are rate limits, if the request can be canceled, what happens on duplicate requests, or what the response looks like (success/failure). For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence that directly states the tool's purpose with zero wasted words. It is appropriately sized for a simple tool and front-loaded with the core action.

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

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

Given the tool's complexity (a mutation with social implications), lack of annotations, no output schema, and 0% schema description coverage, the description is incomplete. It should cover authentication needs, error conditions, response format, and usage context to be minimally adequate. Currently, it only states the basic action without supporting details.

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

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

The description does not mention the 'userId' parameter at all, and schema description coverage is 0%, so the parameter is undocumented in both schema and description. However, with only one required parameter, the agent can infer it's the target user, giving a baseline score. The description adds no value beyond what's obvious from the tool name and schema structure.

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

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

The description clearly states the action ('send a friend request') and target ('to another user'), which is specific and unambiguous. It distinguishes from siblings like 'vrchat_get_friends_list' (read) or 'vrchat_join_group' (different resource). However, it doesn't explicitly differentiate from 'vrchat_request_invite', which might be a similar social interaction but for instances rather than friendships.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing to know the user ID), exclusions (e.g., cannot send to existing friends), or related tools like 'vrchat_get_friends_list' to check current friends first. Usage is implied only by the action itself.

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