Parallels RAS MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes targeting specific resources (e.g., farm, infra, pub, site) and actions (get, list), with clear boundaries like ras_farm_get_licensing vs. ras_farm_get_config. However, some overlap exists in 'get' operations across similar resources (e.g., ras_infra_get_rds_hostpools and ras_infra_get_rds_hosts), which could cause minor confusion but is mitigated by detailed descriptions.
Naming Consistency5/5
All tools follow a consistent snake_case pattern with a clear structure: ras_<category>_<action>_<resource> (e.g., ras_farm_get_administrators, ras_pub_get_all_items). This predictability makes it easy for agents to understand the tool's domain and purpose at a glance, with no deviations in naming style.
Tool Count2/5
With 41 tools, the count is excessive for a single server, likely overwhelming for agents to navigate efficiently. While the domain (Parallels RAS management) is broad, the toolset could be streamlined by grouping related operations (e.g., combining multiple 'get' tools into fewer, more general ones) to reduce cognitive load and improve usability.
Completeness5/5
The toolset provides comprehensive coverage for managing a Parallels RAS farm, including configuration, infrastructure, publishing, sessions, and site settings. It supports full CRUD-like operations (primarily read/get actions) across all key areas, with no obvious gaps—agents can audit, monitor, and troubleshoot the entire system effectively.
Average 4.5/5 across 41 of 41 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide comprehensive behavioral hints (readOnly, openWorld, idempotent, non-destructive), so the description doesn't need to repeat these. It adds useful context about the tool's purpose and scope, but doesn't disclose additional behavioral traits like rate limits, authentication requirements, or pagination behavior that could be helpful beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each serve distinct purposes: the first defines what the tool does, and the second provides usage guidance. There's no wasted language, and the information is front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only, parameterless tool with comprehensive annotations, the description provides adequate context about purpose and usage. However, without an output schema, it doesn't describe what the response looks like (e.g., format, structure, or example output), which would be helpful for an agent to understand what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, and instead focuses on the tool's purpose and usage, which is the correct approach for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List'), resource ('user portal themes'), and scope ('configured in the RAS farm'), with specific details about what's included ('branding, logos, and customisation settings'). It distinguishes from sibling tools by focusing specifically on themes rather than other infrastructure components like certificates or connection brokers.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage contexts ('review portal appearance configuration' and 'verify theme assignments'), giving clear guidance on when to use this tool. However, it doesn't specify when NOT to use it or mention alternative tools for related tasks, preventing a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide comprehensive behavioral hints (readOnlyHint=true, destructiveHint=false, openWorldHint=true, idempotentHint=true), so the agent knows this is a safe, non-destructive read operation. The description adds useful context about what information is returned (policy names, settings, assignment status) and the purpose of client policies, but doesn't provide additional behavioral details like pagination, rate limits, or authentication requirements beyond what annotations cover.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences: the first states the tool's purpose and output, the second provides context about client policies and usage scenarios. Every sentence adds value without redundancy, and it's appropriately front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with comprehensive annotations and no parameters, the description provides good context about what information is returned and when to use it. However, without an output schema, the description could benefit from more detail about the return format (e.g., whether it's a list, object structure, or paginated). The current description is mostly complete but has a minor gap in output specification.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, focusing instead on the tool's purpose and output. No parameter information is needed or expected given the empty input schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('List all Parallels RAS client policies') and resource ('client policies'), with explicit scope ('including policy names, settings, and assignment status'). It distinguishes from sibling tools by focusing specifically on client policies rather than farms, infrastructure, publishing, sessions, sites, or support info.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 ('to audit policy configuration or troubleshoot client behaviour issues'), giving practical application scenarios. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the many sibling tools, though the purpose differentiation implies it's for client policies specifically.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover key behavioral traits: readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true. The description adds some context by mentioning 'full desktops' and access verification, but doesn't disclose additional traits like rate limits, pagination, or error handling. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences that are front-loaded with the core purpose and followed by specific usage examples. Every sentence adds value without redundancy, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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) and rich annotations covering safety and behavior, the description is mostly complete. It could slightly improve by hinting at return format or data scope, but it adequately complements the structured data for this read-only listing tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose and usage. A baseline of 4 is applied since no parameters exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('published desktop resources'), specifying these are 'full desktops available to users via RDS, VDI, or AVD.' It distinguishes from siblings like ras_pub_get_avd_apps or ras_pub_get_rds_apps by focusing on desktops rather than apps, and from ras_pub_get_all_items by being more specific to desktops.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 it: 'to review desktop assignments, check which desktop types are published, or verify user access.' It doesn't explicitly state when not to use it or name alternatives, but the context is sufficiently clear for an agent to infer usage scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide key behavioral hints (readOnlyHint: true, openWorldHint: true, idempotentHint: true, destructiveHint: false), so the description does not need to repeat these. It adds some context by mentioning the types of data included in the listing, but does not disclose additional traits like pagination, rate limits, or authentication requirements beyond what annotations cover.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences: the first states the purpose and output details, and the second provides usage scenarios. Every sentence adds value without waste, making it front-loaded and easy to understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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) and rich annotations, the description is largely complete. It covers purpose, output details, and usage context. However, it could be slightly enhanced by mentioning the lack of filtering options or clarifying the relationship with sibling tools like ras_pub_get_all_items for completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline is high. The description does not need to explain parameters, and it appropriately focuses on the tool's purpose and output details, adding value by specifying what information is included in the listing without redundant parameter explanations.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('List published RDS applications') and resource ('RDS applications'), distinguishing it from siblings like ras_pub_get_avd_apps or ras_pub_get_vdi_apps by specifying RDS applications. It also lists specific attributes included in the output (app names, executable paths, server associations, user filter assignments).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 ('to review which applications are published via RDS, check app configurations, or troubleshoot application launch issues'), giving practical scenarios. However, it does not explicitly state when NOT to use it or mention alternatives among the sibling tools, such as ras_pub_get_all_items which might overlap in scope.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a read-only, non-destructive, idempotent operation with open-world data, covering key behavioral traits. The description adds value by clarifying the tool's focus on resource allocation and troubleshooting, but does not disclose additional behaviors like rate limits or authentication needs beyond what annotations provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by usage guidelines in the second. Every sentence adds value without redundancy, making it efficient and well-structured for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (0 parameters, read-only operation with annotations), no output schema, and clear purpose, the description is largely complete. It could slightly improve by hinting at the return format (e.g., settings structure) but is adequate for the context provided.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline is 4 as no parameter documentation is needed. The description appropriately does not discuss parameters, focusing instead on the tool's purpose and usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('CPU optimization settings for the site'), specifying it retrieves configuration for resource allocation across user sessions. It distinguishes from sibling tools like ras_site_get_load_balancing or ras_site_get_ad_integration by focusing on CPU-specific policies.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage contexts: 'review resource management policies' and 'troubleshoot performance issues', giving clear guidance on when to use this tool. However, it does not mention when not to use it or name specific alternatives among siblings, such as ras_farm_get_performance for broader metrics.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a read-only, non-destructive, idempotent, and open-world operation, covering key safety traits. The description adds value by clarifying the tool's focus on administrative accounts and its use for auditing purposes, which provides context beyond annotations. No contradictions exist, as listing aligns with read-only behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, using two sentences that efficiently convey the tool's function and use cases without unnecessary details. Each sentence adds value: the first defines the action and data, and the second provides practical applications, making it front-loaded and waste-free.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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) and rich annotations, the description is largely complete, covering purpose and usage. However, it could slightly enhance completeness by mentioning the return format (e.g., list of administrators) or any limitations, though annotations already provide safety context, making this a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the schema fully documents the lack of inputs. The description appropriately does not discuss parameters, maintaining focus on the tool's purpose and usage. This meets the baseline expectation for a parameterless tool without redundancy.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('List RAS farm administrator accounts') and resource ('administrator accounts'), distinguishing it from siblings like ras_farm_get_config or ras_farm_get_licensing by focusing on administrative personnel rather than configuration or licensing data. It specifies the data returned (usernames, roles, permissions, group membership), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 ('to audit admin access, verify role assignments, or review who has administrative control of the farm'), which helps the agent understand appropriate scenarios. However, it does not explicitly mention when not to use it or name specific alternatives among siblings, such as ras_policies_list for policy-related audits, leaving some room for improvement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds valuable context beyond annotations by specifying what licensing data is returned (type, expiration, seat count, usage, activation status) and the tool's diagnostic purpose. While annotations already indicate read-only, non-destructive, idempotent, and open-world behavior, the description usefully elaborates on the specific information retrieved and use cases.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences: the first states what the tool does and what data it returns, the second provides usage scenarios. Every word earns its place with zero redundancy or wasted space, and the information is front-loaded effectively.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless read-only tool with comprehensive annotations, the description provides excellent context about what licensing information is retrieved and when to use it. The only minor gap is the lack of output schema, but the description compensates by listing the specific data points returned. It's nearly complete for this tool's complexity level.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, and instead focuses on the data returned by the tool, which is the correct emphasis for a parameterless query tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('get licensing status') and resources ('RAS licensing'), listing concrete data points like license type, expiration date, seat count, usage, and activation status. It distinguishes itself from sibling tools by focusing specifically on licensing information rather than administrators, configuration, performance, or other aspects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage contexts ('check license compliance, verify capacity, or diagnose licensing issues'), giving practical scenarios for when to use this tool. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the many sibling tools, which prevents a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide excellent behavioral coverage (read-only, open-world, idempotent, non-destructive). The description adds useful context about what information is retrieved (configuration, counters, thresholds, settings), which helps the agent understand the scope of data returned beyond what annotations indicate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each earn their place. The first sentence states what the tool does, and the second provides usage guidance. No wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with comprehensive annotations and no parameters, the description provides sufficient context about what information is retrieved. However, without an output schema, the description could benefit from more detail about the structure of returned data (e.g., whether it's a single object or array, what fields to expect).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline is 4. The description appropriately doesn't discuss parameters since none exist, focusing instead on what the tool retrieves.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('get', 'review', 'check') and resources ('performance monitor configuration and counters', 'resource utilisation thresholds', 'monitoring settings'). It distinguishes from siblings by focusing on performance monitoring rather than administrators, config, licensing, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context ('review performance baselines or check monitoring configuration'), which helps the agent understand when to use this tool. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the many sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already provide comprehensive behavioral hints (readOnly=true, destructive=false, etc.), so the bar is lower. The description adds valuable context about what information is retrieved (configuration details) and the verification purpose, which helps the agent understand the tool's behavior beyond the basic safety profile indicated by annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each earn their place: the first states the purpose and scope, the second provides usage guidance. No wasted words, and the information is front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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, comprehensive annotations indicating safe read operation), the description provides adequate context about what configuration is retrieved and the verification purpose. The main gap is the lack of output schema, but the description compensates somewhat by listing the configuration aspects. For a read-only configuration check tool, this is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, and instead focuses on what configuration aspects are retrieved, which adds semantic value about the tool's scope.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get reporting configuration') and resource ('RAS farm'), listing the key configuration aspects (report scheduling, data retention, database connection settings). It distinguishes from sibling tools by focusing specifically on reporting configuration, unlike other 'get' tools that target administrators, licensing, performance, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 ('to verify reporting is enabled and properly configured'), which gives practical guidance. However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the many sibling tools, though the purpose differentiation is implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already provide strong behavioral hints (readOnly, openWorld, idempotent, non-destructive). The description adds valuable context about what information is returned (hostname, IP, OS, agent version, status) and the practical use cases. It doesn't contradict annotations and provides additional behavioral insight beyond what annotations offer.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each earn their place. The first sentence states what the tool does and what information it returns. The second sentence provides usage guidance. There's zero wasted language or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only listing tool with comprehensive annotations and no parameters, the description provides good context about what information is returned and when to use it. However, without an output schema, the description could benefit from more detail about the return format (e.g., whether it's paginated, sorted, or includes all fields mentioned).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, which is correct for this tool. No parameter information is needed or provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and the resource 'Parallels RAS agents deployed across the farm', specifying what information is included (hostname, IP, OS, agent version, current status). It distinguishes itself from sibling tools by focusing specifically on agents rather than other infrastructure components like certificates, connection brokers, or sites.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage contexts: 'verify agent deployment, diagnose connectivity issues, or check agent versions'. This gives clear guidance on when to use this tool. However, it doesn't specify when NOT to use it or name alternative tools for similar purposes, which prevents a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds value by explaining that the tool lists 'membership and configuration' for 'load balancing and resource allocation,' providing context on what information is retrieved, which enhances transparency beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by explanatory context and usage examples. Each sentence adds value without redundancy, and the structure is efficient, making it easy to understand quickly with zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (read-only list operation with no parameters) and rich annotations (covering safety and idempotency), the description is mostly complete. It explains what is listed and why, but lacks details on output format or pagination, and there is no output schema, leaving a minor gap in full context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately does not discuss parameters, focusing on the tool's purpose instead. A baseline of 4 is applied as it compensates well for the lack of parameters by adding semantic context about what the tool lists.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('RDS host pool membership and configuration'), specifying what the tool does. It distinguishes from siblings like 'ras_infra_get_rds_hosts' (individual hosts) and 'ras_infra_get_vdi_hostpools' (VDI pools), making the purpose specific and well-differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 ('to review pool composition, check host assignments, or verify pool settings'), giving practical scenarios. However, it does not explicitly state when not to use it or name alternatives among siblings, such as 'ras_infra_get_rds_hosts' for individual host details, which prevents a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a read-only, non-destructive, idempotent, and open-world operation, covering key behavioral traits. The description adds valuable context by specifying the types of details returned (e.g., CPU/RAM usage, OS version) and the tool's use cases (monitoring, troubleshooting), which enhances transparency beyond the annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences: the first lists the action and details returned, and the second provides usage guidelines. Every sentence adds value without redundancy, making it front-loaded and appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a read-only list operation with rich annotations but no output schema), the description is mostly complete. It covers purpose, usage, and returned details well. However, it lacks information on output format (e.g., list structure, pagination) or error handling, which would be helpful since there's no output schema, preventing a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, meaning no parameters are documented in the schema. The description does not mention any parameters, which is appropriate since none exist, but it could have explicitly stated 'no parameters required' for clarity. Given the baseline of 4 for 0 parameters, this is a strong score with minor room for improvement.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('List RDS session hosts') and resource ('RDS session hosts'), distinguishing it from sibling tools like 'ras_infra_get_agents' or 'ras_infra_get_connection_brokers' by focusing exclusively on RDS hosts. It provides a detailed list of what information is included (hostname, IP, agent status, etc.), making the purpose highly specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('to monitor host health, check capacity, or troubleshoot RDS issues'), providing clear context for its application. However, it does not specify when not to use it or mention alternatives among sibling tools, such as 'ras_infra_get_vdi_hostpools' for VDI-related monitoring, which prevents a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare this as read-only, non-destructive, idempotent, and open-world, covering key behavioral traits. The description adds valuable context by mentioning 'multi-site deployments distribute infrastructure across locations,' which helps the agent understand the operational environment. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise and front-loaded: the first sentence states the core purpose, followed by explanatory context and usage scenarios. Every sentence adds value without redundancy, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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) and rich annotations, the description is mostly complete. It covers purpose, context, and usage well. A slight deduction because it doesn't hint at the return format (e.g., list structure or status details), which could help the agent interpret results, though annotations mitigate this gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline is 4. The description appropriately doesn't discuss parameters, as none exist, and instead focuses on the tool's purpose and usage, which is efficient and correct.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('List all sites'), resource ('configured in the RAS farm'), and scope ('and their status'), distinguishing it from sibling tools like ras_infra_get_agents or ras_infra_get_gateway_status that focus on other infrastructure components. It explicitly identifies what the tool does without being tautological.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 ('to check site connectivity, verify site configuration, or audit the farm topology'), giving practical scenarios. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools, which prevents a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already provide strong behavioral hints (read-only, open-world, idempotent, non-destructive), but the description adds valuable context by explaining what VDI templates are ('Templates define the base image and settings for provisioned VDI desktops') and what specific information is returned. This enhances understanding beyond the basic safety profile indicated by annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with three sentences that each serve a distinct purpose: stating the action, defining the resource, and providing usage guidance. There's no wasted language, and the information is front-loaded with the core purpose stated first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only listing tool with comprehensive annotations and no parameters, the description provides excellent context about what information is returned and when to use it. The only minor gap is the lack of output schema, but the description compensates well by specifying what information is included ('status, and configuration') and providing usage examples.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, and instead focuses on the tool's purpose and output semantics, which is the correct approach for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('VDI templates'), and specifies what information is included ('their status, and configuration'). It distinguishes from siblings by focusing specifically on VDI templates rather than other infrastructure components like agents, certificates, or connection brokers listed in the sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage contexts ('Use this to check template versions, maintenance mode status, or provisioning settings'), giving clear guidance on when to use this tool. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools, which prevents a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, read-only, idempotent operation. The description adds useful context about the scope ('across all resource types') and purpose ('complete overview'), but doesn't provide additional behavioral details like pagination, rate limits, or response format that would be helpful given the lack of 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each earn their place: the first defines the tool's scope and action, the second provides explicit usage guidance. There's zero wasted language, and the information is front-loaded with the core purpose immediately stated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (aggregating multiple resource types), the rich annotations cover safety and behavior aspects well, and with 0 parameters fully documented in the schema, the description provides good contextual completeness. The main gap is the lack of output schema, but the description compensates somewhat by explaining what information will be returned ('everything published in the farm').
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so there are no parameters to document. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose and usage. A baseline of 4 is appropriate for a zero-parameter tool where the schema fully covers the input requirements.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('List all published items') and resource scope ('across all resource types (RDS, VDI, AVD apps and desktops) in a single view'), distinguishing it from sibling tools like ras_pub_get_avd_apps or ras_pub_get_rds_apps that focus on specific resource types. It explicitly mentions the comprehensive nature of the tool versus more targeted alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('for a complete overview of everything published in the farm, or to search across all resource types'), effectively distinguishing it from sibling tools that handle specific resource types or administrative functions. It clearly indicates this is the tool for cross-resource aggregation rather than filtered views.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare this as read-only, non-destructive, idempotent, and open-world. The description adds valuable context beyond annotations by explaining that these are 'Azure-hosted session hosts' apps and mentioning the purpose of 'reviewing assignments' and 'verifying publishing.' It doesn't contradict annotations, and provides useful operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences with zero wasted words. The first sentence states the core purpose, and the second provides usage guidance. Every sentence earns its place, and the information is front-loaded effectively.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a simple list operation with comprehensive annotations (read-only, non-destructive, etc.) and no parameters, the description provides good context about what's being listed and why. However, without an output schema, it doesn't describe what information is returned about each app (e.g., names, IDs, assignment details), leaving some ambiguity about the response format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, and instead focuses on the tool's purpose and usage context, which is the correct approach for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('published Azure Virtual Desktop (AVD) applications'), and distinguishes this tool from siblings like ras_pub_get_rds_apps and ras_pub_get_vdi_apps by specifying it's for AVD apps delivered from Azure-hosted session hosts. It provides specific context about what makes these apps unique.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('to review AVD app assignments or verify Azure-based application publishing'), providing clear context. However, it doesn't specify when NOT to use it or explicitly name alternatives among the sibling tools (like ras_pub_get_rds_apps for RDS apps).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, open-world, idempotent, and non-destructive behavior, so the description adds value by explaining the tool's purpose in reviewing hierarchy and access settings, without contradicting annotations. However, it lacks details on rate limits or authentication needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by specific use cases, making it efficient and well-structured with no wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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) and rich annotations, the description is largely complete for a read-only listing tool. However, it could benefit from mentioning the return format or pagination behavior to fully guide the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline is 4. The description appropriately does not discuss parameters, focusing instead on the tool's purpose and usage, which aligns with the empty input schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('List published resource folders') and resource ('folders that organise applications and desktops'), distinguishing it from sibling tools like ras_pub_get_all_items or ras_pub_get_desktops by focusing on folder hierarchy and organisation rather than individual items or resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 ('review the folder hierarchy, check resource organisation, or verify folder-level access settings'), but does not explicitly mention when not to use it or name alternative tools for related tasks, such as ras_pub_get_all_items for a broader list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, non-destructive, idempotent, and open-world behavior. The description adds valuable context by specifying what information is retrieved (MFA providers, rules, bypass conditions) and the use cases (audit, troubleshooting), enhancing understanding beyond the annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences that are front-loaded with the core purpose and followed by usage guidance. Every sentence adds value without waste, making it efficiently structured and appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 0 parameters, rich annotations (read-only, etc.), and no output schema, the description is largely complete. It covers purpose, usage, and behavioral context. A minor gap is the lack of detail on return format (e.g., structure of configuration data), but this is partially mitigated by the annotations and low complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on the tool's purpose and usage without redundant parameter details, aligning with the baseline expectation for zero-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and specifies the resource 'multi-factor authentication provider configuration' with detailed components (enabled MFA providers, criteria rules, bypass conditions). It distinguishes from sibling tools like ras_site_get_ad_integration by focusing on MFA security, making the purpose specific and well-differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: 'to audit MFA security posture or troubleshoot MFA login failures.' This provides clear context for usage. However, it does not mention when not to use it or name specific alternatives among siblings, which prevents a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, open-world, idempotent, and non-destructive behavior. The description adds valuable context by specifying that it retrieves configuration details for alert triggers, email notifications, and event thresholds, which helps the agent understand the scope of data returned, though it does not mention rate limits or authentication needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence and follows with usage context in the second, with no wasted words. Every sentence adds value, making it efficiently structured and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (0 parameters, no output schema) and rich annotations covering safety and behavior, the description is sufficiently complete. It explains what configuration data is retrieved and why to use it, though it could briefly mention the return format or data structure for added clarity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on the tool's purpose without redundant parameter details, earning a baseline score of 4 for zero-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get notification event configuration') and resource ('alert triggers, email notifications, and event thresholds'), distinguishing it from sibling tools like ras_site_get_ad_integration or ras_site_get_mfa by focusing on notification events rather than other site configurations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 ('to review which events trigger admin notifications or verify alerting is properly configured'), but it does not explicitly mention when not to use it or name alternative tools for related tasks, such as ras_site_get_connection_settings for other configurations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a read-only, non-destructive, idempotent operation with open-world semantics. The description adds useful context by explaining what URL redirection does ('allows specific URLs opened on RDS hosts to be redirected to the client device browser'), which helps the agent understand the domain-specific behavior beyond the generic annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences: the first states the purpose, and the second provides usage guidance. Every sentence adds value with no redundant or unnecessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read-only tool with comprehensive annotations, the description provides sufficient context about what the tool retrieves and why to use it. However, without an output schema, it doesn't describe the return format (e.g., list of rules with specific fields), leaving a minor gap in completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline is 4. The description appropriately does not discuss parameters since none exist, and instead focuses on the tool's purpose and usage context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('Get URL redirection rules') and resources ('configured for the site'), and distinguishes it from siblings by focusing on URL redirection rules rather than other site configurations like AD integration or MFA.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 the tool ('to review redirection rules or troubleshoot URL handling'), but does not explicitly mention when not to use it or name alternative tools for related tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare this as read-only, non-destructive, idempotent, and open-world. The description adds useful context about what configuration elements are retrieved (farm name, domain, backup settings, global options) and the tool's purpose for review/verification. It doesn't contradict annotations and provides additional behavioral context beyond what annotations cover.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two well-structured sentences with zero waste. The first sentence states purpose and scope, the second provides usage guidance. Every word earns its place, and the description is appropriately sized for a simple read-only tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with 0 parameters, comprehensive annotations, and no output schema, the description provides excellent context about what configuration elements are retrieved and when to use it. The only minor gap is that without an output schema, the description doesn't detail the exact structure of returned data, but this is reasonable given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, and instead focuses on what configuration elements are returned, which adds semantic value for understanding the tool's output.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get'), resource ('RAS farm configuration settings'), and scope ('including farm name, domain, backup settings, and global options'). It distinguishes this tool from siblings by focusing on overall farm setup rather than specific components like administrators, licensing, or performance.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides three concrete use cases: 'review the overall farm setup, verify domain configuration, or check backup scheduling.' This gives clear guidance on when to use this tool versus the many sibling tools that target specific subsystems or components.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide strong behavioral hints (read-only, open-world, idempotent, non-destructive). The description adds valuable context about what specific configuration is retrieved (SMTP settings for email notifications) and the troubleshooting use case, which helps the agent understand the tool's practical application beyond the basic safety profile indicated by annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of two well-structured sentences: the first explains what the tool does, and the second provides usage guidance. Every word contributes meaning without redundancy, making it efficient and front-loaded with essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only configuration retrieval tool with comprehensive annotations and no parameters, the description provides adequate context about what is retrieved and when to use it. The main gap is the lack of output schema, but the description compensates by specifying the type of configuration data returned (SMTP settings). Given the tool's simplicity and strong annotation coverage, this is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters (schema coverage 100%), so there are no parameters to document. The description appropriately focuses on what the tool returns rather than input parameters, which aligns with the zero-parameter design. A baseline of 4 is appropriate since there are no parameters to explain.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get'), resource ('SMTP mailbox configuration'), and scope ('used for RAS email notifications'), including what information is retrieved ('server address, port, and sender details'). It distinguishes this from sibling tools by focusing specifically on email notification settings rather than other configuration aspects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides two concrete use cases: 'verify email notification settings' and 'troubleshoot notification delivery failures.' This gives clear guidance on when this tool should be used versus other configuration retrieval tools in the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, open-world, idempotent, and non-destructive behavior, so the description doesn't need to repeat these. However, it adds context by specifying the inventory includes details like expiration dates and usage, which helps the agent understand the scope and potential use cases, though it doesn't mention rate limits or auth needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by specific use cases. Every sentence adds value without redundancy, making it efficient and easy to parse for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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) and rich annotations, the description is complete enough for a list operation. It explains what data is returned and usage scenarios, though it doesn't detail output format or pagination, which could be minor gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't discuss parameters, which is appropriate, but it could have noted the lack of parameters for clarity. Baseline is 3, but the tool's simplicity and full schema coverage justify a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('List') and resource ('certificate inventory for the RAS farm'), including details like certificate names, expiration dates, issuers, and usage. It distinguishes from sibling tools by focusing on certificates, unlike other tools that handle administrators, licensing, performance, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides usage scenarios: 'audit SSL/TLS certificates, check for upcoming expirations, or verify certificate assignments.' This gives clear guidance on when to use this tool, such as for monitoring or compliance purposes, without needing to reference alternatives since it's a specialized list operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, open-world, idempotent, and non-destructive behavior. The description adds valuable context about what the tool retrieves (status, priority, configuration) and its purpose for health checks and diagnostics, without contradicting annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: the first defines the tool's purpose, the second provides usage guidelines. Each sentence is information-dense with zero waste, and the structure is front-loaded with core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with no parameters and comprehensive annotations, the description is complete in explaining what it does and when to use it. The lack of output schema is a minor gap, but the description compensates by detailing the retrieved information (status, priority, configuration).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema coverage, the baseline is 4. The description appropriately explains that no inputs are needed, as it retrieves general broker information, adding semantic clarity beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get connection broker status, priority, and configuration') and resource ('connection brokers'), distinguishing it from siblings by focusing on session brokering and load distribution rather than administrators, certificates, or other infrastructure components.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly provides three use cases: 'check broker health, verify primary/secondary priority, or diagnose session routing issues,' giving clear guidance on when to use this tool versus alternatives like performance monitoring or session listing tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true. The description adds valuable context about what the tool actually checks (enrollment server health) and its troubleshooting purpose for certificate enrollment failures, which goes beyond the basic safety profile indicated by annotations. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences: the first establishes purpose and context, the second provides explicit usage guidelines. Every word serves a purpose with zero redundancy or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read-only tool with comprehensive annotations, the description provides excellent purpose clarity and usage guidelines. The only minor gap is the lack of information about return format (no output schema exists), but given the tool's simplicity and the annotations' coverage, this is acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, focusing instead on the tool's purpose and usage context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get enrollment server status') and resource ('enrollment servers'), with additional context about their role in SCEP certificate enrollment for device management. It distinguishes from sibling tools by focusing specifically on enrollment servers rather than other infrastructure components like agents, certificates, or connection brokers.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: 'Use this to check enrollment server health or troubleshoot certificate enrollment failures.' This provides clear context for usage and distinguishes it from other monitoring tools that might check different components of the infrastructure.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering the core safety profile. The description adds valuable context about what information is returned ('connection state, IP addresses, and tunnel mode') and explains that gateways 'provide external user access to published resources,' which helps the agent understand the tool's domain. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences that efficiently convey purpose, details returned, and usage guidelines. Every sentence adds value: the first explains what the tool does and what information it provides, the second explains when to use it. No wasted words or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with no parameters and comprehensive annotations, the description provides excellent context about what information is returned and when to use it. The only minor gap is the lack of an output schema, but the description compensates by listing specific data points returned. This is nearly complete for this type of tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on what the tool returns rather than inputs. A baseline of 4 is applied for tools with zero parameters, as no parameter semantics are required.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get the status'), the resource ('RAS Secure Client Gateways'), and specific details included ('connection state, IP addresses, and tunnel mode'). It distinguishes from sibling tools by focusing specifically on gateway status rather than other infrastructure components like agents, certificates, or connection brokers.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: 'Use this to monitor gateway health or troubleshoot external connectivity issues.' It provides clear context about the tool's purpose (monitoring/troubleshooting) and distinguishes it from other tools that might handle configuration, administration, or other aspects of the RAS infrastructure.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true. The description adds valuable context about what information is returned (device health, IP addresses, operational state) and the tool's purpose for monitoring and diagnostics. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste. The first sentence states purpose and return values, the second provides usage guidance. Every word earns its place and the information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 0-parameter read-only tool with comprehensive annotations, the description provides excellent context about what information is returned and when to use it. The only minor gap is that without an output schema, the exact structure of the returned data isn't specified, but the description gives a good conceptual overview.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, and instead focuses on what the tool returns and when to use it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get the status'), target resource ('HALB devices in the farm'), and scope ('device health, IP addresses, and operational state'). It distinguishes from sibling tools like 'ras_infra_get_gateway_status' by focusing specifically on load balancer devices rather than gateways.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides when-to-use guidance: 'Use this to monitor load balancer availability or diagnose gateway connectivity issues.' This gives clear context for when this tool is appropriate versus other monitoring or diagnostic tools in the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a read-only, non-destructive, idempotent operation with open-world data. The description adds valuable context by specifying the return data structure (provider names, metadata URLs, configuration details) and use cases (audit, troubleshooting), which goes beyond annotations. No contradictions exist with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences: the first states the purpose and return data, the second provides usage guidelines. Every word adds value, with no redundancy or fluff, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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, read-only operation with annotations), the description is nearly complete. It covers purpose, usage, and output details. The only minor gap is lack of explicit mention about pagination or result limits, but this is reasonable for a list tool with open-world hint. With no output schema, the description adequately compensates.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on output semantics, mentioning what data is returned. This exceeds the baseline of 3 for high schema coverage by providing useful context about the tool's output.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('List SAML identity providers') and resources ('configured for single sign-on'), distinguishing it from sibling tools like 'ras_infra_get_providers' by specifying SAML IDPs for SSO. It explicitly mentions what information is returned (provider names, metadata URLs, configuration details), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: 'to audit SSO configuration or troubleshoot SAML authentication issues.' This directly informs the agent about appropriate contexts, helping it choose this tool over alternatives like general 'get_providers' or other infrastructure tools for specific SSO-related tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a read-only, non-destructive, idempotent operation with open-world data. The description adds valuable context by specifying what information is included in the listing ('pool members, provisioning settings, and capacity'), which helps the agent understand the output scope beyond the basic 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences: the first states what the tool does and what it includes, the second provides specific use cases. Every word adds value, with no repetition or fluff, making it efficiently front-loaded and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with 0 parameters and comprehensive annotations, the description is nearly complete. It explains the output content and use cases well. A slight deduction because there's no output schema, and the description doesn't mention format or pagination, but this is minor given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on the tool's purpose and output, not parameters, earning a high baseline score for compensating with semantic clarity about what data is retrieved.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List'), the resource ('VDI host pool configuration'), and specific components ('pool members, provisioning settings, and capacity'). It distinguishes from sibling tools like 'ras_infra_get_rds_hostpools' by specifying VDI rather than RDS pools, making the purpose specific and differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: 'to review VDI pool composition, check desktop provisioning status, or verify pool sizing.' It provides clear use cases without needing to mention alternatives, as the tool's scope is well-defined and distinct from siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds valuable context beyond annotations by specifying the tool's diagnostic purpose ('verify publishing is functioning or diagnose why resources are unavailable') and hinting at return content ('pending changes'), which isn't captured in annotations. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured with two sentences: the first states the purpose and return values, and the second provides explicit usage guidelines. Every sentence adds 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.
Completeness4/5
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), rich annotations, and clear purpose, the description is nearly complete. It covers purpose, usage, and behavioral context effectively. A slight deduction because it doesn't detail the exact format of return values (e.g., structure of 'pending changes'), but this is minor given the annotations and diagnostic nature.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose and usage. A baseline of 4 is applied for zero-parameter tools when the description adds value elsewhere.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('Get the overall publishing service status and health') and distinguishes it from sibling tools by focusing on publishing service status rather than specific published items (like ras_pub_get_all_items, ras_pub_get_desktops, etc.). It explicitly mentions what it returns ('whether the publishing agent is operational and any pending changes').
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: 'Use this to verify publishing is functioning or diagnose why resources are unavailable.' This clearly indicates the diagnostic/verification context and distinguishes it from tools that retrieve specific published resources, helping the agent choose appropriately among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering safety and idempotency. The description adds valuable context by explaining what VDI apps are (running on dedicated virtual machines) and their distinction from RDS apps, which helps the agent understand the domain context beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each serve a clear purpose: the first states what the tool does, and the second provides usage guidance. There is zero wasted text, and it's front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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, rich annotations covering safety and idempotency), the description is complete enough. It explains the tool's purpose, distinguishes it from alternatives, and adds domain context. The lack of an output schema is a minor gap, but for a list operation with clear annotations, this is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on purpose and usage without redundant parameter details, earning a high baseline score for not adding unnecessary information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('List') and resource ('published VDI applications'), and distinguishes it from RDS apps by explaining that VDI apps run on dedicated virtual machines rather than shared RDS hosts. This differentiation from sibling tools like ras_pub_get_rds_apps is explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: 'to review VDI-published applications or compare with RDS app assignments.' It clearly distinguishes this tool from alternatives by contrasting VDI with RDS apps, helping the agent choose appropriately among sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds valuable context by specifying it lists 'active' sessions (implying real-time or current state) and includes troubleshooting use cases, which enhances understanding beyond annotations. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences: the first states the purpose and details, the second provides usage guidelines. Every sentence adds value without redundancy, making it front-loaded and concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters, rich annotations covering safety and behavior, and no output schema, the description is largely complete. It explains what the tool does and when to use it. A minor gap is the lack of detail on output format or pagination, but this is acceptable given the annotations and context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose and usage. A baseline of 4 is applied as it compensates well for the lack of parameters by providing clear context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('List') and resource ('active remote desktop sessions across the RAS farm'), including detailed attributes like username, client IP, etc. It distinguishes itself from sibling tools by focusing specifically on active sessions rather than configuration, infrastructure, or other aspects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides usage scenarios: 'monitor active users, check session counts, troubleshoot user connectivity, or identify idle/disconnected sessions.' This gives clear guidance on when to use this tool versus alternatives, though it doesn't name specific sibling tools, the context is well-defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a read-only, non-destructive, idempotent operation with open-world data. The description adds valuable context about what configuration data is retrieved (domain settings, trust relationships, mappings) and troubleshooting applications, which helps the agent understand the tool's behavior beyond the safety profile provided by annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first states the purpose and scope, the second provides usage guidelines. Every word adds value with zero waste, and it's front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with no parameters and comprehensive annotations, the description provides sufficient context about what data is retrieved and when to use it. The lack of an output schema means return values aren't documented, but the description compensates by specifying the configuration aspects covered. Some additional detail about output format could improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose and usage. A baseline of 4 is applied since no parameters exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get') and resource ('Active Directory integration configuration') with detailed scope ('domain settings, forest trust relationships, and OU mappings'). It distinguishes this tool from siblings by focusing on AD integration rather than other site configurations like connection settings or MFA.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides three use cases: 'verify AD connectivity, check domain join status, or troubleshoot authentication issues.' This gives clear guidance on when to use this tool, though it doesn't mention alternatives or exclusions, which is acceptable given the tool's specific focus.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a read-only, non-destructive, idempotent operation with open-world data. The description adds useful context by specifying the tool's purpose for security review and troubleshooting, which complements the annotations without contradiction. However, it doesn't mention potential rate limits or authentication requirements beyond what annotations imply.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences that are front-loaded with the tool's purpose and followed by usage guidance. Every word adds value without repetition or fluff, making it highly efficient and easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters, rich annotations covering safety and behavior, and no output schema, the description provides sufficient context by explaining what settings are retrieved and when to use it. However, it doesn't describe the return format or structure, which could be helpful since there's no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose and usage. This aligns with the baseline expectation for zero-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get') and resource ('connection and authentication settings'), listing concrete examples like session timeouts and authentication methods. It distinguishes this tool from sibling tools like ras_site_get_ad_integration or ras_site_get_mfa by focusing on connection-specific settings rather than other site configurations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: 'to review security posture or troubleshoot client connection issues.' This provides clear context for its application, though it doesn't name specific alternatives among siblings. The guidance is direct and practical for agent decision-making.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds valuable context beyond annotations: it explains that the tool retrieves configuration details for troubleshooting and verification, which complements the annotations (readOnlyHint=true, destructiveHint=false) that indicate a safe, non-destructive read operation. However, it does not mention potential limitations like rate limits or authentication requirements, which could be useful for an agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by specific usage scenarios in the second. Both sentences are essential, providing clear value without redundancy or unnecessary details, making it highly efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a read-only configuration retrieval with no parameters) and rich annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint), the description is largely complete. It explains what is retrieved and when to use it, though it could briefly mention the output format or data structure since there is no output schema, leaving a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline is 4. The description appropriately does not discuss parameters, as none exist, and instead focuses on the tool's purpose and usage, which is sufficient given the empty input schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get FSLogix profile container configuration') and resource ('FSLogix profile container'), distinguishing it from sibling tools by focusing on FSLogix-specific settings rather than general site configurations like 'ras_site_get_ad_integration' or 'ras_site_get_printing'. It explicitly lists what is retrieved: VHD location paths, size limits, and redirection settings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: 'to verify profile management setup, check storage paths, or troubleshoot profile loading issues.' It clearly differentiates this tool from siblings by specifying its troubleshooting and verification purposes, which are not covered by other tools like 'ras_site_get_connection_settings' or 'ras_site_get_mfa'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true. The description adds useful context about what information is retrieved (settings for diagnosis) without contradicting annotations, though it doesn't mention rate limits or authentication needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste: first states purpose and scope, second provides usage guidelines. Every word earns its place, and information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with rich annotations and no parameters, the description is complete enough. It explains what's retrieved and when to use it, though without an output schema, it doesn't detail return format (e.g., JSON structure).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema coverage, the baseline is 4. The description appropriately doesn't discuss parameters but adds value by explaining what settings are retrieved (balancing method, resource weights, session limits).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get load balancing settings') and resource ('RDS hosts'), distinguishing it from siblings like ras_site_get_ad_integration or ras_site_get_printing. It specifies the scope includes balancing method, resource weights, and session limits.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool: 'to review how sessions are distributed across RDS hosts or diagnose uneven load distribution.' This provides clear context and distinguishes it from general performance or configuration tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true. The description adds valuable context about the tool's purpose for troubleshooting and review, which complements the annotations without contradicting them. However, it doesn't mention rate limits, authentication needs, or specific behavioral traits beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences that are front-loaded with the core purpose followed by usage guidance. Every word earns its place with zero waste or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with no parameters and comprehensive annotations, the description provides complete context about what it retrieves and when to use it. The only minor gap is lack of output format details, but with no output schema, this would be helpful for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline is 4. The description appropriately doesn't discuss parameters since none exist, focusing instead on what the tool retrieves (printing settings).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get printing configuration settings') and resource ('printing configuration'), with detailed scope including 'printer redirection, universal printing options, and driver policies'. It distinguishes from siblings by focusing on printing settings rather than other site configurations like ad_integration or connection_settings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly provides when-to-use guidance: 'Use this to troubleshoot print redirection issues or review printing policy configuration.' This gives clear context for when this tool should be selected over alternatives, though it doesn't explicitly name sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare this as read-only, non-destructive, idempotent, and open-world, which covers the core safety profile. The description adds valuable context about what the tool actually does - checking connectivity and join status for multi-tenant deployments - which goes beyond the annotations. It doesn't mention rate limits or authentication requirements, but with comprehensive annotations, the bar is lower.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each earn their place. The first sentence states the purpose, the second provides usage guidance. There's zero wasted language, and the information is front-loaded with the core functionality stated immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only status checking tool with comprehensive annotations, the description provides sufficient context. It explains what the tool does and when to use it. The lack of output schema means the description doesn't detail return values, but for a simple status check tool, this is acceptable. It could potentially mention what format the status information comes in, but it's reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, so there's no need for parameter documentation. The description appropriately focuses on the tool's purpose and usage rather than parameter details. With 100% schema description coverage (though empty), the baseline would be 3, but for zero-parameter tools, a higher score is warranted.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('get', 'verify', 'check') and resources ('tenant broker status and join information', 'tenant broker connectivity', 'join status for managed sites'). It distinguishes itself from sibling tools by focusing specifically on tenant broker functionality, unlike other ras_site_get_* tools that handle different aspects like AD integration, connection settings, or printing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides when-to-use guidance: 'Use this to verify tenant broker connectivity or check join status for managed sites.' This gives clear scenarios for tool invocation and distinguishes it from other monitoring tools in the sibling list that focus on different infrastructure components.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds valuable context about what information is retrieved (support contact details, entitlement status) that isn't captured in annotations, though it doesn't mention potential rate limits or authentication requirements. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences that are front-loaded with the core purpose and followed by specific usage examples. Every word adds value without redundancy, making it efficient and easy to parse for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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) and rich annotations covering safety and behavior, the description provides complete context for usage. It explains what information is retrieved and when to use it, though it doesn't detail the exact return format (e.g., JSON structure), which would be helpful but isn't critical with annotations present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description appropriately doesn't discuss parameters, maintaining focus on the tool's purpose. A baseline of 4 is applied since no parameters exist, and the description doesn't attempt to explain non-existent inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get') and resource ('Parallels RAS support information'), listing concrete data points like contact details, version, build number, and support entitlement. It distinguishes this tool from siblings (e.g., ras_farm_get_version) by focusing on support-specific information rather than general farm version details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides three use cases: 'check the installed RAS version', 'verify support status', and 'gather information for a support ticket'. This gives clear guidance on when to use this tool, differentiating it from alternatives like ras_farm_get_version which might only provide version data without support context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true. The description adds useful context about what information is returned (API version and build number) and the practical use cases (compatibility verification, feature availability checking), which goes beyond the annotations. No contradictions exist.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences that are front-loaded with the core purpose, followed by specific usage guidance. Every sentence adds value without redundancy, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with 0 parameters, comprehensive annotations, and clear purpose, the description provides complete context. It explains what the tool does, when to use it, and what information it returns, which is sufficient given the tool's low complexity and lack of output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose and usage. A baseline of 4 is appropriate for a zero-parameter tool where the schema fully covers the input structure.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get'), resource ('RAS web service (REST API) version information'), and outcome ('Returns the current API version and build number'). It distinguishes itself from sibling tools by focusing on API version retrieval rather than administrators, config, licensing, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: 'Use this to verify the API version is compatible or check which features are available.' This provides clear guidance on its purpose versus alternatives like checking system status or configuration details offered by other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true. The description adds value by specifying the scope ('configured in the RAS farm') and listing concrete provider types, which helps the agent understand what data to expect. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste: the first states purpose and scope with examples, the second provides usage guidelines. Every word adds value, and it's front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read-only tool with comprehensive annotations, the description is complete. It explains what the tool does, when to use it, and what data to expect (provider types), addressing all necessary context without needing output schema details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on output semantics by listing provider types, which compensates for the lack of output schema. Baseline is 4 for zero-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all cloud and hypervisor providers configured in the RAS farm'), with specific examples (AVD, AWS EC2, Azure, Hyper-V, Nutanix, vCenter, VMware ESXi). It distinguishes from siblings by focusing on providers rather than administrators, config, licensing, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: 'to verify provider connectivity, check provider types, or audit multi-cloud config.' It provides clear use cases without needing to mention alternatives, as the zero-parameter nature and provider focus naturally differentiate it from sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![ParallelsRAS_MCP MCP server](https://glama.ai/mcp/servers/RMITBLOG/ParallelsRAS_MCP/badges/card.svg)](https://glama.ai/mcp/servers/RMITBLOG/ParallelsRAS_MCP)

Score Badge

Copy to your README.md:

[![ParallelsRAS_MCP MCP server](https://glama.ai/mcp/servers/RMITBLOG/ParallelsRAS_MCP/badges/score.svg)](https://glama.ai/mcp/servers/RMITBLOG/ParallelsRAS_MCP)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/RMITBLOG/ParallelsRAS_MCP'

If you have feedback or need assistance with the MCP directory API, please join our Discord server