Railway MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Tools are well-differentiated with clear purposes, though some overlap exists (e.g., deployment_trigger vs service_restart, variable_set vs variable_bulk_set). Descriptions include 'Best for' and 'Not for' sections that effectively clarify boundaries, preventing most confusion.
Naming Consistency5/5
All tools follow a consistent snake_case verb_noun pattern (e.g., project_list, service_create_from_repo, variable_delete). The naming is highly predictable and readable across all 38 tools, with no deviations in style.
Tool Count2/5
With 38 tools, the count is excessive for a Railway server, making it overwhelming for agents to navigate. While the domain is broad (projects, services, deployments, variables, domains, volumes, templates, databases), many tools could be consolidated or omitted without losing functionality.
Completeness5/5
The tool set provides comprehensive coverage of Railway's domain, including full CRUD operations for projects, services, deployments, variables, domains, volumes, and templates. There are no obvious gaps, and tools support complete workflows from setup to management.
Average 4.2/5 across 38 of 38 tools scored. Lowest: 2.9/5.
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 is passing
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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states it's an update operation. It lacks critical behavioral details: whether this requires specific permissions, if changes are reversible, potential side effects, or error conditions. 'Update' implies mutation, but no further context is given.
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 a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/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 mutation operation with no annotations and no output schema), the description is insufficient. It doesn't explain what happens on success/failure, return values, or behavioral nuances, leaving significant gaps for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents both parameters (volumeId and name). The description adds no additional meaning beyond the schema's parameter descriptions, such as format examples or constraints, but doesn't contradict them either.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Update') and resource ('a volume's properties'), making the purpose evident. However, it doesn't differentiate from sibling tools like 'volume_create' or 'volume_delete' beyond the verb, nor does it specify what 'properties' means beyond the schema's 'name' parameter.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing volume), exclusions, or comparisons to siblings like 'volume_create' for new volumes or 'volume_list' for viewing properties.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states it's a list operation, implying read-only behavior, but doesn't specify whether it returns paginated results, error conditions, or any side effects. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and wastes no space, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/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 (single parameter, list operation) and high schema coverage, the description is minimally adequate. However, with no annotations and no output schema, it fails to address behavioral aspects like return format or error handling, which could be important for an agent's decision-making.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with the single parameter 'projectId' fully documented in the schema. The description adds no additional meaning beyond implying the parameter is required to scope the listing, which is already clear from the schema. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List all') and resource ('environments in a project'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'project_list' or 'domain_list' which also list resources, missing the opportunity to clarify its specific scope within the project context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid project ID), exclusions, or how it relates to siblings like 'project_info' or 'deployment_list', leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool is for getting status (implying a read operation) but doesn't mention any behavioral traits like whether it requires authentication, has rate limits, returns real-time or cached data, or what happens if the workflow ID is invalid. The description adds minimal context beyond the basic purpose.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, starting with the core purpose. The use of emojis and bullet points ('⚡️ Best for:', '⚠️ Not for:', '→ Next steps:', '→ Related:') adds structure without unnecessary verbosity. However, the inclusion of 'Next steps: service_info' might be slightly extraneous as it doesn't directly relate to usage guidelines.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/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 (1 parameter, no output schema, no annotations), the description is somewhat complete but has gaps. It covers purpose and basic usage guidelines but lacks behavioral details like error handling or response format. Without annotations or an output schema, the agent might struggle with understanding the full context of the tool's operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'workflowId' parameter fully documented as 'ID of the workflow to get the status of.' The description doesn't add any additional meaning or context about the parameter beyond what the schema provides, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/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: 'Get the status of a workflow' with a specific verb ('Get') and resource ('workflow status'). It distinguishes from some siblings like 'template_deploy' or 'service_create_from_image' by focusing on status retrieval rather than creation or deployment. However, it doesn't explicitly differentiate from 'deployment_status' which might be a similar sibling tool.
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 guidance with 'Best for: Checking workflow status' and 'Not for: Creating new services,' which helps the agent understand appropriate use cases. It also mentions 'Next steps: service_info' and 'Related: template_list, template_deploy' to suggest alternatives and context. However, it doesn't clarify when to use this versus 'deployment_status' or other status-related siblings.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It correctly identifies this as a destructive operation ('Delete'), which is appropriate. However, it doesn't mention important behavioral aspects like whether deletion is permanent/irreversible, what happens to associated resources, authentication requirements, or error conditions. The description adds some context about use cases but misses key operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely well-structured and concise, using bullet points, icons, and clear sections that make information easy to scan. Every sentence earns its place by providing specific guidance without redundancy. The information is front-loaded with the core purpose, followed by usage guidelines and related context.
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 single-parameter destructive operation with no annotations and no output schema, the description provides good contextual completeness. It covers purpose, usage scenarios, exclusions, prerequisites, and related tools. The main gap is the lack of information about the deletion consequences (permanence, side effects) and what the tool returns, but given the schema covers the parameter well and the description provides strong usage guidance, it's reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with the single parameter 'proxyId' well-documented in the schema. The description doesn't add any additional parameter information beyond what's already in the schema. According to the scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description, which applies here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and resource ('a TCP proxy'), making the purpose immediately understandable. It distinguishes from sibling tools like tcp_proxy_create and tcp_proxy_list by focusing on removal rather than creation or listing. However, it doesn't explicitly differentiate from other deletion tools like service_delete or volume_delete beyond the resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides excellent usage guidance with explicit 'Best for' and 'Not for' sections, clearly indicating when to use this tool (removing unused proxies, security management, endpoint cleanup) and when not to use it (temporary proxy disabling, port updates). It also mentions prerequisites (tcp_proxy_list) and related tools (service_update), offering comprehensive context for decision-making.
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?
No annotations are provided, so the description carries the full burden. It implies a read-only operation ('Check', 'Monitoring', 'Verifying') but doesn't explicitly state whether this requires authentication, has rate limits, or what the response format looks like. The description adds some behavioral context (e.g., it's for status checking, not logs), but lacks details on error handling, permissions, or output structure, leaving gaps for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, followed by organized sections (Best for, Not for, Prerequisites, etc.). It's appropriately sized for the tool's complexity, with each sentence adding value (e.g., distinguishing from logs, guiding usage). Minor points are deducted for some redundancy (e.g., 'Check' in the first line and 'Monitoring' in Best for), but overall it's efficient and clear.
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 moderate complexity (1 parameter, no output schema, no annotations), the description is mostly complete. It covers purpose, usage guidelines, and relationships with other tools. However, it lacks details on behavioral aspects like authentication needs or response format, which would be helpful since no annotations or output schema are provided. This gap prevents a perfect score, but it's sufficient for basic use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'deploymentId' documented as 'ID of the deployment to check status for'. The description doesn't add any additional parameter semantics beyond what the schema provides, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't need to given the schema's completeness.
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 ('Check') and resource ('status of a deployment'), distinguishing it from siblings like deployment_list (which lists deployments) and deployment_logs (which provides logs). The title-like first line '[API] Check the current status of a deployment' directly communicates the core function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance with 'Best for' and 'Not for' sections, naming specific use cases (monitoring progress, verifying success, checking failures) and exclusions (service runtime logs, database logs). It also lists prerequisites (deployment_list, deployment_trigger), next steps (deployment_logs), and related tools (service_info, service_restart, deployment_wait), offering comprehensive context for when to use this tool versus alternatives.
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?
No annotations are provided, so the description carries the full burden. It mentions 'Create' implying a write operation but lacks details on permissions, rate limits, or error handling. The 'Next steps' and 'Related' sections add some behavioral context (e.g., follow-up actions), but critical aspects like mutation effects or response format are missing, leaving gaps for a tool with no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with sections like 'Best for', 'Not for', and bullet points for prerequisites and alternatives, making it easy to scan. It is front-loaded with the core purpose. However, some sections (e.g., 'Next steps', 'Related') could be trimmed as they are less critical, slightly reducing efficiency.
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 no annotations and no output schema, the description does well by covering usage guidelines and distinguishing from siblings. It lacks details on behavioral traits (e.g., what 'Create' entails operationally) and output, but the structured sections compensate somewhat. For a mutation tool with 3 parameters, it is mostly complete but could improve on transparency.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters (projectId, image, name). The description does not add any parameter-specific details beyond what the schema provides, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate as the description adds no extra semantic value for parameters.
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 creates a new service from a Docker image, using specific verbs ('Create') and resources ('service', 'Docker image'). It distinguishes from siblings like service_create_from_repo and database_deploy by explicitly naming them in the 'Not for' section, 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 provides explicit guidance with 'Best for' and 'Not for' sections, listing specific use cases (e.g., custom database deployments) and exclusions (e.g., not for standard database deployments). It names alternatives (database_deploy, service_create_from_repo) and prerequisites (project_list), offering comprehensive usage context.
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?
No annotations are provided, so the description carries the full burden. It discloses that the tool is for authentication configuration and mentions it's 'only needed if not set in environment variables', adding useful context about prerequisites. However, it lacks details on behavioral traits like whether this is a one-time setup, if it persists across sessions, error handling, or rate limits, leaving gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized, using bullet points (✓ and ×) and arrows (→) for clarity. It is front-loaded with the core purpose, followed by best uses, exclusions, and related tools, with every sentence adding value and no wasted words.
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 (single parameter, no output schema, no annotations), the description is mostly complete. It covers purpose, usage, and exclusions well. However, as a mutation tool with no annotations, it could benefit from more behavioral details (e.g., side effects, error cases), slightly reducing completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the schema fully documenting the single 'token' parameter. The description does not add any parameter-specific semantics beyond what's in the schema (e.g., no extra details on token format or validation). According to the rules, with high schema coverage, the baseline is 3 even without param info in the description.
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: 'Configure the Railway API token for authentication' with the specific verb 'configure' and resource 'API token'. It distinguishes from siblings by explicitly stating what it's not for (project configuration, service settings, environment variables), making it distinct from tools like project_create, service_list, or variable_set.
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 it ('Initial setup', 'Token updates', 'Authentication configuration') and when not to use it ('Not for: Project configuration, Service settings, Environment variables'). It also suggests next steps (project_list, service_list) and related tools (project_create), offering clear alternatives and context.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation through 'List' and 'Viewing deployment history', but doesn't explicitly state whether it requires authentication, has rate limits, or what format the output takes. It adds some context about 'recent' deployments and the default limit, but lacks comprehensive behavioral details.
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 with clear sections (purpose, best for, prerequisites, next steps, related tools) using bullet points and symbols. Every sentence earns its place by providing distinct value without repetition or fluff. The information is front-loaded with the core purpose 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 list tool with 4 parameters and 100% schema coverage but no output schema, the description provides good contextual completeness. It covers purpose, usage scenarios, prerequisites, and related tools. The main gap is the lack of output format description, which would 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.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 4 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema, such as explaining how environmentId relates to service_list or providing examples of valid IDs. It meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 recent deployments') with the target resource ('for a service in a specific environment'). It distinguishes itself from sibling tools like deployment_logs (which shows logs) and deployment_trigger (which initiates deployments), establishing a unique read-only history function.
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 with 'Best for' scenarios (viewing deployment history, monitoring service updates), prerequisites (service_list), next steps (deployment_logs, deployment_trigger), and related tools (service_info, service_restart). This gives clear context for when to use this tool versus alternatives.
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?
No annotations are provided, so the description carries the full burden. It implies a read-only operation ('Get logs') but doesn't explicitly state permissions, rate limits, or pagination behavior. It adds some context about log types (not for service/database logs) but lacks details on output format or error handling.
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 well-structured with bullet points and icons, front-loading the core purpose. Every sentence adds value: the main action, usage scenarios, exclusions, and related tools. 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 no annotations and no output schema, the description does well by covering purpose, usage, and exclusions. However, it lacks details on behavioral aspects like permissions or output format, which would be helpful for a tool with no structured output. It's mostly complete but has minor gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters (deploymentId and limit). The description doesn't add any parameter-specific details beyond what's in the schema, such as format examples or constraints. Baseline 3 is appropriate when schema coverage is high.
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 logs') and resource ('for a specific deployment'), distinguishing it from siblings like deployment_status (status vs. logs) and service_info (service vs. deployment). It specifies the exact scope of logs (deployment-related) rather than being generic.
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 provides explicit guidance with 'Best for' (debugging, monitoring, checking build output) and 'Not for' (service runtime logs, database logs), plus prerequisites (deployment_list), next steps (deployment_status), and related tools (service_info, deployment_trigger). This clearly defines when to use this tool versus alternatives.
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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool checks domain availability, implying a read-only operation, but does not disclose details like rate limits, authentication needs, error handling, or what 'available for use' entails (e.g., registration status). The description adds basic context but lacks depth for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, followed by bullet points for usage guidelines and related tools. Every sentence earns its place by providing actionable information 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 low complexity (1 parameter, no output schema, no annotations), the description is complete enough for basic use. It covers purpose, usage scenarios, and next steps, but lacks details on behavioral aspects like response format or error conditions. For a simple read operation, this is largely sufficient, though minor gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'domain' parameter documented as 'Domain name to check availability for.' The description does not add any parameter-specific information beyond what the schema provides, such as format examples or constraints. Given the high schema coverage, a baseline score of 3 is appropriate as the schema handles the parameter documentation adequately.
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 explicitly states the tool's purpose as 'Check if a domain is available for use,' which is a specific verb ('Check') and resource ('domain') combination. It clearly distinguishes this tool from its siblings like domain_create, domain_list, domain_update, and domain_delete by focusing solely on availability checking rather than creation, listing, updating, or deletion.
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 usage guidelines with a 'Best for' section listing specific scenarios (validating domain availability, pre-deployment checks, domain planning) and includes 'Next steps: domain_create' and 'Related: domain_list' to guide the agent on when to use this tool versus alternatives. This offers clear context and direction for tool selection.
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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the tool as a list operation, implying it's read-only and non-destructive, which is helpful. However, it lacks details on behavioral traits like pagination, rate limits, authentication needs, or error handling. The description adds some context (e.g., it lists 'both service and custom' domains) but doesn't fully compensate for the absence of annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized, using bullet points and icons for clarity. It front-loads the core purpose in the first sentence, followed by organized sections (Best for, Prerequisites, Next steps, Related) that add value without redundancy. Every sentence earns its place by providing actionable guidance, making it efficient and easy to scan.
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 moderate complexity (3 required parameters, no output schema, no annotations), the description is largely complete. It covers purpose, usage guidelines, and context well. However, it lacks details on output format or behavioral aspects like error handling, which would be beneficial since there's no output schema. The description compensates somewhat with rich contextual guidance but has minor gaps in behavioral transparency.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all three parameters (projectId, environmentId, serviceId) documented in the schema. The description doesn't add any parameter-specific information beyond what the schema provides, such as explaining relationships between parameters or usage examples. Given the high schema coverage, the baseline score of 3 is appropriate, as the description doesn't enhance parameter understanding but relies on the 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 tool's purpose: 'List all domains (both service and custom) for a service.' It specifies the verb ('List'), resource ('domains'), and scope ('for a service'), distinguishing it from sibling tools like domain_check, domain_create, or domain_update. The mention of 'both service and custom' adds specificity about what types of domains are included.
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 usage guidance with dedicated sections: 'Best for' lists three specific use cases (viewing endpoints, managing configurations, auditing settings), 'Prerequisites' names service_list as a required step, 'Next steps' suggests domain_create and domain_update as follow-ups, and 'Related' mentions service_info and tcp_proxy_list as alternatives. This comprehensively addresses when and how to use the tool versus other options.
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?
No annotations are provided, so the description carries the full burden. It mentions the tool lists 'all services' and implies it's a read operation, but doesn't disclose behavioral traits like pagination, rate limits, error handling, or authentication needs. The description adds some context (e.g., it's for listing) but lacks depth on operational 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 well-structured and front-loaded with the core purpose, followed by bullet points for usage, prerequisites, and related tools. Every sentence earns its place, with no wasted words, making it efficient and easy to scan.
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 (1 parameter, no output schema, no annotations), the description is fairly complete for a list operation. It covers purpose, usage, and workflow context. However, it lacks details on output format or behavioral aspects, which slightly limits completeness for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents the single parameter (projectId). The description adds no additional meaning beyond what's in the schema, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate.
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 ('services in a specific Railway project'), distinguishing it from siblings like service_info (detailed info) or service_create (creation). It explicitly mentions what it returns: an overview, service IDs, and status.
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 with 'Best for' scenarios (overview, finding IDs, checking status), prerequisites (project_list), next steps (service_info, deployment_list), and related tools (project_info, variable_list). This clearly indicates when to use it versus alternatives.
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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies mutation ('Update'), but doesn't specify permissions required, whether changes are reversible, or potential side effects (e.g., downtime). However, it adds some context by listing prerequisites and related tools, which helps infer workflow dependencies. Without annotations, more behavioral details (e.g., rate limits, auth needs) would improve transparency.
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 well-structured and front-loaded with the core purpose, followed by clear sections (Best for, Not for, Prerequisites, Next steps, Related). Every sentence earns its place by providing actionable guidance without redundancy. It uses bullet points and symbols (✓, ×, →) for readability, making it efficient and easy to scan.
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 (10 parameters, mutation operation) and lack of annotations/output schema, the description does a good job of contextual completeness by covering usage guidelines, exclusions, prerequisites, and related tools. However, it could be more complete by including details on behavioral traits (e.g., what 'Update' entails operationally) or output expectations, which are missing despite no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 10 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., no extra syntax or format details). According to the rules, with high schema coverage (>80%), the baseline is 3 even with no param info in the description, which applies here.
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 ('Update a service's configuration') and distinguishes it from sibling tools by listing what it's 'Not for' (e.g., not for updating environment variables, restarting services, or triggering deployments). It explicitly names alternative tools like variable_set, service_restart, and deployment_trigger, making its scope 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 ('Best for: Changing service settings, Updating resource limits, Modifying deployment configuration') and when not to use it ('Not for: Updating environment variables, Restarting services, Triggering new deployments'), with named alternatives for each exclusion. It also lists prerequisites (service_list, service_info) and next steps (deployment_trigger), offering comprehensive usage context.
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?
No annotations are provided, so the description carries the full burden. It implies a read-only operation (listing proxies) and hints at configuration management, but does not disclose behavioral traits like pagination, rate limits, authentication needs, or error handling. The description adds some context (e.g., for auditing) but lacks detailed behavioral transparency.
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 well-structured and front-loaded: the first sentence states the core purpose, followed by bullet-point sections (Best for, Prerequisites, Next steps, Related) that efficiently provide additional context without redundancy. Every sentence earns its place, making it concise and easy to scan.
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 moderate complexity (2 required parameters, no output schema, no annotations), the description is mostly complete. It covers purpose, usage guidelines, and related tools, but lacks details on behavioral aspects (e.g., output format, error cases) and does not fully compensate for the absence of annotations. It is adequate but has minor gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema already documents both parameters (environmentId and serviceId) with descriptions. The description does not add any parameter-specific semantics beyond what the schema provides, such as format examples or constraints. Baseline 3 is appropriate when schema coverage is high.
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: 'List all TCP proxies for a service in a specific environment.' It specifies the verb ('List'), resource ('TCP proxies'), and scope ('for a service in a specific environment'), distinguishing it from siblings like tcp_proxy_create (which creates proxies) and domain_list (which lists domains).
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 usage guidance with sections: 'Best for' lists use cases (viewing configurations, managing access, auditing endpoints), 'Prerequisites' specifies service_list as a required step, 'Next steps' suggests tcp_proxy_create, and 'Related' mentions domain_list and service_info as alternatives. This clearly indicates when to use this tool versus others.
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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that the volume is 'persistent' and for a 'service', which adds some context about the tool's behavior. However, it lacks details on permissions, error handling, or what the tool returns, leaving gaps in behavioral transparency for a creation tool with no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, followed by bullet-pointed sections for best uses, exclusions, prerequisites, next steps, and related tools. Each sentence or bullet point adds value without redundancy, making it efficient and easy to scan.
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 as a creation operation with no annotations and no output schema, the description provides strong usage guidelines and related tool context. However, it lacks details on behavioral aspects like return values or error conditions, which slightly reduces completeness. The high schema coverage and clear structure compensate partially, but not fully.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the input schema already documents all four parameters (projectId, environmentId, serviceId, mountPath) with descriptions. The description does not add any parameter-specific details beyond what the schema provides, such as format examples or constraints, resulting in a baseline score of 3.
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 'Create' and resource 'new persistent volume for a service', making the purpose specific and unambiguous. It distinguishes this tool from sibling tools like volume_list, volume_update, and volume_delete by focusing on creation rather than listing, updating, or deleting volumes.
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 with 'Best for' and 'Not for' sections, clearly indicating when to use this tool (e.g., for database storage, persistent data) and when not to use it (e.g., for temporary storage, static file hosting). It also lists prerequisites (service_list), next steps (volume_list), and related tools (service_update, database_deploy), offering comprehensive usage context.
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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool is for listing volumes, which implies a read-only operation, but doesn't explicitly state whether it's safe, requires specific permissions, or details about rate limits or pagination. The description adds some context with the 'Best for' section, but lacks deeper behavioral traits.
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 well-structured and appropriately sized, using bullet points and arrows for clarity. Every sentence earns its place by providing purpose, usage guidelines, prerequisites, and related tools without unnecessary fluff. It's front-loaded with the core action and efficiently organized.
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 (1 parameter, 100% schema coverage, no output schema), the description is mostly complete. It covers purpose, usage, and context well, but lacks details on behavioral aspects like permissions or output format, which would be helpful since no annotations or output schema are provided. This minor gap prevents a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'projectId' fully documented in the schema as 'ID of the project to list volumes for'. The description doesn't add any additional meaning or details about this parameter beyond what the schema provides, so it meets the baseline of 3 for high schema coverage.
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 volumes') and resource ('in a project'), distinguishing it from sibling tools like volume_create, volume_delete, and volume_update. The title 'volume_list' aligns perfectly with this purpose, making the tool's function immediately apparent.
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 ('Best for: Viewing persistent storage configurations, Managing data volumes, Auditing storage usage'), prerequisites ('Prerequisites: project_list'), next steps ('Next steps: volume_create'), and related tools ('Related: service_info, database_deploy'). This comprehensive guidance helps the agent choose this tool appropriately over alternatives.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates this is a destructive operation ('Delete', 'Security cleanup'), mentions prerequisites, and hints at side effects through 'Next steps' (suggesting deployments or restarts may be needed). However, it doesn't explicitly state permission requirements, rate limits, or whether deletion is permanent/reversible.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, best for, not for, prerequisites, next steps, related tools) and uses bullet points/emojis for readability. While slightly longer than minimal, every section adds value. The core purpose is stated upfront, making it 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 destructive tool with no annotations and no output schema, the description provides good context: clear purpose, usage guidelines, prerequisites, and related tools. It adequately covers the mutation nature and hints at side effects. The main gap is lack of explicit information about return values or error conditions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 4 parameters. The description adds minimal parameter-specific semantics beyond the schema - it mentions 'shared variable' context for the optional serviceId parameter, but doesn't provide additional format details, examples, or constraints. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete a variable'), specifies the resource ('for a service in a specific environment'), and distinguishes from siblings like 'variable_set' (create/update) and 'variable_list' (read). It provides specific context about configuration management rather than just restating the tool name.
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 includes explicit 'Best for' and 'Not for' sections with concrete use cases (removing unused configuration, security cleanup) and exclusions (temporary disabling, bulk removal). It also lists prerequisites ('service_list'), next steps ('deployment_trigger', 'service_restart'), and related tools ('variable_list', 'variable_set'), providing comprehensive guidance on when and how to use this tool.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation by focusing on listing available types, but doesn't explicitly state permissions, rate limits, or response format. The description adds context about what the tool does (list deployable types) and doesn't do (list existing databases), but lacks details on behavioral traits like error handling or output structure.
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 well-structured and front-loaded with the core purpose in the first sentence. Each subsequent section ('Best for', 'Not for', 'Alternatives', etc.) adds value without redundancy. The use of symbols (✓, ×, →) enhances readability, and all content is directly relevant to helping an agent understand and use the tool 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 the tool's simplicity (0 parameters, no annotations, no output schema), the description is largely complete. It covers purpose, usage guidelines, and related tools. However, without an output schema, it doesn't describe the return format (e.g., list structure, data fields), which is a minor gap. For a read-only list tool, this is still highly informative but not fully exhaustive.
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 inputs. The description doesn't need to add parameter information, as there are none to explain. It appropriately focuses on the tool's purpose and usage 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 tool's purpose with specific verbs ('List all available database types') and resources ('database types that can be deployed using Railway's official templates'). It distinguishes itself from siblings by specifying what it does (listing available types) versus what it doesn't do (listing existing databases or getting connection details), making it highly 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 provides explicit usage guidelines with 'Best for' and 'Not for' sections, clearly indicating when to use this tool (e.g., discovering supported types, planning deployments) and when not to use it (e.g., listing existing databases). It also names alternatives ('service_create_from_image') and suggests next steps ('database_deploy'), offering comprehensive guidance for tool selection.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates that this is a deployment-triggering action (implying a write/mutation operation) and provides context about what it's designed for (deploying code changes, applying config updates, rolling back). However, it doesn't explicitly mention potential side effects like service downtime, authentication requirements, or rate limits.
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 well-structured and efficiently organized with clear sections (purpose, best for, not for, prerequisites, alternatives, next steps, related). Every sentence earns its place by providing valuable guidance without redundancy. 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?
For a mutation tool with no annotations and no output schema, the description provides substantial context about usage scenarios, exclusions, prerequisites, and related tools. However, it doesn't describe what happens after triggering (e.g., deployment process initiation, return values, or error conditions), leaving some behavioral aspects unspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all four parameters (projectId, serviceId, environmentId, commitSha) with clear descriptions. The description doesn't add any additional parameter semantics beyond what's in the schema, making the baseline score of 3 appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 ('Trigger') and resource ('new deployment for a service'), distinguishing it from siblings like service_restart and service_update. The title line '[API] Trigger a new deployment for a service' provides immediate clarity about the core function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance with 'Best for' and 'Not for' sections, naming specific alternatives (service_restart, service_update) and exclusions (restarting services, updating service config, database changes). It also includes prerequisites (service_list) and related tools, offering comprehensive usage 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates that this is a creation/mutation tool (implied by 'Create'), mentions prerequisites that suggest authorization needs, and provides context about what gets created (custom domains, HTTPS endpoints). However, it doesn't explicitly mention rate limits or detailed error conditions.
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 well-structured with clear sections (API purpose, Best for, Not for, Prerequisites, Alternatives, Next steps, Related). Every sentence earns its place by providing distinct value, 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 creation tool with no annotations and no output schema, the description provides substantial context about usage, alternatives, and relationships. It covers the tool's purpose, when to use it, and what to expect next. The main gap is the lack of information about return values or error conditions, which would be helpful given the absence of an output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema, which is acceptable given the comprehensive schema coverage. The baseline score of 3 reflects adequate parameter documentation through the schema alone.
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 ('Create a new domain for a service') and distinguishes it from sibling tools by explicitly mentioning what it's not for (TCP proxy setup, internal service communication). It provides a verb+resource combination that is 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 with 'Best for' and 'Not for' sections, names specific alternatives (tcp_proxy_create), lists prerequisites (service_list, domain_check), and suggests next steps (domain_update). This gives comprehensive context for when to use this tool versus alternatives.
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?
With no annotations provided, the description carries the full burden. It implies a destructive action ('Delete') but doesn't specify if deletion is permanent, requires specific permissions, or has rate limits. It adds some context (e.g., not for temporary disabling) but lacks details on behavioral traits like error handling or confirmation prompts.
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 well-structured with bullet points (⚡️ Best for, ⚠️ Not for) and arrows for prerequisites/alternatives, making it front-loaded and efficient. Every sentence adds value without redundancy, fitting the tool's complexity appropriately.
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 destructive tool with no annotations and no output schema, the description does well by covering purpose, usage guidelines, and context. However, it lacks details on return values or error cases, which could be important for deletion operations. Given the tool's complexity, it's mostly complete but has 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 100% description coverage (parameter 'id' is documented), so the baseline is 3. The description adds value by implicitly clarifying that 'id' refers to a domain ID (from context like 'domain_list'), though it doesn't explicitly explain parameter semantics beyond the schema. Given the single parameter and high schema coverage, a score of 4 reflects adequate compensation.
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 ('Delete a domain from a service') with the resource ('domain'), distinguishing it from siblings like domain_update (for updates) and domain_list (for listing). It avoids tautology by not just restating the name.
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 provides explicit guidance with 'Best for' (removing unused domains, cleaning up configurations) and 'Not for' (temporary domain disabling, port updates), plus mentions prerequisites (domain_list) and alternatives (domain_update), clearly defining when to use this tool versus others.
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?
With no annotations provided, the description carries full burden and does well by indicating this is a configuration update operation (implying mutation), mentioning specific constraints (cannot change domain names, not for TCP proxy), and providing prerequisite/next step context. It doesn't mention permissions, rate limits, or error conditions, but provides solid behavioral 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 perfectly structured with clear sections (API label, Best for, Not for, Prerequisites, Next steps, Related). Every sentence earns its place, and information is front-loaded with the core purpose first. No wasted words.
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 mutation tool with no annotations and no output schema, the description does very well by providing clear purpose, usage guidelines, constraints, and contextual relationships. It could mention what the update returns or error conditions, but given the good structure and guidance, it's mostly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents both parameters. The description doesn't add any parameter-specific information beyond what's in the schema (id and targetPort are clearly documented there). Baseline 3 is appropriate when schema does the heavy lifting.
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 ('Update a domain's configuration') and distinguishes it from siblings by mentioning what it's not for (changing domain names, TCP proxy configuration). It explicitly differentiates from domain_delete/recreate and tcp_proxy_* tools.
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 excellent usage guidance with explicit 'Best for' and 'Not for' sections, naming specific alternatives (delete and recreate for domain name changes). It also includes prerequisite and next step references to domain_list, and mentions related service_update.
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?
No annotations are provided, so the description carries the full burden. It implies a read-only operation by using 'List' and 'Viewing', but does not explicitly state whether it's safe, requires authentication, or has rate limits. The description adds some context about listing shared variables if serviceId is omitted, but lacks details on output format or pagination.
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 well-structured with bullet points and icons, making it easy to scan. Every sentence serves a clear purpose—stating the action, providing usage scenarios, and linking to related tools—with no 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?
Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is largely complete. It covers purpose, usage, and parameter nuances, but could improve by addressing behavioral aspects like authentication or output format, which are missing due to the lack of annotations and 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 schema description coverage is 100%, so the schema already documents all parameters. The description adds value by clarifying that serviceId is optional and explaining the behavior when omitted (lists shared variables across all services), which enhances understanding beyond the schema's basic descriptions.
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 environment variables for a service'), making the purpose specific and unambiguous. It distinguishes itself from sibling tools like service_info or variable_bulk_set by focusing exclusively on listing variables.
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 with 'Best for' scenarios (viewing configuration, auditing, checking connection strings), prerequisites (service_list), next steps (variable_set, variable_delete), and related tools (service_info, variable_bulk_set). This comprehensively informs when and how to use this tool versus alternatives.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates that this is a creation operation (implies mutation/write), mentions what it's best for and what it's not for, and provides next steps. However, it doesn't explicitly mention permissions, rate limits, or error conditions that might be relevant for a creation tool.
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 well-structured with clear sections (purpose, best for, not for, next steps, related tools). Every sentence earns its place by providing specific guidance without unnecessary verbiage. The use of symbols (⚡️, ⚠️, →) enhances readability while maintaining conciseness.
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 creation tool with no annotations and no output schema, the description provides strong contextual guidance about when to use it, what it's not for, and next steps. However, it doesn't describe what the tool returns or potential error conditions, which would be helpful given the absence of an output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents both parameters (name and teamId). The description doesn't add any additional parameter information beyond what's in the schema, so it meets the baseline of 3 for high schema coverage without adding extra value.
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 explicitly states 'Create a new Railway project' which is a specific verb+resource action. It clearly distinguishes this from sibling tools like project_delete, project_update, and project_list by focusing on creation rather than modification or deletion operations.
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 with 'Best for' and 'Not for' sections, clearly indicating when to use this tool (starting new applications, setting up development environments) and when not to use it (duplicating existing projects). It also lists next steps and related tools, providing clear alternatives and 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates that this is a destructive operation ('Delete a Railway project and all its resources'), warns against misuse for temporary deactivation, and implies irreversible deletion. However, it lacks details on permissions, rate limits, or confirmation steps, which would be helpful for a destructive tool.
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 well-structured and front-loaded with the core action, followed by bullet-pointed best practices, warnings, prerequisites, and alternatives. Each section adds value without redundancy, and the use of symbols (⚡️, ⚠️, →) enhances readability while keeping the text efficient and focused.
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 destructive nature, no annotations, and no output schema, the description does a good job of covering key aspects: purpose, usage guidelines, and behavioral warnings. It could improve by mentioning error handling or return values, but for a single-parameter tool with clear schema coverage, it provides sufficient context for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with the single parameter 'projectId' fully documented in the schema. The description does not add any additional semantic context beyond what the schema provides (e.g., format examples or sourcing guidance), so it meets the baseline score of 3 where the schema handles parameter documentation adequately.
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 ('Delete a Railway project and all its resources') with the verb 'Delete' and resource 'Railway project', distinguishing it from siblings like service_delete which handles service-level cleanup. It explicitly mentions the scope ('all its resources'), making the purpose unambiguous and distinct.
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 ('Best for: Removing unused projects, Cleaning up test projects') and when not to use it ('Not for: Temporary project deactivation, Service-level cleanup'), with named alternatives (service_delete). It also lists prerequisites (project_list, project_info) and related tools (project_create), offering comprehensive usage context.
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?
No annotations are provided, so the description carries the full burden. It states this is a read operation ('Get detailed information'), which implies non-destructive behavior, but doesn't explicitly mention safety, permissions, rate limits, or response format. The description adds some context about prerequisites and related tools, but lacks detailed behavioral disclosure for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, followed by organized sections (Best for, Prerequisites, Next steps, Related). Every sentence earns its place by providing actionable guidance without redundancy. The use of symbols (⚡️, ✓, →) enhances readability without adding fluff.
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 moderate complexity (single parameter, read-only operation), no annotations, and no output schema, the description does a good job of covering purpose, usage, and relationships. However, it lacks details on behavioral aspects like error handling or response structure, which would be helpful for a tool with no structured output documentation. The completeness is strong but not perfect.
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 100% description coverage, so the schema fully documents the single parameter (projectId). The description doesn't add any parameter-specific information beyond what's in the schema, but with only one parameter and high schema coverage, this is acceptable. The baseline for high coverage is 3, but the description compensates by providing excellent usage context, warranting a slightly higher score.
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 detailed information') and resource ('about a specific Railway project'), distinguishing it from siblings like project_list (which lists projects) and project_update/project_delete (which modify projects). The title is null, so the description fully defines the tool's purpose.
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 with 'Best for' examples (viewing details, checking environments, configuration review), prerequisites ('project_list'), next steps ('service_list, variable_list'), and related tools ('project_update, project_delete'). This clearly indicates when to use this tool versus alternatives.
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?
No annotations are provided, so the description carries full burden. It indicates this is a read operation (list) but doesn't disclose behavioral traits like pagination, rate limits, authentication requirements, or error handling. The description adds some context about use cases but lacks operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, followed by bullet points for use cases and clear next steps. Every sentence adds value without redundancy, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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, no annotations), the description is complete enough for a list operation. It explains purpose, usage, and related tools, though it could benefit from mentioning output format or limitations (e.g., no filtering).
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 doesn't need to explain parameters, and it appropriately doesn't mention any. Baseline is 4 for zero parameters, as it avoids 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 specific verb ('List') and resource ('projects in your Railway account'). It distinguishes from siblings by specifying it lists 'all projects' rather than filtering or managing individual projects, unlike project_info, project_create, or project_delete.
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 ('Best for: Getting an overview of all projects, Finding project IDs, Project discovery and management') and suggests next steps (project_info, service_list) and related tools (project_create, project_delete), clearly differentiating from alternatives.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates that this is a creation/mutation tool (implied by 'Create'), specifies it's for GitHub repositories, and mentions build processes. However, it doesn't detail authentication needs, rate limits, or what happens on failure, leaving some behavioral aspects unclear.
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 well-structured with clear sections (API note, Best for, Not for, Prerequisites, Alternatives, Next steps, Related), using bullet points and symbols for readability. Every sentence earns its place by providing actionable guidance without 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 creation tool with no annotations and no output schema, the description does an excellent job covering usage context, alternatives, and prerequisites. However, it lacks details on return values or error handling, which would be helpful given the mutation nature and absence of output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters. The description doesn't add any additional parameter semantics beyond what's in the schema (e.g., format examples for 'repo' are in the schema). Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 ('Create a new service') and resource ('from a GitHub repository'), distinguishing it from sibling tools like service_create_from_image. It explicitly mentions deploying applications from source code and GitHub-hosted projects, providing a precise purpose.
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 includes explicit 'Best for' and 'Not for' sections with named alternatives (service_create_from_image, database_deploy), prerequisites (project_list), and related next steps (variable_set, service_update). This provides comprehensive guidance on when to use this tool versus others.
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?
With no annotations provided, the description carries full burden. It clearly indicates this is a destructive operation ('Delete'), implies permanent removal (contrasted with temporary alternatives), and mentions prerequisites that suggest authentication or access needs. However, it doesn't specify rate limits, confirmation prompts, or irreversible consequences beyond the contrast with service_restart.
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?
Well-structured with clear sections (API label, purpose, best for/not for, prerequisites, alternatives, related). Every sentence earns its place by providing distinct guidance without redundancy. The information is front-loaded with the core purpose 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 destructive tool with no annotations and no output schema, the description provides strong contextual guidance about usage scenarios, alternatives, and prerequisites. However, it doesn't describe what happens after deletion (e.g., confirmation message, error handling, or cascading effects) which would be helpful given the tool's destructive nature.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, providing clear documentation for both parameters (projectId, serviceId). The description doesn't add any parameter-specific details beyond what the schema already states, so it meets the baseline of 3 where the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 ('Delete a service from a project') with the exact resource ('service'), distinguishing it from siblings like service_restart or service_update. It goes beyond just restating the tool name by specifying the target context (project).
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 'Best for' scenarios (removing unused services, cleaning up test services, project reorganization) and 'Not for' cases (temporary stoppage, configuration updates) with named alternatives (service_restart, service_update). Also lists prerequisites (service_list, service_info) and related tools (project_delete), giving comprehensive guidance on when to use this tool.
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?
With no annotations provided, the description carries full burden. It effectively communicates this is a read-only operation ('Get detailed information'), suggests it's for monitoring/checking purposes, and implies it returns configuration/status/health data. However, it doesn't explicitly mention rate limits, authentication needs, or error behaviors.
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 with clear sections (purpose, best for, prerequisites, next steps, related tools). Every sentence earns its place, and information is front-loaded with the core purpose stated first. The bullet-point format enhances readability without unnecessary verbosity.
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 3 parameters and 100% schema coverage, the description is quite complete. It provides purpose, usage context, and workflow relationships. The main gap is the lack of output schema, so the agent doesn't know the return format, but the description compensates somewhat by indicating what information will be returned (configuration, status, health, deployment details).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters. The description doesn't add any parameter-specific information beyond what's in the schema. The baseline of 3 is appropriate when the schema does the heavy lifting for parameter documentation.
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 detailed information') and resource ('about a specific service'). It distinguishes from siblings like service_list (which lists services) and service_update (which modifies services). The '[API]' prefix further clarifies this is an API operation.
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 through the 'Best for' section listing three specific use cases, plus prerequisite ('service_list'), next steps ('deployment_list, variable_list'), and related tools ('service_update, deployment_trigger'). This gives clear context for when to use this tool versus alternatives.
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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It effectively communicates that this is a mutation tool (implied by 'Restart'), specifies use cases and exclusions, and mentions prerequisites and alternatives. However, it lacks details on potential side effects (e.g., downtime, data loss) or response behavior, which would be helpful for a mutation tool with no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, followed by organized sections (Best for, Not for, Prerequisites, Alternatives, Related). Each sentence earns its place by providing actionable guidance without redundancy, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, the description does an excellent job covering usage context, exclusions, and relationships. It falls short only in not detailing behavioral aspects like potential impacts (e.g., service interruption) or response format, which would enhance completeness given the tool's complexity and lack of structured metadata.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with clear documentation for both parameters (serviceId and environmentId). The description does not add any parameter-specific information beyond what the schema provides, such as format examples or sourcing details. Given the high schema coverage, a baseline score of 3 is appropriate, as the description does not compensate but also does not detract.
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 ('Restart a service') and resource ('in a specific environment'), using a precise verb. It distinguishes this tool from sibling tools like deployment_trigger, service_update, and service_delete by explicitly stating what it is not for, making the purpose unambiguous 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 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 ('Best for: Applying configuration changes, Clearing service state, Resolving runtime issues') and when not to use it ('Not for: Deploying new code, Updating service config, Long-term service stoppage'), with named alternatives for each exclusion. It also lists prerequisites (service_list) and related tools, offering comprehensive usage 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates that this is a creation/mutation tool (implied by 'Create'), specifies use cases and exclusions, and mentions prerequisites and related tools. However, it doesn't explicitly address potential side effects, error conditions, or what happens after creation (e.g., whether the proxy is immediately active).
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 with clear sections (Best for, Not for, Prerequisites, Alternatives, Next steps, Related) using bullet points and icons. Every sentence earns its place by providing actionable guidance without redundancy. The information is front-loaded with the core purpose statement.
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 creation tool with 3 parameters, 100% schema coverage, but no annotations or output schema, the description provides excellent contextual guidance about when and how to use the tool. It covers prerequisites, alternatives, and related operations. The main gap is the lack of information about what the tool returns (since there's no output schema) or potential error conditions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so all parameters are documented in the schema itself. The description doesn't add any additional parameter-specific information beyond what's in the schema (e.g., it doesn't explain parameter relationships or provide examples). This meets the baseline expectation when schema coverage is complete.
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 ('Create a new TCP proxy') and resource ('for a service'), distinguishing it from sibling tools like domain_create for HTTP/HTTPS endpoints. It provides concrete examples of use cases (database access, external connections, exposing TCP services) that clarify the tool's purpose beyond just the name.
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 ('Best for: Setting up database access, Configuring external connections, Exposing TCP services') and when not to use it ('Not for: HTTP/HTTPS endpoints (use domain_create), Internal service communication'). It also lists prerequisites (service_list), alternatives (domain_create), and next/related steps, providing comprehensive guidance for tool selection.
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?
With no annotations provided, the description carries full burden. It effectively communicates this is a deployment/mutation tool (implied by 'Deploy'), mentions prerequisites (template_list), and suggests related operations (service_update, deployment_trigger). However, it doesn't explicitly state permission requirements, rate limits, or what happens if deployment fails, leaving some behavioral aspects unclear.
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 well-structured with clear sections (Best for, Not for, Prerequisites, Alternatives, Next steps, Related) using visual markers (✓, ×, →). Every sentence serves a distinct purpose with zero waste. 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 deployment tool with no annotations and no output schema, the description provides excellent contextual guidance about usage scenarios, alternatives, prerequisites, and next steps. It effectively compensates for the lack of structured behavioral annotations. The only minor gap is not explicitly describing the return value or deployment outcome.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 4 parameters thoroughly. The description adds no additional parameter-specific information beyond what's in the schema. This meets the baseline expectation when schema coverage is complete, but doesn't enhance understanding of parameter semantics.
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 verb+resource: 'Deploy a new service from a template'. It distinguishes from siblings by explicitly mentioning what it's not for (custom configurations, GitHub deployments) and listing alternatives like service_create_from_repo. The [WORKFLOW] tag further clarifies its role.
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 ('Best for: Starting new services from templates, Quick service deployment') and when not to use ('Not for: Custom service configurations, GitHub repository deployments'). It names specific alternatives (service_create_from_repo, service_create_from_image, database_deploy) and lists prerequisites (template_list) and next steps (service_info, variable_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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates the tool's scope (listing all available templates) and hints at its read-only nature through the 'List' action, though it doesn't explicitly mention permissions, rate limits, or pagination. The 'Next steps' section adds useful context about subsequent actions.
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 well-structured with bullet points and icons for readability, front-loading the core purpose. Every sentence earns its place by providing clear guidance, exclusions, alternatives, and related tools without 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 simple list tool with one optional parameter and no output schema, the description is highly complete. It covers purpose, usage guidelines, and context thoroughly. The only minor gap is the lack of explicit mention of output format or pagination, 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.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents the optional 'searchQuery' parameter. The description doesn't add any parameter-specific information beyond what's in the schema, but the baseline score of 3 is appropriate given the high schema coverage.
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 explicitly states the tool's purpose as 'List all available templates on Railway' with a specific verb ('List') and resource ('templates'), clearly distinguishing it from sibling tools like service_list, database_list_types, or volume_list. The '[API]' prefix further clarifies it's an API operation.
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 with 'Best for' and 'Not for' sections, naming specific use cases (discovering templates, planning deployments) and exclusions (listing existing services, getting service details). It also lists alternatives (service_create_from_repo, service_create_from_image) and related tools (database_list_types), offering comprehensive context for when to use this tool.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior by indicating it creates or updates variables, specifies bulk use cases, and notes prerequisites and related tools. However, it lacks details on permissions, rate limits, or error handling, which would enhance transparency further.
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 well-structured with bullet points and icons, making it easy to scan. It is front-loaded with the core purpose and efficiently organized into sections like 'Best for' and 'Not for', with no wasted sentences—each part adds clear value.
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 complexity of a bulk mutation tool with no annotations and no output schema, the description does a good job by covering purpose, usage, and related tools. However, it could improve by detailing output behavior or error cases, which would make it more complete for an agent's understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description does not add specific parameter semantics beyond what the schema provides, such as explaining 'variables' mapping or 'serviceId' optionality in more detail, resulting in a baseline score of 3.
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 ('Create or update') and resource ('multiple environment variables at once'), making the purpose specific. It distinguishes from sibling 'variable_set' by emphasizing bulk operations versus single updates, providing clear differentiation.
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 guidelines with 'Best for' and 'Not for' sections, naming specific scenarios like migration and setup. It lists prerequisites ('service_list'), alternatives ('variable_set'), and next steps ('deployment_trigger'), offering comprehensive guidance on when to use this tool versus others.
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?
With no annotations provided, the description carries full burden and does well by explaining it's for copying variables between environments, mentioning optional service-specific copying, and implying it's a batch operation. However, it doesn't explicitly state whether this is a read-only or mutating operation, or discuss potential side effects like overwriting behavior (though the schema covers the overwrite parameter).
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 with clear sections (purpose, best for, not for, prerequisites, alternatives, next steps, related). Every sentence earns its place, 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 tool with 5 parameters, no annotations, and no output schema, the description provides good context about when to use it, alternatives, prerequisites, and related operations. It could be more complete by explicitly stating whether this is a mutating operation and what the expected output looks like, but it covers most essential usage aspects well.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds minimal parameter-specific information beyond what's in the schema (e.g., mentioning 'shared variables' for the optional serviceId). This meets the baseline expectation when schema coverage is complete.
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 verb ('Copy') and resource ('variables from one environment to another'), and distinguishes it from sibling tools like variable_set for single updates. The '[WORKFLOW]' label and context about environment migration/duplication further clarify its scope.
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 with 'Best for' and 'Not for' sections, naming specific alternatives (variable_set) and prerequisites (service_list). It also lists related tools and next steps, offering comprehensive usage 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior by indicating it can create or update variables, mentions prerequisites (service_list), and hints at next steps (deployment_trigger, service_restart). However, it lacks details on error handling, rate limits, or auth needs, which would be beneficial for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, followed by organized sections (Best for, Not for, Prerequisites, etc.). Every sentence serves a clear purpose without redundancy, making it efficient and easy to scan.
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 (mutation with 5 parameters) and no annotations or output schema, the description does a good job by covering purpose, usage, prerequisites, and related tools. However, it could improve by mentioning the response format or error cases, which are missing despite the lack of output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description does not add any parameter-specific details beyond what the schema provides, such as examples or constraints. This meets the baseline for high schema coverage, but no extra value is added.
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 ('Create or update') and resource ('environment variable'), distinguishing it from siblings like variable_bulk_set for bulk operations and variable_list for viewing. It directly answers what the tool does without ambiguity.
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 with 'Best for' and 'Not for' sections, naming specific use cases (e.g., setting configuration values) and exclusions (e.g., not for bulk updates). It also lists prerequisites (service_list), alternatives (variable_bulk_set), and related tools, offering comprehensive context for when to use this tool.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates that this is a destructive operation ('Delete'), implies permanent removal ('Storage cleanup'), and mentions a prerequisite action ('volume_list'). However, it doesn't specify authentication requirements, rate limits, or error conditions, leaving some behavioral aspects uncovered.
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 well-structured with clear sections (purpose, best for, not for, prerequisites, related), uses bullet points and symbols for readability, and contains no redundant information. Every sentence serves a distinct purpose in guiding tool selection and usage.
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 destructive tool with no annotations and no output schema, the description does an excellent job covering purpose, usage guidelines, and prerequisites. It could be more complete by mentioning potential side effects (e.g., data loss irreversibility) or output expectations, but it's largely sufficient given the context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the single parameter 'volumeId', which is fully documented in the schema. The description doesn't add any parameter-specific information beyond what the schema provides, so it meets the baseline score of 3 for adequate coverage without extra value.
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 ('Delete a volume from a service') with the resource ('volume'), distinguishing it from siblings like volume_create, volume_list, and volume_update. It provides a precise verb+resource combination that leaves no ambiguity about the tool's function.
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 includes explicit 'Best for' and 'Not for' sections with specific use cases (e.g., 'Removing unused storage' vs. 'Temporary data removal'), mentions prerequisites ('volume_list'), and references alternatives ('use volume_backup first'). This provides comprehensive guidance on when to use this tool versus others.
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:

[![railway-mcp MCP server](https://glama.ai/mcp/servers/epitaphe360/railway-mcp/badges/card.svg)](https://glama.ai/mcp/servers/epitaphe360/railway-mcp)

Score Badge

Copy to your README.md:

[![railway-mcp MCP server](https://glama.ai/mcp/servers/epitaphe360/railway-mcp/badges/score.svg)](https://glama.ai/mcp/servers/epitaphe360/railway-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/epitaphe360/railway-mcp'

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